AIGC标识 栈调试心得

栈调试心得

本文档由两部分内容整理合并而来:

  1. 通用的栈信息打印原理、方法和排查流程。
  2. 本项目中 FCCU_FaultInitTask 重启问题排查过程中总结出的 retained debug、栈余量、栈哨兵和阶段记录经验。

目标是形成一份可以反复参考的栈调试实践文档:既能理解原理,也能直接应用到 RT-Thread / Cortex-M / 嵌入式项目的问题定位中。

  1. 如何获取栈信息
    使用rt_thread_self()获取当前线程
    使用rt_thread_self()->stack_addr获取当前线程的栈地址(栈底,高地址)——栈从高地址向低地址生长,倒置的杯子
    使用rt_thread_self()->stack_size获取当前线程的栈大小,结合栈地址可获得栈顶地址(低地址)
    在函数内定义一个局部变量,该局部变量的地址即是当前栈的sp,
    通过当前栈的sp和栈顶地址即可算出当前栈的剩余空间,即可确认问题是否是栈溢出导致的
    eg:
    volatile rt_uint32_t stack_marker = FCCU_DBG_MAGIC;
    rt_thread_t self = rt_thread_self();
    rt_uint32_t stack_addr = FCCU_DBG_STACK_INVALID;
    rt_uint32_t stack_size = 0U;
    rt_uint32_t current_sp = (rt_uint32_t)&stack_marker;
    rt_uint32_t stack_remaining = FCCU_DBG_STACK_INVALID;

    if (RT_NULL != self)
    {
    stack_addr = (rt_uint32_t)self->stack_addr;
    stack_size = self->stack_size;
    if ((current_sp >= stack_addr) && (current_sp <= (stack_addr + stack_size)))
    {
    stack_remaining = current_sp - stack_addr;
    }
    }

  2. 软复位的ram保留区如何做
    GCC:
    在链接脚本中定义一个.debug_data段,将其放在ram特定位置,利用__attribute__((section(".debug_data")))声明变量,即可实现变量软复位时不被清除。
    eg:/* 在 RAM 中定义不初始化段 /
    .noinit (NOLOAD) :
    {
    . = ALIGN(4);
    KEEP(
    (.noinitdata))
    . = ALIGN(4);
    } >RAM
    uint32_t my_retained_data attribute((section(".noinitdata")));
    keil:
    Keil 使用分散加载文件(Scatter File, .sct)来控制内存布局。在 RAM 区域单独划出一块,加上 UNINIT 属性。使用__attribute__((section("NO_INIT"), zero_init))声明变量
    eg://假设你的普通 RAM 是 RW_IRAM1
    RW_IRAM1 0x20000000 0x0000A000 { ; RW data
    *.o (+RW +ZI)
    }

    // 新增不初始化区域
    NOINIT_RAM 0x2000A000 UNINIT 0x00002000 { ; UNINIT 关键字是关键
    *.o (NO_INIT)
    }
    unsigned char my_retained_data[256] attribute((section("NO_INIT"), zero_init));
    IAR:
    使用__no_init关键字,在.icf文件中,定义一个不被初始化的块,使用__no_init声明变量
    eg:define block NoInitBlock with alignment = 4, size = 0x2000 { };
    initialize by copy { readwrite };
    do not initialize { section .noinit, block NoInitBlock };
    __no_init volatile uint32_t my_retained_data;

  3. log打印有延迟,无法准确表明当前程序执行位置
    方法1:在需要进行打印的节点,写入一个上电不会复位的变量(ram保留区,变量需用volatile),每执行一个节点修改这个变量的数据
    对于保留区已有的数据,可以建立一个结构体将其包括在内,以防止调试变量被污染,在软复位后打印这个变量的数值即可观察复位前精确执行到哪一步。

    方法2:在打印后增加延时,确保打印顺利完成,此方法适用于复位原因与时间无关的情况

  4. 栈哨兵的使用方法及作用
    在函数内定义一个volatile局部变量,在函数内的某个子函数返回时检查这个变量的数值是否和定义时一直,如果不一致说明发生了栈踩踏。
    还有一种方法是使用rt_memset将剩余所有栈空间全写成魔数
    此方法仅作为特定情况的检查,rtt本身有栈溢出检测功能RT_USING_OVERFLOW_CHECK,优先使用rtt提供的功能


1. 栈调试到底在调什么

“栈调试”本质上是在观察程序运行时的这些信息:

  1. 当前线程是谁。
  2. 当前线程栈起始地址是多少。
  3. 当前线程栈大小是多少。
  4. 当前 SP 大概在哪里。
  5. 当前还剩多少栈空间。
  6. 历史最大使用过多少栈。
  7. 栈附近有没有被踩踏。
  8. 崩溃或复位前最后执行到哪个阶段。
  9. 如果进入异常,PC / LR / SP 指向哪里。

很多嵌入式问题表面看是:

  • 随机重启
  • 偶现 HardFault
  • 串口日志打印不完整
  • 程序卡死
  • 函数还没返回就复位
  • 某个变量莫名其妙被改

但底层可能是:

  • 线程栈溢出
  • 局部数组太大
  • 函数调用链太深
  • 中断嵌套消耗栈
  • 返回地址被踩
  • 函数指针异常
  • log 还没发完就复位
  • 硬件异步复位,软件日志无法准确反映最后执行点

所以栈调试的核心价值是:把“感觉像随机问题”的现象,变成可以用地址、阶段号、栈余量和寄存器现场分析的问题。


2. 栈的基本原理

2.1 栈是什么

栈是一块连续内存,用来保存函数运行时的临时数据,常见内容包括:

局部变量
函数参数
返回地址
保存的寄存器
中断现场
异常现场

栈的特点是后进先出:

函数调用时压栈
函数返回时出栈

2.2 栈增长方向

在 ARM Cortex-M 和很多嵌入式平台上,栈通常从高地址向低地址增长。

可以把它想象成一个倒置的杯子:

高地址  stack_addr + stack_size  <- 初始 SP 附近
        已使用区域向下增长
        ...
低地址  stack_addr               <- 栈底 / 低地址边界

随着函数调用变深,SP 会逐渐变小。

对于向低地址增长的栈:

stack_addr <= current_sp <= stack_addr + stack_size

当前剩余栈空间可以近似计算为:

stack_remaining = current_sp - stack_addr;

如果:

current_sp < stack_addr

基本说明栈已经越界。


3. 在 RT-Thread 中获取当前线程栈信息

3.1 获取当前线程

在 RT-Thread 中,可以使用:

rt_thread_t self = rt_thread_self();

获取当前线程对象。

常用字段:

self->stack_addr
self->stack_size

其中:

self->stack_addr  当前线程栈低地址边界
self->stack_size  当前线程栈大小

3.2 获取当前 SP 的实用方法

在普通 C 函数中,可以定义一个 volatile 局部变量,然后取它的地址,作为当前栈位置的近似值:

volatile rt_uint32_t stack_marker = FCCU_DBG_MAGIC;
rt_uint32_t current_sp = (rt_uint32_t)&stack_marker;

原因是局部变量通常分配在当前函数栈帧中,所以它的地址可以近似代表当前 SP 附近的位置。

注意:这不是 CPU 硬件 SP 的精确值,但用于判断当前线程栈剩余空间通常足够实用。

3.3 当前栈剩余空间计算示例

volatile rt_uint32_t stack_marker = FCCU_DBG_MAGIC;
rt_thread_t self = rt_thread_self();
rt_uint32_t stack_addr = FCCU_DBG_STACK_INVALID;
rt_uint32_t stack_size = 0U;
rt_uint32_t current_sp = (rt_uint32_t)&stack_marker;
rt_uint32_t stack_remaining = FCCU_DBG_STACK_INVALID;

if (RT_NULL != self)
{
    stack_addr = (rt_uint32_t)self->stack_addr;
    stack_size = self->stack_size;

    if ((current_sp >= stack_addr) &&
        (current_sp <= (stack_addr + stack_size)))
    {
        stack_remaining = current_sp - stack_addr;
    }
}

这段代码适合用于:

  • 判断当前线程是否接近栈溢出。
  • 把栈余量保存到 retained RAM,复位后再分析。
  • 在关键路径前后记录栈余量变化。

4. MSP、PSP 与硬件 SP

在 ARM Cortex-M 上常见两个栈指针:

MSP: Main Stack Pointer
PSP: Process Stack Pointer

一般来说:

  • 裸机主流程通常使用 MSP。
  • RTOS 线程通常使用 PSP。
  • 中断 / 异常入口通常使用 MSP。

可以用内联汇编读取:

static inline uint32_t dbg_get_msp(void)
{
    uint32_t value;
    __asm volatile ("MRS %0, msp" : "=r" (value));
    return value;
}

static inline uint32_t dbg_get_psp(void)
{
    uint32_t value;
    __asm volatile ("MRS %0, psp" : "=r" (value));
    return value;
}

打印:

void dbg_print_sp(void)
{
    rt_kprintf("MSP = 0x%08x\n", dbg_get_msp());
    rt_kprintf("PSP = 0x%08x\n", dbg_get_psp());
}

在 RTOS 线程里排查线程栈时,一般更关注 PSP 或线程对象中保存的栈信息。


5. 当前栈使用量与历史最大栈使用量

5.1 当前栈使用量

当前栈使用量依赖当前 SP:

current_used = stack_top - current_sp;
current_free = current_sp - stack_bottom;

对于向低地址增长的栈:

stack_bottom = stack_addr
stack_top    = stack_addr + stack_size

当前栈使用量只能说明“此刻”用了多少栈。

缺点是:如果最危险的调用链已经返回,当前 SP 又恢复了,看起来就会比较安全。

5.2 历史最大栈使用量

更可靠的方法是“栈填充法”。

线程创建时,RTOS 或调试代码把栈填成固定值,例如:

0x23
0xA5
0xCCCCCCCC

程序运行后,真正用过的栈区域会被覆盖。扫描还保持填充值的区域,就能知道历史最大栈使用量。

示例:

uint32_t dbg_calc_stack_max_used(uint8_t *stack_start,
                                 uint32_t stack_size,
                                 uint8_t pattern)
{
    uint32_t unused = 0;

    while ((unused < stack_size) && (stack_start[unused] == pattern))
    {
        unused++;
    }

    return stack_size - unused;
}

这个方法能发现“曾经差点爆栈”,即使现在 SP 看起来正常。


6. 栈哨兵的使用方法和作用

6.1 局部栈哨兵

在函数内定义一个 volatile 局部变量,在执行某个可疑子函数前后检查它是否被改写:

volatile rt_uint32_t guard0 = FCCU_STACK_GUARD0;
volatile rt_uint32_t guard1 = FCCU_STACK_GUARD1;

some_suspicious_function();

if ((FCCU_STACK_GUARD0 != guard0) ||
    (FCCU_STACK_GUARD1 != guard1))
{
    /* 说明当前函数栈帧附近可能被踩踏 */
}

