目录 什么是HardFault中断 HardFault触发后如何回溯 异常发生在主栈情况下 异常发生在任务栈情况下 如何判断发生在主栈还是任务栈 以LN882HM为例看如何实现
什么是HardFault中断 在 ARM Cortex-M 系列处理器中,HardFault 是一种用于处理严重错误的系统异常。
程序运行过程中,如果发生非法内存访问、总线访问错误、非法指令执行、除零等错误,处理器可能产生 MemManage、BusFault 或 UsageFault。当对应异常未启用或无法正常处理时,异常可能升级为 HardFault。
发生 HardFault 后,可以通过读取异常现场保存的 PC、LR、xPSR 等寄存器,以及 SCB 中的故障状态寄存器,定位异常发生的位置并分析故障原因。
HardFault触发后如何回溯 这里有两种情况,第一种在RTOS的任务中触发也有可能在调度器或者硬件中断执行时发生。
异常发生在主栈情况下 主栈情况下比较简单因为没有切换栈,直接从栈里面倒着推就好了
异常发生在任务栈情况下
发生异常后内核自动完成部分寄存器(R0、R1、R2、R3、R12、LR、PC、xPSR)压栈到PSP,再切换到MSP执行HardFault中断函数。
在中断函数中R0、R1、R2、R3、R12、LR、PC、xPSR已经变为中断函数的相关数据而不是任务现场了,所以在这里需要进行任务回溯。
读取PSP指针位置获取到最近一次执行的任务栈,此时任务栈中保存的数据即为异常中断进入前R0、R1、R2、R3、R12、LR、PC、xPSR,这里将数据打印出来,特别是PC指针,再根据elf文件获取到当时任务的执行函数和具体行数。
如何判断发生在主栈还是任务栈 这里插个关于内核方面的知识,在ARM-Cortex内核中可以通过LR寄存器的bit2来判断发生来源
以LN882HM为例看如何实现 亮牛封装的比较好,所以这里以亮牛代码为例
1 2 3 4 5 6 7 8 9 10 11 12 13 __asm void fault_handler(void){ IMPORT cm_backtrace_fault MOV R0 , LR MOV R1 , SP BL __cpp(cm_backtrace_fault) B . }
这里把LR拷到R0,SP拷到R1,调用C函数用于传参,我们来看cm_backtrace_fault实现
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void cm_backtrace_fault (uint32_t fault_handler_lr, uint32_t fault_handler_sp) { uint32_t stack_pointer = fault_handler_sp, saved_regs_addr = stack_pointer, tcb_stack_pointer = 0 ; const char *regs_name[] = { "R0 " , "R1 " , "R2 " , "R3 " , "R12" , "LR " , "PC " , "PSR" }; #ifdef CMB_USING_DUMP_STACK_INFO uint32_t stack_start_addr = main_stack_start_addr; size_t stack_size = main_stack_size; #endif CMB_ASSERT(init_ok); CMB_ASSERT(!on_fault); on_fault = true ; cmb_println("" ); cm_backtrace_firmware_info();
前面主要一些初始化判断还有打印固件信息没啥好说的
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #ifdef CMB_USING_OS_PLATFORM on_thread_before_fault = fault_handler_lr & (1UL << 2 ); if (on_thread_before_fault) { cmb_println(print_info[PRINT_FAULT_ON_THREAD], get_cur_thread_name() != NULL ? get_cur_thread_name() : "NO_NAME" ); saved_regs_addr = stack_pointer = cmb_get_psp(); #ifdef CMB_USING_DUMP_STACK_INFO get_cur_thread_stack_info(&tcb_stack_pointer, &stack_start_addr, &stack_size); #endif } else { cmb_println(print_info[PRINT_FAULT_ON_HANDLER]); } #else cmb_println(print_info[PRINT_FAULT_ON_HANDLER]); #endif
这里通过LR寄存器,bit2判断发生中断前是PSP还是MSP,并且获取到对应栈顶指针
1 2 stack_pointer += sizeof (size_t ) * 8 ;
跳过异常栈帧也就是内核自动保存的R0~R3, R12, LR,PC,xPSR八个寄存器(ARM栈向下生长,所以加8*4字节)
1 2 3 4 #if (CMB_CPU_PLATFORM_TYPE == CMB_CPU_ARM_CORTEX_M4) || (CMB_CPU_PLATFORM_TYPE == CMB_CPU_ARM_CORTEX_M7) || \ (CMB_CPU_PLATFORM_TYPE == CMB_CPU_ARM_CORTEX_M33) stack_pointer = statck_del_fpu_regs(fault_handler_lr, stack_pointer); #endif
判断是否使用FPU扩展异常栈帧,如果有则跳过
1 2 3 4 5 6 7 8 9 10 11 12 13 #ifdef CMB_USING_DUMP_STACK_INFO if (stack_pointer < stack_start_addr || stack_pointer > stack_start_addr + stack_size) { cmb_println("stack_pointer: 0x%08x, stack_start_addr: 0x%08x, stack_end_addr: 0x%08x" , stack_pointer, stack_start_addr, stack_start_addr + stack_size); stack_is_overflow = true ; #if (CMB_OS_PLATFORM_TYPE == CMB_OS_PLATFORM_RTT) if (on_thread_before_fault) { stack_pointer = tcb_stack_pointer; } #endif }
紧接着栈溢出检测
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 dump_stack(stack_start_addr, stack_size, (uint32_t *) stack_pointer); #endif { cmb_println(print_info[PRINT_REGS_TITLE]); regs.saved.r0 = ((uint32_t *)saved_regs_addr)[0 ]; regs.saved.r1 = ((uint32_t *)saved_regs_addr)[1 ]; regs.saved.r2 = ((uint32_t *)saved_regs_addr)[2 ]; regs.saved.r3 = ((uint32_t *)saved_regs_addr)[3 ]; regs.saved.r12 = ((uint32_t *)saved_regs_addr)[4 ]; regs.saved.lr = ((uint32_t *)saved_regs_addr)[5 ]; regs.saved.pc = ((uint32_t *)saved_regs_addr)[6 ]; regs.saved.psr.value = ((uint32_t *)saved_regs_addr)[7 ]; cmb_println(" %s: %08x %s: %08x %s: %08x %s: %08x" , regs_name[0 ], regs.saved.r0, regs_name[1 ], regs.saved.r1, regs_name[2 ], regs.saved.r2, regs_name[3 ], regs.saved.r3); cmb_println(" %s: %08x %s: %08x %s: %08x %s: %08x" , regs_name[4 ], regs.saved.r12, regs_name[5 ], regs.saved.lr, regs_name[6 ], regs.saved.pc, regs_name[7 ], regs.saved.psr.value); cmb_println("==============================================================" ); }
7.将栈数据打印出来,包括出错现场
1 2 3 4 5 6 7 8 9 10 11 12 13 14 #if (CMB_CPU_PLATFORM_TYPE != CMB_CPU_ARM_CORTEX_M0) regs.syshndctrl.value = CMB_SYSHND_CTRL; regs.mfsr.value = CMB_NVIC_MFSR; regs.mmar = CMB_NVIC_MMAR; regs.bfsr.value = CMB_NVIC_BFSR; regs.bfar = CMB_NVIC_BFAR; regs.ufsr.value = CMB_NVIC_UFSR; regs.hfsr.value = CMB_NVIC_HFSR; regs.dfsr.value = CMB_NVIC_DFSR; regs.afsr = CMB_NVIC_AFSR; fault_diagnosis(); #endif
通过 Cortex-M4 的 SCB(System Control Block,系统控制块) 辅助判断异常原因
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 static void print_call_stack (uint32_t sp) { size_t i, cur_depth = 0 ; uint32_t call_stack_buf[CMB_CALL_STACK_MAX_DEPTH] = {0 }; cur_depth = cm_backtrace_call_stack(call_stack_buf, CMB_CALL_STACK_MAX_DEPTH, sp); for (i = 0 ; i < cur_depth; i++) { sprintf (call_stack_info + i * (8 + 1 ), "%08lx" , (unsigned long )call_stack_buf[i]); call_stack_info[i * (8 + 1 ) + 8 ] = ' ' ; } if (cur_depth) { cmb_println(print_info[PRINT_CALL_STACK_INFO], fw_name, CMB_ELF_FILE_EXTENSION_NAME, cur_depth * (8 + 1 ), call_stack_info); } else { cmb_println(print_info[PRINT_CALL_STACK_ERR]); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 size_t cm_backtrace_call_stack (uint32_t *buffer, size_t size, uint32_t sp) { uint32_t stack_start_addr = main_stack_start_addr, pc; #ifdef CMB_USING_OS_PLATFORM uint32_t tcb_sp; #endif size_t depth = 0 , stack_size = main_stack_size; bool regs_saved_lr_is_valid = false ; if (on_fault) { if (!stack_is_overflow) { buffer[depth++] = regs.saved.pc; pc = regs.saved.lr - 1 ; if ((pc >= code_start_addr) && (pc <= code_start_addr + code_size) && (depth < CMB_CALL_STACK_MAX_DEPTH) && (depth < size)) { buffer[depth++] = pc; regs_saved_lr_is_valid = true ; } } #ifdef CMB_USING_OS_PLATFORM if (on_thread_before_fault) { get_cur_thread_stack_info(&tcb_sp, &stack_start_addr, &stack_size); } } else { if (cmb_get_sp() == cmb_get_psp()) { get_cur_thread_stack_info(&tcb_sp, &stack_start_addr, &stack_size); } #endif } if (stack_is_overflow) { sp = stack_start_addr; } for (; sp < stack_start_addr + stack_size; sp += sizeof (size_t )) { pc = *((uint32_t *) sp) - sizeof (size_t ); if (pc % 2 == 0 ) { continue ; } pc = *((uint32_t *) sp) - 1 ; if ((pc >= code_start_addr + sizeof (size_t )) && (pc <= code_start_addr + code_size) && (depth < CMB_CALL_STACK_MAX_DEPTH) && disassembly_ins_is_bl_blx(pc - sizeof (size_t )) && (depth < size)) { if ((depth == 2 ) && regs_saved_lr_is_valid && (pc == buffer[1 ])) { continue ; } buffer[depth++] = pc; } } return depth; }
采用栈扫描方式推测调用链并打印出来,个人认为这块写的很精妙
1 2 3 4 if (cur_depth) { cmb_println(print_info[PRINT_CALL_STACK_INFO], fw_name, CMB_ELF_FILE_EXTENSION_NAME, cur_depth * (8 + 1 ), call_stack_info); }
通过addr2line指令找到函数入口,例如PC: 08003456 LR: 08001235则命令打印展开后为
1 addr2line -e firmware.elf -afpiC 0x08003456 0x08001234