231 lines
7.2 KiB
C
231 lines
7.2 KiB
C
/*
|
|
* Copyright (c) 2014 Travis Geiselbrecht
|
|
*
|
|
* Use of this source code is governed by a MIT-style
|
|
* license that can be found in the LICENSE file or at
|
|
* https://opensource.org/licenses/MIT
|
|
*/
|
|
#include <stdio.h>
|
|
#include <lk/debug.h>
|
|
#include <lk/bits.h>
|
|
#include <arch/arch_ops.h>
|
|
#include <arch/arm64.h>
|
|
|
|
#define SHUTDOWN_ON_FATAL 1
|
|
|
|
struct fault_handler_table_entry {
|
|
uint64_t pc;
|
|
uint64_t fault_handler;
|
|
};
|
|
|
|
struct fault_status_map {
|
|
uint32_t fsc;
|
|
const char *fault_msg;
|
|
};
|
|
|
|
/* Instruction and Data abort share the fault status encoding */
|
|
static const struct fault_status_map fsc_map[] = {
|
|
{
|
|
.fsc = 0b000000,
|
|
.fault_msg = "Address size fault, level 0 of translation or translation table base register"
|
|
},
|
|
{
|
|
.fsc = 0b000001,
|
|
.fault_msg = "Address size fault, level 1"
|
|
},
|
|
{
|
|
.fsc = 0b000010,
|
|
.fault_msg = "Address size fault, level 2"
|
|
},
|
|
{
|
|
.fsc = 0b000011,
|
|
.fault_msg = "Address size fault, level 3"
|
|
},
|
|
{
|
|
.fsc = 0b000100,
|
|
.fault_msg = "Translation fault, level 0"
|
|
},
|
|
{
|
|
.fsc = 0b000101,
|
|
.fault_msg = "Translation fault, level 1"
|
|
},
|
|
{
|
|
.fsc = 0b000110,
|
|
.fault_msg = "Translation fault, level 2"
|
|
},
|
|
{
|
|
.fsc = 0b000111,
|
|
.fault_msg = "Translation fault, level 3"
|
|
},
|
|
{
|
|
.fsc = 0b001001,
|
|
.fault_msg = "Access flag fault, level 1"
|
|
},
|
|
{
|
|
.fsc = 0b001010,
|
|
.fault_msg = "Access flag fault, level 2"
|
|
},
|
|
{
|
|
.fsc = 0b001011,
|
|
.fault_msg = "Access flag fault, level 3"
|
|
},
|
|
{
|
|
.fsc = 0b001101,
|
|
.fault_msg = "Permission fault, level 1"
|
|
},
|
|
{
|
|
.fsc = 0b001110,
|
|
.fault_msg = "Permission fault, level 2"
|
|
},
|
|
{
|
|
.fsc = 0b001111,
|
|
.fault_msg = "Permission fault, level 3"
|
|
},
|
|
{
|
|
.fsc = 0b010000,
|
|
.fault_msg = "Synchronous External abort, not on translation table walk"
|
|
},
|
|
{
|
|
.fsc = 0b010001,
|
|
.fault_msg = "Synchronous Tag Check fail"
|
|
},
|
|
{
|
|
.fsc = 0b010100,
|
|
.fault_msg = "Synchronous External abort, on translation table walk, level 0"
|
|
},
|
|
{
|
|
.fsc = 0b010101,
|
|
.fault_msg = "Synchronous External abort, on translation table walk, level 1"
|
|
},
|
|
{
|
|
.fsc = 0b010110,
|
|
.fault_msg = "Synchronous External abort, on translation table walk, level 2"
|
|
},
|
|
{
|
|
.fsc = 0b010111,
|
|
.fault_msg = "Synchronous External abort, on translation table walk, level 3"
|
|
},
|
|
{
|
|
.fsc = 0b100001,
|
|
.fault_msg = "Alignment fault"
|
|
},
|
|
{
|
|
.fsc = 0b110000,
|
|
.fault_msg = "TLB conflict abort"
|
|
},
|
|
{
|
|
.fsc = 0b111101,
|
|
.fault_msg = "Section Domain Fault, used only for faults reported in the PAR_EL1"
|
|
},
|
|
{
|
|
.fsc = 0b111110,
|
|
.fault_msg = "Page Domain Fault, used only for faults reported in the PAR_EL1"
|
|
},
|
|
};
|
|
|
|
static void print_fault_msg(uint32_t fsc)
|
|
{
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < countof(fsc_map); i++) {
|
|
if (fsc_map[i].fsc == fsc) {
|
|
printf("%s\n", fsc_map[i].fault_msg);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern struct fault_handler_table_entry __fault_handler_table_start[];
|
|
extern struct fault_handler_table_entry __fault_handler_table_end[];
|
|
|
|
static void dump_iframe(const struct arm64_iframe_long *iframe) {
|
|
printf("iframe %p:\n", iframe);
|
|
printf("x0 0x%16llx x1 0x%16llx x2 0x%16llx x3 0x%16llx\n", iframe->r[0], iframe->r[1], iframe->r[2], iframe->r[3]);
|
|
printf("x4 0x%16llx x5 0x%16llx x6 0x%16llx x7 0x%16llx\n", iframe->r[4], iframe->r[5], iframe->r[6], iframe->r[7]);
|
|
printf("x8 0x%16llx x9 0x%16llx x10 0x%16llx x11 0x%16llx\n", iframe->r[8], iframe->r[9], iframe->r[10], iframe->r[11]);
|
|
printf("x12 0x%16llx x13 0x%16llx x14 0x%16llx x15 0x%16llx\n", iframe->r[12], iframe->r[13], iframe->r[14], iframe->r[15]);
|
|
printf("x16 0x%16llx x17 0x%16llx x18 0x%16llx x19 0x%16llx\n", iframe->r[16], iframe->r[17], iframe->r[18], iframe->r[19]);
|
|
printf("x20 0x%16llx x21 0x%16llx x22 0x%16llx x23 0x%16llx\n", iframe->r[20], iframe->r[21], iframe->r[22], iframe->r[23]);
|
|
printf("x24 0x%16llx x25 0x%16llx x26 0x%16llx x27 0x%16llx\n", iframe->r[24], iframe->r[25], iframe->r[26], iframe->r[27]);
|
|
printf("x28 0x%16llx x29 0x%16llx lr 0x%16llx usp 0x%16llx\n", iframe->r[28], iframe->r[29], iframe->lr, iframe->usp);
|
|
printf("elr 0x%16llx\n", iframe->elr);
|
|
printf("spsr 0x%16llx\n", iframe->spsr);
|
|
arch_stacktrace(iframe->r[29], iframe->elr);
|
|
}
|
|
|
|
__WEAK void arm64_syscall(struct arm64_iframe_long *iframe, bool is_64bit) {
|
|
panic("unhandled syscall vector\n");
|
|
}
|
|
|
|
void arm64_sync_exception(struct arm64_iframe_long *iframe);
|
|
void arm64_sync_exception(struct arm64_iframe_long *iframe) {
|
|
struct fault_handler_table_entry *fault_handler;
|
|
uint32_t esr = ARM64_READ_SYSREG(esr_el1);
|
|
uint32_t ec = BITS_SHIFT(esr, 31, 26);
|
|
uint32_t il = BIT(esr, 25);
|
|
uint32_t iss = BITS(esr, 24, 0);
|
|
|
|
switch (ec) {
|
|
case 0b000111: /* floating point */
|
|
arm64_fpu_exception(iframe);
|
|
return;
|
|
case 0b010001: /* syscall from arm32 */
|
|
case 0b010101: /* syscall from arm64 */
|
|
#ifdef WITH_LIB_SYSCALL
|
|
void arm64_syscall(struct arm64_iframe_long *iframe);
|
|
arch_enable_fiqs();
|
|
arm64_syscall(iframe);
|
|
arch_disable_fiqs();
|
|
return;
|
|
#else
|
|
arm64_syscall(iframe, (ec == 0x15) ? true : false);
|
|
return;
|
|
#endif
|
|
case 0b100000: /* instruction abort from lower level */
|
|
case 0b100001: /* instruction abort from same level */
|
|
printf("instruction abort: PC at 0x%llx\n", iframe->elr);
|
|
print_fault_msg(BITS(iss, 5, 0));
|
|
break;
|
|
case 0b100100: /* data abort from lower level */
|
|
case 0b100101: { /* data abort from same level */
|
|
for (fault_handler = __fault_handler_table_start;
|
|
fault_handler < __fault_handler_table_end;
|
|
fault_handler++) {
|
|
if (fault_handler->pc == iframe->elr) {
|
|
iframe->elr = fault_handler->fault_handler;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* read the FAR register */
|
|
uint64_t far = ARM64_READ_SYSREG(far_el1);
|
|
|
|
printf("data fault: %s access from PC 0x%llx, FAR 0x%llx, iss 0x%x (DFSC 0x%lx)\n",
|
|
BIT(iss, 6) ? "Write" : "Read", iframe->elr, far, iss, BITS(iss, 5, 0));
|
|
print_fault_msg(BITS(iss, 5, 0));
|
|
break;
|
|
}
|
|
case 0b111100: {
|
|
printf("BRK #0x%04lx instruction: PC at 0x%llx\n",
|
|
BITS_SHIFT(iss, 15, 0), iframe->elr);
|
|
break;
|
|
}
|
|
default:
|
|
printf("unhandled synchronous exception\n");
|
|
}
|
|
|
|
/* unhandled exception, die here */
|
|
printf("ESR 0x%x: ec 0x%x, il 0x%x, iss 0x%x\n", esr, ec, il, iss);
|
|
dump_iframe(iframe);
|
|
|
|
panic("die\n");
|
|
}
|
|
|
|
void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which);
|
|
void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which) {
|
|
printf("invalid exception, which 0x%x\n", which);
|
|
dump_iframe(iframe);
|
|
|
|
panic("die\n");
|
|
}
|