用途:

  • 判断子函数是否破坏了调用者栈。
  • 判断局部数组越界是否覆盖到相邻栈变量。
  • 在没有 HardFault 的情况下发现轻微栈踩踏。

6.2 剩余栈空间填魔数

另一种方法是把剩余栈区域写成魔数,再检查魔数是否被覆盖。

但注意:

  • 这种方法更适合特定场景定点排查。
  • 不应随意覆盖正在使用的栈区域。
  • RT-Thread 本身有栈溢出检测功能,优先使用系统提供能力。

RT-Thread 可关注:

RT_USING_OVERFLOW_CHECK

如果系统已经开启栈溢出检测,应优先相信 RTT 的机制,再结合自定义 retained debug 细化定位。


7. log 打印延迟与 retained debug

7.1 为什么不能只依赖串口 log

串口 log 有延迟,rt_kprintf() 返回也不一定代表数据已经完整发出。

如果复位发生在:

  • rt_kprintf() 内部
  • 串口缓冲发送过程中
  • 某个硬件操作刚执行完
  • 异步复位源触发时

那么最后看到的 log 可能是不完整的,例如:

FCCU_MD?
FCCU1R?
F?

所以“最后一条串口 log”不一定等于“最后执行位置”。

7.2 方法一:使用软复位 RAM 保留区记录 stage

