什么是HardFault中断

在 ARM Cortex-M 系列处理器中,HardFault 是一种用于处理严重错误的系统异常。

程序运行过程中,如果发生非法内存访问、总线访问错误、非法指令执行、除零等错误,处理器可能产生 MemManage、BusFault 或 UsageFault。当对应异常未启用或无法正常处理时,异常可能升级为 HardFault。

发生 HardFault 后,可以通过读取异常现场保存的 PC、LR、xPSR 等寄存器,以及 SCB 中的故障状态寄存器,定位异常发生的位置并分析故障原因。

HardFault触发后如何回溯

这里有两种情况,第一种在RTOS的任务中触发也有可能在调度器或者硬件中断执行时发生。

异常发生在主栈情况下

主栈情况下比较简单因为没有切换栈,直接从栈里面倒着推就好了

异常发生在任务栈情况下

  1. 发生异常后内核自动完成部分寄存器(R0、R1、R2、R3、R12、LR、PC、xPSR)压栈到PSP,再切换到MSP执行HardFault中断函数。

  2. 在中断函数中R0、R1、R2、R3、R12、LR、PC、xPSR已经变为中断函数的相关数据而不是任务现场了,所以在这里需要进行任务回溯。

  3. 读取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)
{
#ifdef CFG_USING_CM_BACKTRACE
IMPORT cm_backtrace_fault
#endif

MOV R0, LR
MOV R1, SP
#ifdef CFG_USING_CM_BACKTRACE
BL __cpp(cm_backtrace_fault)
#endif
B .
}
  1. 这里把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);
/* only call once */
CMB_ASSERT(!on_fault);

on_fault = true;

cmb_println("");
cm_backtrace_firmware_info();
  1. 前面主要一些初始化判断还有打印固件信息没啥好说的
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);
/* check which stack was used before (MSP or PSP) */
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 /* CMB_USING_DUMP_STACK_INFO */

} else {
cmb_println(print_info[PRINT_FAULT_ON_HANDLER]);
}
#else
/* bare metal(no OS) environment */
cmb_println(print_info[PRINT_FAULT_ON_HANDLER]);
#endif /* CMB_USING_OS_PLATFORM */
  1. 这里通过LR寄存器,bit2判断发生中断前是PSP还是MSP,并且获取到对应栈顶指针
1
2
/* delete saved R0~R3, R12, LR,PC,xPSR registers space */
stack_pointer += sizeof(size_t) * 8;
  1. 跳过异常栈帧也就是内核自动保存的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 /* (CMB_CPU_PLATFORM_TYPE == CMB_CPU_ARM_CORTEX_M4) || (CMB_CPU_PLATFORM_TYPE == CMB_CPU_ARM_CORTEX_M7) */
  1. 判断是否使用FPU扩展异常栈帧,如果有则跳过
1
2
3
4
5
6
7
8
9
10
11
12
13
#ifdef CMB_USING_DUMP_STACK_INFO
/* check stack overflow */
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) {
/* change the stack start adder to TCB->sp when stack is overflow */
stack_pointer = tcb_stack_pointer;
}
#endif
}
  1. 紧接着栈溢出检测
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 information */
dump_stack(stack_start_addr, stack_size, (uint32_t *) stack_pointer);
#endif /* CMB_USING_DUMP_STACK_INFO */

{
/* dump register */
cmb_println(print_info[PRINT_REGS_TITLE]);

regs.saved.r0 = ((uint32_t *)saved_regs_addr)[0]; // Register R0
regs.saved.r1 = ((uint32_t *)saved_regs_addr)[1]; // Register R1
regs.saved.r2 = ((uint32_t *)saved_regs_addr)[2]; // Register R2
regs.saved.r3 = ((uint32_t *)saved_regs_addr)[3]; // Register R3
regs.saved.r12 = ((uint32_t *)saved_regs_addr)[4]; // Register R12
regs.saved.lr = ((uint32_t *)saved_regs_addr)[5]; // Link register LR
regs.saved.pc = ((uint32_t *)saved_regs_addr)[6]; // Program counter PC
regs.saved.psr.value = ((uint32_t *)saved_regs_addr)[7]; // Program status word PSR

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
    /* the Cortex-M0 is not support fault diagnosis */
#if (CMB_CPU_PLATFORM_TYPE != CMB_CPU_ARM_CORTEX_M0)
regs.syshndctrl.value = CMB_SYSHND_CTRL; // System Handler Control and State Register
regs.mfsr.value = CMB_NVIC_MFSR; // Memory Fault Status Register
regs.mmar = CMB_NVIC_MMAR; // Memory Management Fault Address Register
regs.bfsr.value = CMB_NVIC_BFSR; // Bus Fault Status Register
regs.bfar = CMB_NVIC_BFAR; // Bus Fault Manage Address Register
regs.ufsr.value = CMB_NVIC_UFSR; // Usage Fault Status Register
regs.hfsr.value = CMB_NVIC_HFSR; // Hard Fault Status Register
regs.dfsr.value = CMB_NVIC_DFSR; // Debug Fault Status Register
regs.afsr = CMB_NVIC_AFSR; // Auxiliary Fault Status Register

fault_diagnosis();
#endif
  1. 通过 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) {
/* first depth is PC */
buffer[depth++] = regs.saved.pc;
/* fix the LR address in thumb mode */
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
/* program is running on thread before fault */
if (on_thread_before_fault) {
get_cur_thread_stack_info(&tcb_sp, &stack_start_addr, &stack_size);
}
} else {
/* OS environment */
if (cmb_get_sp() == cmb_get_psp()) {
get_cur_thread_stack_info(&tcb_sp, &stack_start_addr, &stack_size);
}
#endif /* CMB_USING_OS_PLATFORM */

}

if (stack_is_overflow) {
sp = stack_start_addr;
}

/* copy called function address */
for (; sp < stack_start_addr + stack_size; sp += sizeof(size_t)) {
/* the *sp value may be LR, so need decrease a word to PC */
pc = *((uint32_t *) sp) - sizeof(size_t);
/* the Cortex-M using thumb instruction, so the pc must be an odd number */
if (pc % 2 == 0) {
continue;
}
/* fix the PC address in thumb mode */
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)
/* check the the instruction before PC address is 'BL' or 'BLX' */
&& disassembly_ins_is_bl_blx(pc - sizeof(size_t)) && (depth < size)) {
/* the second depth function may be already saved, so need ignore repeat */
if ((depth == 2) && regs_saved_lr_is_valid && (pc == buffer[1])) {
continue;
}
buffer[depth++] = pc;
}
}

return depth;
}
  1. 采用栈扫描方式推测调用链并打印出来,个人认为这块写的很精妙
  • 地址是否符合 Thumb 模式的特征。

  • 地址是否位于程序代码区间内。

  • 地址附近是否存在 BL 或 BLX 函数调用指令。

  • 是否超过调用栈缓冲区容量。

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);
}
  1. 通过addr2line指令找到函数入口,例如PC: 08003456 LR: 08001235则命令打印展开后为
1
addr2line -e firmware.elf -afpiC 0x08003456 0x08001234