21ic电子技术开发论坛 › 个人版区 › 贝贝的实验室 › ARM cortex-M 系列 HardFault的诊断
返回列表 发新帖我要提问

ARM cortex-M 系列 HardFault的诊断

[复制链接]
2072|9
 楼主| keer_zu 发表于 2022-1-26 11:20 | 显示全部楼层 |阅读模式
ar, AD, TE, cortex-, Cortex-M, HardFault
本帖最后由 keer_zu 于 2022-1-26 11:22 编辑

（转自 aozima）rt-thread问答。

ARM cortex-M上面的fault想必大家都不陌生，我相信还没有谁从来没有出现过fault。
但出现fault后如何排查，相信很多人都是一筹莫展。
在我的项目中加了一些代码，Fault 后可以打印出更多的信息。
复制
  1. #define SCB_CFSR        (*(volatile const unsigned *)0xE000ED28) /* Configurable Fault Status Register */
    

  2. #define SCB_HFSR        (*(volatile const unsigned *)0xE000ED2C) /* HardFault Status Register */
    

  3. #define SCB_MMAR        (*(volatile const unsigned *)0xE000ED34) /* MemManage Fault Address register */
    

  4. #define SCB_BFAR        (*(volatile const unsigned *)0xE000ED38) /* Bus Fault Address Register */
    


  5. 

  6. #define SCB_CFSR_MFSR   (*(volatile const unsigned char*)0xE000ED28)  /* Memory-management Fault Status Register */
    

  7. #define SCB_CFSR_BFSR   (*(volatile const unsigned char*)0xE000ED29)  /* Bus Fault Status Register */
    

  8. #define SCB_CFSR_UFSR   (*(volatile const unsigned short*)0xE000ED2A) /* Usage Fault Status Register */
    


  9. 

  10. static void usage_fault_track(void)
    

  11. {
    

  12.     rt_kprintf("usage fault:
    

  13. ");
    

  14.     rt_kprintf("SCB_CFSR_UFSR:0x%02X ", SCB_CFSR_UFSR);
    


  15. 

  16.     if(SCB_CFSR_UFSR & (1<<0))
    

  17.     {
    

  18.         /* [0]:UNDEFINSTR */
    

  19.         rt_kprintf("UNDEFINSTR ");
    

  20.     }
    


  21. 

  22.     if(SCB_CFSR_UFSR & (1<<1))
    

  23.     {
    

  24.         /* [1]:INVSTATE */
    

  25.         rt_kprintf("INVSTATE ");
    

  26.     }
    


  27. 

  28.     if(SCB_CFSR_UFSR & (1<<2))
    

  29.     {
    

  30.         /* [2]:INVPC */
    

  31.         rt_kprintf("INVPC ");
    

  32.     }
    


  33. 

  34.     if(SCB_CFSR_UFSR & (1<<3))
    

  35.     {
    

  36.         /* [3]:NOCP */
    

  37.         rt_kprintf("NOCP ");
    

  38.     }
    


  39. 

  40.     if(SCB_CFSR_UFSR & (1<<8))
    

  41.     {
    

  42.         /* [8]:UNALIGNED */
    

  43.         rt_kprintf("UNALIGNED ");
    

  44.     }
    


  45. 

  46.     if(SCB_CFSR_UFSR & (1<<9))
    

  47.     {
    

  48.         /* [9]:DIVBYZERO */
    

  49.         rt_kprintf("DIVBYZERO ");
    

  50.     }
    


  51. 

  52.     rt_kprintf("
    

  53. ");
    

  54. }
    


  55. 

  56. static void bus_fault_track(void)
    

  57. {
    

  58.     rt_kprintf("bus fault:
    

  59. ");
    

  60.     rt_kprintf("SCB_CFSR_BFSR:0x%02X ", SCB_CFSR_BFSR);
    


  61. 

  62.     if(SCB_CFSR_BFSR & (1<<0))
    

  63.     {
    

  64.         /* [0]:IBUSERR */
    

  65.         rt_kprintf("IBUSERR ");
    

  66.     }
    


  67. 

  68.     if(SCB_CFSR_BFSR & (1<<1))
    

  69.     {
    

  70.         /* [1]:PRECISERR */
    

  71.         rt_kprintf("PRECISERR ");
    

  72.     }
    


  73. 

  74.     if(SCB_CFSR_BFSR & (1<<2))
    

  75.     {
    

  76.         /* [2]:IMPRECISERR */
    

  77.         rt_kprintf("IMPRECISERR ");
    

  78.     }
    


  79. 

  80.     if(SCB_CFSR_BFSR & (1<<3))
    

  81.     {
    

  82.         /* [3]:UNSTKERR */
    

  83.         rt_kprintf("UNSTKERR ");
    

  84.     }
    


  85. 

  86.     if(SCB_CFSR_BFSR & (1<<4))
    

  87.     {
    

  88.         /* [4]:STKERR */
    

  89.         rt_kprintf("STKERR ");
    

  90.     }
    


  91. 

  92.     if(SCB_CFSR_BFSR & (1<<7))
    

  93.     {
    

  94.         rt_kprintf("SCB->BFAR:%08X
    

  95. ", SCB_BFAR);
    

  96.     }
    

  97.     else
    

  98.     {
    

  99.         rt_kprintf("
    

  100. ");
    

  101.     }
    

  102. }
    


  103. 

  104. static void mem_manage_fault_track(void)
    

  105. {
    

  106.     rt_kprintf("mem manage fault:
    

  107. ");
    

  108.     rt_kprintf("SCB_CFSR_MFSR:0x%02X ", SCB_CFSR_MFSR);
    


  109. 

  110.     if(SCB_CFSR_MFSR & (1<<0))
    

  111.     {
    

  112.         /* [0]:IACCVIOL */
    

  113.         rt_kprintf("IACCVIOL ");
    

  114.     }
    


  115. 

  116.     if(SCB_CFSR_MFSR & (1<<1))
    

  117.     {
    

  118.         /* [1]:DACCVIOL */
    

  119.         rt_kprintf("DACCVIOL ");
    

  120.     }
    


  121. 

  122.     if(SCB_CFSR_MFSR & (1<<3))
    

  123.     {
    

  124.         /* [3]:MUNSTKERR */
    

  125.         rt_kprintf("MUNSTKERR ");
    

  126.     }
    


  127. 

  128.     if(SCB_CFSR_MFSR & (1<<4))
    

  129.     {
    

  130.         /* [4]:MSTKERR */
    

  131.         rt_kprintf("MSTKERR ");
    

  132.     }
    


  133. 

  134.     if(SCB_CFSR_MFSR & (1<<7))
    

  135.     {
    

  136.         /* [7]:MMARVALID */
    

  137.         rt_kprintf("SCB->MMAR:%08X
    

  138. ", SCB_MMAR);
    

  139.     }
    

  140.     else
    

  141.     {
    

  142.         rt_kprintf("
    

  143. ");
    

  144.     }
    

  145. }
    


  146. 

  147. static void hard_fault_track(void)
    

  148. {
    

  149.     if(SCB_HFSR & (1UL<<1))
    

  150.     {
    

  151.         /* [1]:VECTBL, Indicates hard fault is caused by failed vector fetch. */
    

  152.         rt_kprintf("failed vector fetch
    

  153. ");
    

  154.     }
    


  155. 

  156.     if(SCB_HFSR & (1UL<<30))
    

  157.     {
    

  158.         /* [30]:FORCED, Indicates hard fault is taken because of bus fault,
    

  159.                         memory management fault, or usage fault. */
    

  160.         if(SCB_CFSR_BFSR)
    

  161.         {
    

  162.             bus_fault_track();
    

  163.         }
    


  164. 

  165.         if(SCB_CFSR_MFSR)
    

  166.         {
    

  167.             mem_manage_fault_track();
    

  168.         }
    


  169. 

  170.         if(SCB_CFSR_UFSR)
    

  171.         {
    

  172.             usage_fault_track();
    

  173.         }
    

  174.     }
    


  175. 

  176.     if(SCB_HFSR & (1UL<<31))
    

  177.     {
    

  178.         /* [31]:DEBUGEVT, Indicates hard fault is triggered by debug event. */
    

  179.         rt_kprintf("debug event
    

  180. ");
    

  181.     }
    

  182. }
    


  183. 

  184. /**
    

  185.  * fault exception handling
    

  186.  */
    

  187. void rt_hw_hard_fault_exception(struct stack_context* contex)
    

  188. {
    

  189.     rt_kprintf("psr: 0x%08x
    

  190. ", contex->psr);
    

  191.     rt_kprintf(" pc: 0x%08x
    

  192. ", contex->pc);
    

  193.     rt_kprintf(" lr: 0x%08x
    

  194. ", contex->lr);
    

  195.     rt_kprintf("r12: 0x%08x
    

  196. ", contex->r12);
    

  197.     rt_kprintf("r03: 0x%08x
    

  198. ", contex->r3);
    

  199.     rt_kprintf("r02: 0x%08x
    

  200. ", contex->r2);
    

  201.     rt_kprintf("r01: 0x%08x
    

  202. ", contex->r1);
    

  203.     rt_kprintf("r00: 0x%08x
    

  204. ", contex->r0);
    


  205. 

  206.     hard_fault_track();
    


  207. 

  208.     rt_kprintf("hard fault on thread: %s
    

  209. ", rt_current_thread->name);
    

  210. #ifdef RT_USING_FINSH
    

  211.     list_thread();
    

  212. #endif
    

  213.     while (1);
    

  214. }

回复

收藏1 举报

相关帖子
 楼主| keer_zu 发表于 2022-1-26 11:23 | 显示全部楼层
再写了两个测试代码，以手动触发fault。
复制
  1. void div0_test(void)
    

  2. {
    

  3.     volatile int * SCB_CCR = (volatile int *)0xE000ED14; // SCB->CCR
    

  4.     int x,y,z;
    


  5. 

  6.     *SCB_CCR |= (1 << 4); /* bit4: DIV_0_TRP. */
    


  7. 

  8.     x = 10;
    

  9.     y = 0;
    

  10.     z = x / y;
    

  11.     rt_kprintf("z:%d
    

  12. ", z);
    

  13. }
    


  14. 

  15. void unalign_test(void)
    

  16. {
    

  17.     volatile int * SCB_CCR = (volatile int *)0xE000ED14; // SCB->CCR
    

  18.     volatile int * p;
    

  19.     volatile int value;
    


  20. 

  21.     *SCB_CCR |= (1 << 3); /* bit3: UNALIGN_TRP. */
    


  22. 

  23.     p = (int *)0x00;
    

  24.     value = *p;
    

  25.     rt_kprintf("addr:0x%02X value:0x%08X
    

  26. ", (int)p, value);
    


  27. 

  28.     p = (int *)0x04;
    

  29.     value = *p;
    

  30.     rt_kprintf("addr:0x%02X value:0x%08X
    

  31. ", (int)p, value);
    


  32. 

  33.     p = (int *)0x03;
    

  34.     value = *p;
    

  35.     rt_kprintf("addr:0x%02X value:0x%08X
    

  36. ", (int)p, value);
    

  37. }
    


  38. 

  39. #ifdef  RT_USING_FINSH
    

  40. #include <finsh.h>
    

  41. FINSH_FUNCTION_EXPORT(div0_test, div0_test)
    

  42. FINSH_FUNCTION_EXPORT(unalign_test, unalign_test)
    

  43. #endif /* RT_USING_FINSH */
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:23 | 显示全部楼层
测试访问末授权区域
复制
  1. finsh>>int * p //声明一个指针变量
    

  2.         0, 0x00000000
    

  3. finsh>>p = 0xDFFFFFF0 // 指向片上外设区结束处，一般不可能用完，所以此处一般不可访问。
    

  4.         -536870928, 0xdffffff0
    

  5. finsh>>*p // 读取指针处数据
    

  6. psr: 0x01000000
    

  7.  pc: 0x00000e3e
    

  8.  lr: 0x0000451d
    

  9. r12: 0x00000000
    

  10. r03: 0x00000000
    

  11. r02: 0x1fff0180
    

  12. r01: 0x1fff0814
    

  13. r00: 0xdffffff0
    

  14. bus fault:
    

  15. SCB_CFSR_BFSR:0x82 PRECISERR SCB->BFAR:DFFFFFF0
    

  16. hard fault on thread: tshell
    

  17.  thread  pri  status      sp     stack size max used   left tick  error
    

  18. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  19. tidle    0x1f ready   0x00000040 0x00000100 0x00000060 0x00000015 000
    

  20. tshell   0x14 ready   0x00000088 0x00000400 0x00000218 0x00000009 000
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:24 | 显示全部楼层
非对齐访问测试
复制
  1. finsh>>unalign_test()
    

  2. addr:0x00 value:0x20001B80
    

  3. addr:0x04 value:0x0800DE81
    

  4. psr: 0x21000000
    

  5. r00: 0x00000000
    

  6. r01: 0x40013800
    

  7. r02: 0x20000690
    

  8. r03: 0x00000000
    

  9. r04: 0x00000003
    

  10. r05: 0xe000ed14
    

  11. r06: 0xdeadbeef
    

  12. r07: 0x20002678
    

  13. r08: 0xdeadbeef
    

  14. r09: 0xdeadbeef
    

  15. r10: 0xdeadbeef
    

  16. r11: 0xdeadbeef
    

  17. r12: 0x08000a95
    

  18.  lr: 0x08002eb5
    

  19.  pc: 0x08000386
    

  20. usage fault:
    

  21. SCB_CFSR_UFSR:0x100 UNALIGNED
    

  22. hard fault on thread: tshell
    

  23.  thread  pri  status      sp     stack size max used   left tick  error
    

  24. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  25. tidle    0x1f ready   0x00000040 0x00000100 0x0000005c 0x00000009 000
    

  26. tshell   0x14 ready   0x00000088 0x00000800 0x000001b0 0x0000000a 000
    

  27. led      0x14 suspend 0x00000078 0x00000200 0x00000078 0x00000005 000
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:24 | 显示全部楼层
除零异常测试
复制
  1. finsh>>div0_test()
    

  2. psr: 0x41000000
    

  3. r00: 0x00000010
    

  4. r01: 0x08000337
    

  5. r02: 0x20000bb7
    

  6. r03: 0x20000130
    

  7. r04: 0xe000ed14
    

  8. r05: 0x00000000
    

  9. r06: 0xdeadbeef
    

  10. r07: 0x0000000a
    

  11. r08: 0xdeadbeef
    

  12. r09: 0xdeadbeef
    

  13. r10: 0xdeadbeef
    

  14. r11: 0xdeadbeef
    

  15. r12: 0x00000000
    

  16.  lr: 0x08008d91
    

  17.  pc: 0x08000348
    

  18. usage fault:
    

  19. SCB_CFSR_UFSR:0x200 DIVBYZERO
    

  20. hard fault on thread: tshell
    

  21.  thread  pri  status      sp     stack size max used   left tick  error
    

  22. -------- ---- ------- ---------- ---------- ---------- ---------- ---
    

  23. tidle    0x1f ready   0x00000058 0x00000100 0x0000005c 0x0000000f 000
    

  24. tshell   0x14 ready   0x00000088 0x00000800 0x000001b0 0x0000000a 000
    

  25. led      0x14 suspend 0x00000078 0x00000200 0x00000078 0x00000005 000
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:24 | 显示全部楼层
问题追踪
上面测试出了问题，是我们人为设置的故障，但在平时调试中出了问题如何追综呢？
以非对齐访问为例，开发环境使用MDK。

进入JTAG仿真状态，并触发非对齐异常。
此时串口会打印出异常时的寄存器值，此时停止仿真器发现程序停在rt_hw_hard_fault_exception中。

根据上面打印出来的寄存器，提取出关键值是 pc: 0x08000386
我们在MDK的command窗口中输入 pc = 0x08000386
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:24 | 显示全部楼层
7517261f0bf063f5f2.png
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:25 | 显示全部楼层
可以把PC指针临时设回问题发生时的场景，我们看到出现问题的指令是
复制
  1.    239:     p = (int *)0x03; 
    

  2. 0x08000384 2403      MOVS     r4,#0x03
    

  3.    240:     value = *p; 
    

  4. 0x08000386 6820      LDR      r0,[r4,#0x00]
    

  5. 0x08000388 9000      STR      r0,[sp,#0x00]
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:25 | 显示全部楼层
分析 #386 这条指令从 R4+0 的问题读取4字节到R0中，
先前打印出的R4的值为 r04: 0x00000003
因此可以确定为这是因为地址不对齐造成的。

9874161f0bf29a89c3.png
回复

收藏1 举报

 楼主| keer_zu 发表于 2022-1-26 11:26 | 显示全部楼层
本帖最后由 keer_zu 于 2022-1-26 11:28 编辑

当然，具体情况要具体分析，有时候某个步骤出现问题并不会马上崩溃，
而是过一段时间以后才出问题，因此要结合上下文综合分析。
比如上面这个案例真正有问题的指令是 0x08000384。

根据以上的案例，并结合实际调试经验，相信大家可以更快地找出问题。

下面是ST研究会上面的PPT，供参考。
stm32Hard Fault的诊断.pdf
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

keer_zu
个人签名：qq群：49734243 Email:zukeqiang@gmail.com

1488

主题

12949

帖子

55

粉丝
快速回复 在线客服 返回列表 返回顶部