在关键节点写入一个软复位不会清除的变量:

volatile uint32_t stage;

每执行到一个关键位置就更新:

stage = 0x4400U;
FCCU_FaultPinInit();
stage = 0x4401U;

复位后下一次启动时打印 retained stage,就能知道上一次复位前最后记录到哪里。

7.3 方法二:打印后增加延时

如果复位原因与时间无关,可以在关键打印后加延时,确保串口发送完成。

但这个方法有明显局限:

  • 可能改变时序。
  • 不适合强时序问题。
  • 不适合 watchdog / 外设异步复位类问题。

所以更推荐 retained stage。


8. 软复位 RAM 保留区做法

8.1 GCC

在链接脚本中定义一个不初始化段,例如 .noinit:

.noinit (NOLOAD) :
{
    . = ALIGN(4);
    KEEP(*(.noinitdata))
    . = ALIGN(4);
} >RAM

变量声明:

uint32_t my_retained_data __attribute__((section(".noinitdata")));

核心点:

NOLOAD 表示启动时不从镜像加载
不初始化段表示软复位后不会被 C runtime 清零

8.2 Keil

Keil 使用 scatter file 控制内存布局,单独划出 UNINIT 区域:

RW_IRAM1 0x20000000 0x0000A000  {
    *.o (+RW +ZI)
}

NOINIT_RAM 0x2000A000 UNINIT 0x00002000  {
    *.o (NO_INIT)
}

变量声明:

unsigned char my_retained_data[256]
    __attribute__((section("NO_INIT"), zero_init));

8.3 IAR

IAR 可以使用 __no_init,并在 .icf 中定义不初始化块:

define block NoInitBlock with alignment = 4, size = 0x2000 { };
initialize by copy { readwrite };
do not initialize  { section .noinit, block NoInitBlock };

变量声明:

__no_init volatile uint32_t my_retained_data;

9. retained debug 结构体建议

单个 stage 变量虽然简单,但实际排查时通常不够。建议建立结构体,集中保存:

  • magic
  • stage
  • guard 状态
  • 函数返回值
  • reset type
  • stack addr
  • stack size
  • current sp
  • stack remaining
  • debug 参数

示例:

#define FCCU_DBG_MAGIC          (0x46554343U)
#define FCCU_DBG_RESET_UNKNOWN  (0xFFU)
#define FCCU_DBG_STACK_INVALID  (0xFFFFFFFFU)

