From 20cdb2439f7e76f78d2618220fc1a0061afd57cd Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 11 Dec 2013 00:23:15 -0800 Subject: libpayload: Make it possible to install callbacks for particular exceptions. To support a GDB stub, it will be necessary to trap various exceptions which will be used to implement breakpoints, single stepping, etc. BUG=None TEST=Built and booted on Link with hooks installed and saw that they triggered when exceptions occurred. Built and booted on nyan. BRANCH=None Original-Change-Id: Iab659365864a3055159a50b8f6e5c44290d3ba2b Original-Signed-off-by: Gabe Black Original-Reviewed-on: https://chromium-review.googlesource.com/179602 Original-Reviewed-by: Gabe Black Original-Tested-by: Gabe Black Original-Commit-Queue: Gabe Black (cherry picked from commit 8db0897b1ddad600e247cb4df147c757a8187626) Signed-off-by: Marc Jones Change-Id: I5e7f724b99988cd259909dd3bd01166fa52317ec Reviewed-on: http://review.coreboot.org/7656 Tested-by: build bot (Jenkins) Reviewed-by: Paul Menzel Reviewed-by: Ronald G. Minnich --- payloads/libpayload/arch/x86/exception.c | 152 +++++++++++++-------------- payloads/libpayload/arch/x86/exception_asm.S | 13 ++- 2 files changed, 85 insertions(+), 80 deletions(-) (limited to 'payloads/libpayload/arch/x86') diff --git a/payloads/libpayload/arch/x86/exception.c b/payloads/libpayload/arch/x86/exception.c index a9a65ca5a2..33bef71e66 100644 --- a/payloads/libpayload/arch/x86/exception.c +++ b/payloads/libpayload/arch/x86/exception.c @@ -27,39 +27,27 @@ * SUCH DAMAGE. */ +#include #include #include #include uint8_t exception_stack[0x1000] __attribute__((aligned(8))); extern void *exception_stack_end; +extern struct exception_handler_state *exception_handler_state_handoff; -struct exception_state +struct exception_handler_state { - u32 eax; - u32 ecx; - u32 edx; - u32 ebx; - u32 esp; - u32 ebp; - u32 esi; - u32 edi; - u32 eip; - u32 eflags; - u32 cs; - u32 ss; - u32 ds; - u32 es; - u32 fs; - u32 gs; + struct exception_state regs; u32 error_code; u32 vector; } __attribute__((packed)); -struct exception_info +struct exception_handler_info { const char *name; void (*error_code_printer)(u32 code); + exception_hook hook; }; static void print_segment_error_code(u32 code) @@ -105,34 +93,34 @@ static void print_raw_error_code(u32 code) printf("%#x", code); } -static struct exception_info exceptions[] = { - [0] = { .name = "divide by zero" }, - [1] = { .name = "debug" }, - [2] = { .name = "non-maskable-interrupt" }, - [3] = { .name = "breakpoint" }, - [4] = { .name = "overflow" }, - [5] = { .name = "bound range" }, - [6] = { .name = "invalid opcode" }, - [7] = { .name = "device not available" }, - [8] = { .name = "double fault", - .error_code_printer = &print_raw_error_code }, - [10] = { .name = "invalid tss", - .error_code_printer = &print_segment_error_code }, - [11] = { .name = "segment not present", - .error_code_printer = &print_segment_error_code }, - [12] = { .name = "stack", - .error_code_printer = &print_segment_error_code }, - [13] = { .name = "general protection", - .error_code_printer = &print_segment_error_code }, - [14] = { .name = "page fault", - .error_code_printer = &print_page_fault_error_code }, - [16] = { .name = "x87 floating point" }, - [17] = { .name = "alignment check", - .error_code_printer = &print_raw_error_code }, - [18] = { .name = "machine check" }, - [19] = { .name = "SIMD floating point" }, - [30] = { .name = "security", - .error_code_printer = &print_raw_error_code }, +static struct exception_handler_info exceptions[EXC_COUNT] = { + [EXC_DE] = { .name = "divide by zero" }, + [EXC_DB] = { .name = "debug" }, + [EXC_NMI] = { .name = "non-maskable-interrupt" }, + [EXC_BP] = { .name = "breakpoint" }, + [EXC_OF] = { .name = "overflow" }, + [EXC_BR] = { .name = "bound range" }, + [EXC_UD] = { .name = "invalid opcode" }, + [EXC_NM] = { .name = "device not available" }, + [EXC_DF] = { .name = "double fault", + .error_code_printer = &print_raw_error_code }, + [EXC_TS] = { .name = "invalid tss", + .error_code_printer = &print_segment_error_code }, + [EXC_NP] = { .name = "segment not present", + .error_code_printer = &print_segment_error_code }, + [EXC_SS] = { .name = "stack", + .error_code_printer = &print_segment_error_code }, + [EXC_GP] = { .name = "general protection", + .error_code_printer = &print_segment_error_code }, + [EXC_PF] = { .name = "page fault", + .error_code_printer = &print_page_fault_error_code }, + [EXC_MF] = { .name = "x87 floating point" }, + [EXC_AC] = { .name = "alignment check", + .error_code_printer = &print_raw_error_code }, + [EXC_MC] = { .name = "machine check" }, + [EXC_XF] = { .name = "SIMD floating point" }, + [EXC_SX] = { .name = "security", + .error_code_printer = &print_raw_error_code }, }; static void dump_stack(uintptr_t addr, size_t bytes) @@ -150,16 +138,9 @@ static void dump_stack(uintptr_t addr, size_t bytes) } } -void exception_handler(void); -void exception_handler(void) +static void dump_exception_state(struct exception_handler_state *state, + struct exception_handler_info *info) { - struct exception_state *state = - (void *)((u8 *)exception_stack_end - sizeof(*state)); - - struct exception_info *info = NULL; - if (state->vector < ARRAY_SIZE(exceptions)) - info = &exceptions[state->vector]; - if (info) printf("Exception %d (%s)\n", state->vector, info->name); else @@ -169,31 +150,50 @@ void exception_handler(void) info->error_code_printer(state->error_code); printf("\n"); } - printf("EIP: 0x%08x\n", state->eip); - printf("CS: 0x%04x\n", state->cs); - printf("EFLAGS: 0x%08x\n", state->eflags); - printf("EAX: 0x%08x\n", state->eax); - printf("ECX: 0x%08x\n", state->ecx); - printf("EDX: 0x%08x\n", state->edx); - printf("EBX: 0x%08x\n", state->ebx); - printf("ESP: 0x%08x\n", state->esp); - printf("EBP: 0x%08x\n", state->ebp); - printf("ESI: 0x%08x\n", state->esi); - printf("EDI: 0x%08x\n", state->edi); - printf("DS: 0x%04x\n", state->ds); - printf("ES: 0x%04x\n", state->es); - printf("SS: 0x%04x\n", state->ss); - printf("FS: 0x%04x\n", state->fs); - printf("GS: 0x%04x\n", state->gs); - - dump_stack(state->esp, 512); - - halt(); + printf("EIP: 0x%08x\n", state->regs.eip); + printf("CS: 0x%04x\n", state->regs.cs); + printf("EFLAGS: 0x%08x\n", state->regs.eflags); + printf("EAX: 0x%08x\n", state->regs.eax); + printf("ECX: 0x%08x\n", state->regs.ecx); + printf("EDX: 0x%08x\n", state->regs.edx); + printf("EBX: 0x%08x\n", state->regs.ebx); + printf("ESP: 0x%08x\n", state->regs.esp); + printf("EBP: 0x%08x\n", state->regs.ebp); + printf("ESI: 0x%08x\n", state->regs.esi); + printf("EDI: 0x%08x\n", state->regs.edi); + printf("DS: 0x%04x\n", state->regs.ds); + printf("ES: 0x%04x\n", state->regs.es); + printf("SS: 0x%04x\n", state->regs.ss); + printf("FS: 0x%04x\n", state->regs.fs); + printf("GS: 0x%04x\n", state->regs.gs); +} + +void exception_dispatch(void) +{ + struct exception_handler_state *state = + exception_handler_state_handoff; + + struct exception_handler_info *info = NULL; + if (state->vector < EXC_COUNT) + info = &exceptions[state->vector]; + + if (info && info->hook) { + info->hook(state->vector, &state->regs); + } else { + dump_exception_state(state, info); + dump_stack(state->regs.esp, 512); + halt(); + } } -void exception_init_asm(void); void exception_init(void) { exception_stack_end = exception_stack + sizeof(exception_stack); exception_init_asm(); } + +void exception_install_hook(int type, exception_hook hook) +{ + die_if(type >= EXC_COUNT, "Out of bound exception type %d.\n", type); + exceptions[type].hook = hook; +} diff --git a/payloads/libpayload/arch/x86/exception_asm.S b/payloads/libpayload/arch/x86/exception_asm.S index c56a7a0bab..de612ba057 100644 --- a/payloads/libpayload/arch/x86/exception_asm.S +++ b/payloads/libpayload/arch/x86/exception_asm.S @@ -31,6 +31,9 @@ .global exception_stack_end exception_stack_end: .long 0 + .global exception_handler_state_handoff +exception_handler_state_handoff: + .long 0 /* Some temporary variables which are used while saving exception state. */ vector: @@ -134,11 +137,13 @@ exception_common: pushl old_eax /* - * Call the C exception handler. It will find the exception state on - * the exception stack. Not passing parameters means we don't have to - * worry about what ABI is being used. + * Call the C exception handler. It will find the exception state + * using the exception_handler_state_handoff global pointer. Not + * passing parameters means we don't have to worry about what ABI + * is being used. */ - call exception_handler + mov %esp, exception_handler_state_handoff + call exception_dispatch /* * Restore state from the exception state structure, including any -- cgit v1.2.3