typedef struct fccu_retained_debug
{
    rt_uint8_t md5_check_code[FCCU_MD5_CHECK_CODE_LENGTH];
    volatile rt_uint32_t magic;
    volatile rt_uint32_t stage;
    volatile rt_uint32_t stack_guard_status;
    volatile rt_int32_t ret;
    volatile rt_uint32_t reset_type;
    volatile rt_uint32_t stack_addr;
    volatile rt_uint32_t stack_size;
    volatile rt_uint32_t current_sp;
    volatile rt_uint32_t stack_remaining;
    volatile rt_uint32_t debug_arg0;
    volatile rt_uint32_t debug_arg1;
} fccu_retained_debug_t;

初始化时必须做 magic 校验:

static void Fccu_RetainedDebugInitIfNeeded(void)
{
    if (FCCU_DBG_MAGIC != fccu_retained_debug.magic)
    {
        (void)memset((void *)&fccu_retained_debug,
                     0,
                     sizeof(fccu_retained_debug));

        fccu_retained_debug.magic = FCCU_DBG_MAGIC;
        fccu_retained_debug.stack_guard_status = FCCU_STACK_GUARD_OK;
        fccu_retained_debug.reset_type = FCCU_DBG_RESET_UNKNOWN;
        fccu_retained_debug.stack_remaining = FCCU_DBG_STACK_INVALID;
    }
}

9.1 为什么必须有 magic

保留区不会被清零,所以里面可能残留:

  • 上一个版本的结构体内容
  • 旧 MD5 字符串
  • 未定义数据
  • 旧布局下写入的数据

曾经出现过类似无效值:

last stage=66306363 guard=39313033
last stage=a076a9af guard=b897ad2d

这些不是我们定义的 stage。

所以必须用 magic 区分:

当前代码版本写入的有效 retained 数据
历史残留或旧布局数据

没有 magic,last stage/guard 不可信。


10. retained stage 记录原则

10.1 每个阶段号必须唯一

阶段号要避免冲突。

例如曾经有过:

4500/4501 同时被外层 fal_init 阶段和内层 FCCU_FaultErrorPinSetUp 使用

这会导致日志解释歧义。

建议:

0x1000 - 0x1FFF  参数校验
0x2000 - 0x2FFF  MD5 检查
0x4000 - 0x4FFF  FCCU_FaultInitTask 外层流程
0x4400 - 0x44FF  FCCU_FaultPinInit
0x4500 - 0x45FF  FCCU_FaultErrorPinSetUp

同一个 stage 不要在不同上下文复用。

10.2 关键调用前后都要记录

错误示例:

some_function();
stage = 0x1001U;

如果复位发生在 some_function() 内部,就不知道是否进入了该函数。

更好的方式:

stage = 0x1000U;
some_function();
stage = 0x1001U;

含义明确:

停在 1000:进入 some_function 前或函数内部复位
停在 1001:some_function 已返回

10.3 对极短窗口继续细分

如果日志停在:

last st=4502

而下一步马上是分支判断:

if (0U != cciFault)
{
    stage = 0x4512U;
}
else
{
    stage = 0x4522U;
}

可以进一步加入:

FCCU_RetainedDebugStageRecord(0x4520U);
if (0U != cciFault)
{
    FCCU_RetainedDebugStageRecord(0x4521U);
    ...
}
else
{
    FCCU_RetainedDebugStageRecord(0x4522U);
    ...
}

如果仍停在 4520,说明复位可能不是具体分支代码导致,而是异步复位刚好发生在该时间窗口。


11. FCCU_FaultInitTask 重启问题排查笔记

11.1 问题概述

执行 shell 命令:

FCCU_FaultInitTask

现象:程序在 FCCU 初始化过程中出现自动重启,但没有 HardFault,电源也确认稳定。

排查范围最终收敛到:

FCCU_FaultInitTask()
  -> FCCU_FaultPinInit()
     -> FCCU_FaultErrorPinSetUp()

关键异常日志:

FFCCU_FaultInitTask
last st=4502 gd=a55a0000 ret=0 rst=0 free=7964
FCCU0
reset type 0
?

该日志说明:

上一次复位前最后记录点是 0x4502
FCCU_FaultCCIRegTotalGet() 已经返回
后续还没有记录到更细的阶段

12. 排查点一:是否是 MD5 或参数表检查导致重启

12.1 测试方法

在 Fccu_FaultParamListCheck() 中加入局部栈 guard 和 retained stage:

volatile rt_uint32_t guard0 = FCCU_STACK_GUARD0;
volatile rt_uint32_t guard1 = FCCU_STACK_GUARD1;

Fccu_RetainedDebugRecord(0x1002U, ret, reset_type);
utils_md5((const rt_uint8_t*)Fccu_FaultParamListGet(),
          length,
          fccu_retained_debug.md5_check_code);
Fccu_RetainedDebugRecord(0x1003U, ret, reset_type);

if ((FCCU_STACK_GUARD0 != guard0) ||
    (FCCU_STACK_GUARD1 != guard1))
{
    fccu_retained_debug.stack_guard_status = FCCU_STACK_GUARD_BROKEN_POWER_MD5;
}

非上电路径也对 checkMD5() 前后记录 stage。

12.2 观察日志

last st=3001 gd=a55a0000 ret=0 rst=0 free=7988

12.3 结论

  • stage=3001 表示 Fccu_FaultParamListCheck() 已经执行到末尾。
  • guard=a55a0000 表示局部栈 guard 未被破坏。
  • ret=0 表示 MD5 校验路径返回正常。

因此可以排除:

  • utils_md5() 内部直接导致稳定重启。
  • checkMD5() 内部直接导致稳定重启。
  • Fccu_FaultParamListCheck() 内部破坏调用者栈。

13. 排查点二:是否是 FCCU_FaultInitTask 外层流程导致

在 FCCU_FaultInitTask() 每个关键调用前后写 stage:

Fccu_RetainedDebugRecord(0x4000U, ret, reset_type);
rt_kprintf("FCCU0\n");

Fccu_RetainedDebugRecord(0x4001U, ret, reset_type);
ret = Fccu_FaultParamListCheck();
Fccu_RetainedDebugRecord(0x4002U, ret, reset_type);

Fccu_RetainedDebugRecord(0x4300U, ret, reset_type);
FCCU_FaultCCIRegInit();
Fccu_RetainedDebugRecord(0x4301U, ret, reset_type);

Fccu_RetainedDebugRecord(0x4400U, ret, reset_type);
FCCU_FaultPinInit();
Fccu_RetainedDebugRecord(0x4401U, ret, reset_type);

Fccu_RetainedDebugRecord(0x4600U, ret, reset_type);
NVMLOG_init();
Fccu_RetainedDebugRecord(0x4601U, ret, reset_type);

Fccu_RetainedDebugRecord(0x4FFFU, ret, reset_type);

曾经捕获到:

last st=4400 gd=a55a0000 ret=0 rst=0 free=7988

说明已经记录进入 FCCU_FaultPinInit() 前,但没有记录到返回后的 4401。

后来通过更多日志确认,单条不完整日志不能作为最终结论,但它帮助把范围收敛到:

FCCU_FaultPinInit();

14. 排查点三:注释 FCCU_FaultPinInit 后验证

临时注释:

Fccu_RetainedDebugRecord(0x4400U, ret, reset_type);
// FCCU_FaultPinInit();
Fccu_RetainedDebugRecord(0x4401U, ret, reset_type);
rt_kprintf("FCCU8\n");

观察到完整执行:

last st=4fff gd=a55a0000 ret=0 rst=0 free=7988
FCCU0
reset type 1
...
FCCU12
msh />

结论:

注释 FCCU_FaultPinInit() 后,FCCU_FaultInitTask() 可以完整执行到 FCCU12。

说明重启和 FCCU_FaultPinInit() 调用路径强相关。


15. 排查点四:细分 FCCU_FaultPinInit

在 FCCU_FaultPinInit() 内部增加 stage:

void FCCU_FaultPinInit(void)
{
    FCCU_RetainedDebugStageRecord(0x4410U);

    FCCU_RetainedDebugStageRecord(0x4411U);
    FCCU_FaultPinAttrbInit();
    FCCU_RetainedDebugStageRecord(0x4412U);

    FCCU_RetainedDebugStageRecord(0x4420U);
    rt_pin_mode(fccu_pin.error_pin, PIN_MODE_OUTPUT);
    FCCU_RetainedDebugStageRecord(0x4421U);

    FCCU_RetainedDebugStageRecord(0x4430U);
    rt_pin_mode(fccu_pin.heartbeat_pin, PIN_MODE_OUTPUT);
    FCCU_RetainedDebugStageRecord(0x4431U);

    FCCU_RetainedDebugStageRecord(0x4440U);
    FCCU_FaultErrorPinSetUp();
    FCCU_RetainedDebugStageRecord(0x4441U);
}

阶段含义:

Stage 含义
4410 进入 FCCU_FaultPinInit()
4411 调用 FCCU_FaultPinAttrbInit() 前
4412 FCCU_FaultPinAttrbInit() 已返回
4420 调用 rt_pin_mode(error_pin, OUTPUT) 前
4421 rt_pin_mode(error_pin, OUTPUT) 已返回
4430 调用 rt_pin_mode(heartbeat_pin, OUTPUT) 前
4431 rt_pin_mode(heartbeat_pin, OUTPUT) 已返回
4440 调用 FCCU_FaultErrorPinSetUp() 前
4441 FCCU_FaultErrorPinSetUp() 已返回

结论:

  • FCCU_FaultPinAttrbInit() 已通过。
  • rt_pin_mode(error_pin) 已通过。
  • rt_pin_mode(heartbeat_pin) 已通过。
  • 问题继续收敛到 FCCU_FaultErrorPinSetUp() 内部。

16. 排查点五:细分 FCCU_FaultErrorPinSetUp

当前 pin 默认值:

#define FCCU_GPIO_INVALID_PIN   0xffU

static fccu_pin_attribute_t fccu_pin = {GPIO_16, GPIO_17};
static fccu_pin_attribute_t fccu_pin_updata = {GPIO_16, GPIO_17};

内部 stage:

void FCCU_FaultErrorPinSetUp(void)
{
    rt_uint8_t cciFault = 0U;
    rt_uint8_t setFlag = FALSE;
    rt_base_t errorPin = fccu_pin.error_pin;

    FCCU_RetainedDebugStageRecord(0x4500U);

    if (FCCU_GPIO_INVALID_PIN != errorPin)
    {
        FCCU_RetainedDebugStageRecord(0x4501U);
        cciFault = FCCU_FaultCCIRegTotalGet();
        FCCU_RetainedDebugStageRecord(0x4502U);

        if (0U != cciFault)
        {
            FCCU_RetainedDebugStageRecord(0x4512U);
            const fccu_fault_element_attribute_t *f_param = Fccu_FaultParamListGet();
            FCCU_RetainedDebugStageRecord(0x4503U);
            ...
            FCCU_RetainedDebugStageRecord(0x4504U);
        }
        else
        {
            FCCU_RetainedDebugStageRecord(0x4522U);
            setFlag = FALSE;
        }

        if (TRUE == setFlag)
        {
            FCCU_RetainedDebugStageRecord(0x4505U);
            rt_pin_write(errorPin, PIN_HIGH);
        }
        else
        {
            FCCU_RetainedDebugStageRecord(0x4506U);
            rt_pin_write(errorPin, PIN_LOW);
        }
        FCCU_RetainedDebugStageRecord(0x4507U);
    }
    else
    {
        FCCU_RetainedDebugStageRecord(0x45F0U);
    }
}

阶段含义:

Stage 含义
4500 进入 FCCU_FaultErrorPinSetUp(),已读取 errorPin
4501 调用 FCCU_FaultCCIRegTotalGet() 前
4502 FCCU_FaultCCIRegTotalGet() 已返回
4512 cciFault != 0 分支,调用 Fccu_FaultParamListGet() 前
4503 Fccu_FaultParamListGet() 已返回
4504 故障参数扫描循环结束
4522 cciFault == 0 分支
4505 准备 rt_pin_write(errorPin, PIN_HIGH)
4506 准备 rt_pin_write(errorPin, PIN_LOW)
4507 rt_pin_write() 已返回
45F0 errorPin 无效,跳过处理

异常日志停在:

last st=4502

说明:

  • 已进入 FCCU_FaultErrorPinSetUp()。
  • FCCU_FaultCCIRegTotalGet() 已经正常返回。
  • 未记录到 4512,说明当时还没进入 cciFault != 0 的显式记录点。
  • 未记录到 4522,说明当时也没记录到 cciFault == 0 分支。
  • 未记录到 4505/4506/4507,说明还没走到 rt_pin_write() 前。
  • free=7964,说明当前线程栈剩余充足,不是线程栈耗尽。
  • gd=a55a0000,说明 MD5 调用者栈 guard 正常。

当前复位点被压缩到:

cciFault = FCCU_FaultCCIRegTotalGet();
FCCU_RetainedDebugStageRecord(0x4502U);

if (0U != cciFault)
{
    FCCU_RetainedDebugStageRecord(0x4512U);
    ...
}
else
{
    FCCU_RetainedDebugStageRecord(0x4522U);
    ...
}

也就是 4502 之后、进入 4512/4522 之前或记录过程中。


17. 当前 FCCU 问题结论

截至目前,比较可靠的结论是:

  1. Fccu_FaultParamListCheck() 不是当前主要重启点。
  2. utils_md5() / checkMD5() 未检测到破坏调用者栈。
  3. 注释 FCCU_FaultPinInit() 后,FCCU 初始化可以完整执行。
  4. 问题和 fault pin 初始化路径强相关。
  5. FCCU_FaultPinInit() 内部细分后,问题进一步收敛到 FCCU_FaultErrorPinSetUp()。
  6. 异常日志 last st=4502 表示 FCCU_FaultCCIRegTotalGet() 已返回。
  7. 复位发生在其后续分支判断或更后面的极短窗口内。
  8. free=7964/7988 表示当前线程剩余栈充足,不支持“线程栈耗尽导致复位”的判断。
  9. gd=a55a0000 表示 MD5 调用者栈 guard 正常。

18. 下一步建议

18.1 避免 stage 号冲突

当前 4500/4501 曾经在外层和内层都有使用。后续建议统一调整编号,避免解释歧义。

18.2 对 4502 后继续细分

建议改成:

FCCU_RetainedDebugStageRecord(0x4520U);
if (0U != cciFault)
{
    FCCU_RetainedDebugStageRecord(0x4521U);
    ...
}
else
{
    FCCU_RetainedDebugStageRecord(0x4522U);
    ...
}

如果仍停在 4520,说明复位不是具体分支调用造成,而可能是异步复位刚好发生在这个时间窗口。

18.3 记录 cciFault 和 errorPin

建议 retained 结构增加:

volatile rt_uint32_t debug_arg0;
volatile rt_uint32_t debug_arg1;

然后记录:

FCCU_RetainedDebugArgRecord(0x4502U, cciFault, errorPin);

这样下一次启动可以直接知道:

4502 时 cciFault 是 0 还是非 0
4502 时 errorPin 是哪个 GPIO

18.4 检查 GPIO_16/GPIO_17 的硬件含义

当前测试默认 pin 为:

static fccu_pin_attribute_t fccu_pin = {GPIO_16, GPIO_17};
static fccu_pin_attribute_t fccu_pin_updata = {GPIO_16, GPIO_17};

需要确认:

  • GPIO_16 是否影响电源保持、复位脚、boot strap 或外部复位电路。
  • GPIO_17 是否与调试串口、USB、NVM、电源控制等复用冲突。
  • rt_pin_write(GPIO_16, PIN_LOW/HIGH) 是否可能通过外部硬件拉低 reset 或触发电源管理。

18.5 若怀疑异步复位,读取硬件 reset cause

当前 rst=0/1 来自 Mcu_GetResetReason() 的软件保留原因,不一定等价于芯片真实 reset cause。

如果要确认是否为:

  • WDT reset
  • 外部 reset
  • software reset
  • power reset
  • brown-out reset

需要读取芯片硬件 reset status 寄存器,而不是只看 Mcu_GetResetReason()。


19. HardFault 场景下的栈信息打印

如果程序进入 HardFault,Cortex-M 会自动把部分寄存器压入当前栈:

sp[0] = R0
sp[1] = R1
sp[2] = R2
sp[3] = R3
sp[4] = R12
sp[5] = LR
sp[6] = PC
sp[7] = xPSR

HardFault handler 可以这样写:

__attribute__((naked)) void HardFault_Handler(void)
{
    __asm volatile
    (
        "TST lr, #4            \n"
        "ITE EQ                \n"
        "MRSEQ r0, MSP         \n"
        "MRSNE r0, PSP         \n"
        "B hardfault_handler_c \n"
    );
}

void hardfault_handler_c(uint32_t *sp)
{
    rt_kprintf("HardFault!\n");
    rt_kprintf("R0   = 0x%08x\n", sp[0]);
    rt_kprintf("R1   = 0x%08x\n", sp[1]);
    rt_kprintf("R2   = 0x%08x\n", sp[2]);
    rt_kprintf("R3   = 0x%08x\n", sp[3]);
    rt_kprintf("R12  = 0x%08x\n", sp[4]);
    rt_kprintf("LR   = 0x%08x\n", sp[5]);
    rt_kprintf("PC   = 0x%08x\n", sp[6]);
    rt_kprintf("xPSR = 0x%08x\n", sp[7]);

    while (1);
}

最关键的是:

PC: 崩溃时正在执行的指令地址
LR: 返回地址或异常返回标志
SP: 异常现场所在栈位置

20. 如何根据 PC/LR 定位源码

假设打印:

PC = 0x0800456A
LR = 0x08001235

可以用:

arm-none-eabi-addr2line -e build/app.elf -a -f 0x0800456A

输出可能是:

0x0800456A
i2c_read_reg
drivers/i2c.c:87

说明崩溃发生在:

drivers/i2c.c 第 87 行
函数 i2c_read_reg

注意 Thumb 地址最低 bit 可能为 1,例如:

0x08001235

解析时可尝试清除最低 bit:

0x08001234

21. 栈 dump 怎么看

可以打印一段栈内容:

void dbg_dump_stack(uint32_t *sp, uint32_t words)
{
    for (uint32_t i = 0; i < words; i++)
    {
        rt_kprintf("0x%08x: 0x%08x\n",
                   (uint32_t)&sp[i],
                   sp[i]);
    }
}

重点看:

  1. 是否有明显非法地址:

    0x00000000
    0xFFFFFFFF
    0xDEADBEEF
    
  2. 是否有代码区地址:

    0x080xxxxx
    
  3. 是否有 SRAM 地址:

    0x200xxxxx
    
  4. SP 是否在当前线程栈范围内。

如果线程栈范围是:

0x20001000 - 0x20001800

但 SP 是:

0x20000F80

那就高度怀疑栈溢出。


22. 常见现象判断

22.1 PC = 0x00000000

常见原因:

  • 空函数指针调用。
  • 返回地址被覆盖。
  • 跳转到空地址。

排查:

  • 看 LR。
  • 看栈是否溢出。
  • 看函数指针来源。

22.2 PC = 0xFFFFFFFF

常见原因:

  • 函数指针野值。
  • flash 未初始化区域。
  • 内存被踩。

22.3 LR = 0xFFFFFFF9 / 0xFFFFFFFD

这不一定是错误,它可能是 Cortex-M 异常返回标志。

常见含义:

0xFFFFFFF9: 返回后使用 MSP
0xFFFFFFFD: 返回后使用 PSP

不要直接把这种 LR 当普通代码地址解析。

22.4 SP 不在栈范围内

如果:

current_sp < stack_addr

或:

current_sp > stack_addr + stack_size

说明 SP 不在当前线程栈范围内,需要优先怀疑栈溢出、栈破坏或上下文判断错误。

22.5 max_used 接近 stack_size

说明历史最大栈使用量非常接近栈大小,可能已经发生过危险情况。


23. 使用栈打印时的注意事项

23.1 printf / rt_kprintf 本身也消耗栈

在栈快爆时调用复杂打印,可能让问题更严重。

应避免:

  • 大量格式化打印。
  • 浮点打印。
  • sprintf 到大缓冲区。
  • 在异常里做复杂逻辑。

23.2 中断里打印要谨慎

中断里打印可能导致:

  • 阻塞
  • 死锁
  • 串口驱动重入
  • 调度异常
  • 延迟过大

更安全方式:

中断里只记录关键信息到 buffer 或 retained 变量
主线程或复位后再打印

23.3 编译优化会影响 backtrace

优化可能导致:

  • 函数内联
  • 省略帧指针
  • 重排代码
  • 局部变量被优化掉
  • 尾调用优化

调试版本建议:

-g
-O0 或 -Og
-fno-omit-frame-pointer

23.4 栈扫描不是百分百准确

扫描栈找代码地址只能作为启发式方法。

它可能:

  • 漏掉真实返回地址。
  • 把普通数据误判成返回地址。

24. 推荐的完整调试流程

当设备出现重启、死机或疑似栈问题时,可以按以下步骤:

第一步:确认是否有异常现场

如果有 HardFault,优先看:

PC
LR
SP
xPSR
CFSR
HFSR
MMFAR
BFAR

第二步:确认是否是线程栈耗尽

记录:

thread
stack_addr
stack_size
current_sp
stack_remaining

如果 stack_remaining 很小或 SP 越界,优先处理栈问题。

第三步:不要只依赖最后一条 log

如果 log 不完整,使用 retained stage。

第四步:关键函数前后打 stage

stage = BEFORE_CALL;
func();
stage = AFTER_CALL;

第五步:逐层收敛

从外层函数到内层函数逐步细分:

任务入口
  -> 模块初始化
     -> 子模块初始化
        -> 具体外设操作

第六步:记录关键参数

不要只记录 stage,还要记录:

ret
reset_type
stack_remaining
关键局部变量
GPIO 编号
状态寄存器
函数返回值

第七步:区分同步崩溃和异步复位

如果 stage 停在两个普通语句之间,且栈余量正常,要考虑:

  • watchdog
  • 外部 reset
  • 电源管理
  • GPIO 操作触发硬件复位
  • 外设状态导致异步复位

25. 栈问题常见修复方式

如果确认是栈问题,可以:

25.1 增大线程栈

#define SENSOR_THREAD_STACK_SIZE 4096

25.2 减少局部大数组

避免:

void foo(void)
{
    uint8_t image_buf[8192];
}

可以改为:

static uint8_t image_buf[8192];

或放到 heap / 全局 buffer。

25.3 减少递归

递归调用容易快速消耗栈,必要时改成循环或显式栈结构。

25.4 减少深层调用

过深调用链也会消耗栈,关键路径可适当拆分或减少中间层。

25.5 避免在小栈线程里做重打印

尤其注意:

printf("%f", value);
sprintf(big_buffer, ...);

26. 核心口诀

看 SP,知当前;
扫填充值,知历史最大;
看 PC,知死在哪里;
看 LR,知从哪里来;
dump 栈,找调用痕迹;
SP 越界,优先怀疑栈溢出;
PC 跳飞,怀疑函数指针或返回地址被踩;
printf / rt_kprintf 也耗栈,异常里慎用;
串口 log 有延迟,最后一条 log 不一定是最后执行点;
retained stage 比普通 log 更适合定位复位前最后位置;
保留区必须加 magic,否则旧数据不可信;
stage 号必须唯一,否则日志解释会混乱。

27. 本项目经验总结

本次 FCCU 排查中最有价值的经验是:

  1. rt_kprintf() 不可靠时,应使用 retained RAM 记录 stage。
  2. retained 数据必须有 magic 校验。
  3. 只记录 stage 不够,最好同时记录 ret、reset type、栈余量和关键参数。
  4. 栈余量 free=7964/7988 说明当前问题不支持线程栈耗尽判断。
  5. 局部 guard 可以证明某个调用路径是否踩坏调用者栈。
  6. 注释可疑函数做 A/B 验证非常有效。
  7. 阶段号要前后成对记录,才能判断函数是否返回。
  8. 如果 stage 停在极短窗口,应考虑异步复位或硬件副作用。
  9. 对 GPIO / pin write 相关复位问题,必须结合硬件原理图和 reset cause 寄存器判断。
  10. 软件 reset type 不一定等价于硬件真实 reset cause。

最终,这类问题的排查思路不是“多打几个 log”,而是建立一套可复位后追溯的证据链:

retained stage
+ magic 校验
+ stack remaining
+ guard 状态
+ ret/reset type
+ 关键参数
+ 硬件 reset cause

这样才能把偶现重启、日志截断、无 HardFault 的问题,一步步压缩到具体代码窗口或硬件触发条件。

posted @ 2026-08-14 13:29  『落水三千』  阅读(32)  评论(0)    收藏  举报