关于线程栈溢出检查的一些想法

发布于 2021-11-15 13:20:04 浏览：2344 订阅该版

在代码开发的过程中，偶尔会遇到线程栈溢出的问题，栈溢出检查能很好地帮助我们定位问题的位置。
```c
void rt_schedule(void)
{
    ......
            if (to_thread != rt_current_thread)
            {
                /* if the destination thread is not the same as current thread */
                rt_current_priority = (rt_uint8_t)highest_ready_priority;
                from_thread         = rt_current_thread;
                rt_current_thread   = to_thread;

RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread));

if (need_insert_from_thread)
                {
                    rt_schedule_insert_thread(from_thread);
                }

rt_schedule_remove_thread(to_thread);
                to_thread->stat = RT_THREAD_RUNNING | (to_thread->stat & ~RT_THREAD_STAT_MASK);

/* switch to new thread */
                RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                        ("[%d]switch to priority#%d "
                         "thread:%.*s(sp:0x%08x), "
                         "from thread:%.*s(sp: 0x%08x)\n",
                         rt_interrupt_nest, highest_ready_priority,
                         RT_NAME_MAX, to_thread->name, to_thread->sp,
                         RT_NAME_MAX, from_thread->name, from_thread->sp));

#ifdef RT_USING_OVERFLOW_CHECK
                _rt_scheduler_stack_check(to_thread);
#endif /* RT_USING_OVERFLOW_CHECK */

if (rt_interrupt_nest == 0)
                {
                    extern void rt_thread_handle_sig(rt_bool_t clean_state);

RT_OBJECT_HOOK_CALL(rt_scheduler_switch_hook, (from_thread));

rt_hw_context_switch((rt_ubase_t)&from_thread->sp,
                            (rt_ubase_t)&to_thread->sp);

/* enable interrupt */
                    rt_hw_interrupt_enable(level);

#ifdef RT_USING_SIGNALS
                    /* check stat of thread for signal */
                    level = rt_hw_interrupt_disable();
                    if (rt_current_thread->stat & RT_THREAD_STAT_SIGNAL_PENDING)
                    {
                        extern void rt_thread_handle_sig(rt_bool_t clean_state);

rt_current_thread->stat &= ~RT_THREAD_STAT_SIGNAL_PENDING;

rt_hw_interrupt_enable(level);

/* check signal status */
                        rt_thread_handle_sig(RT_TRUE);
                    }
                    else
                    {
                        rt_hw_interrupt_enable(level);
                    }
#endif /* RT_USING_SIGNALS */
                    goto __exit;
                }
                else
                {
                    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n"));

rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp,
                            (rt_ubase_t)&to_thread->sp);
                }
    ......
}
```

```c
#ifdef RT_USING_OVERFLOW_CHECK
static void _rt_scheduler_stack_check(struct rt_thread *thread)
{
    RT_ASSERT(thread != RT_NULL);

#ifdef ARCH_CPU_STACK_GROWS_UPWARD
    if (*((rt_uint8_t *)((rt_ubase_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
#else
    if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
#endif /* ARCH_CPU_STACK_GROWS_UPWARD */
        (rt_ubase_t)thread->sp <= (rt_ubase_t)thread->stack_addr ||
        (rt_ubase_t)thread->sp >
        (rt_ubase_t)thread->stack_addr + (rt_ubase_t)thread->stack_size)
    {
        rt_ubase_t level;

rt_kprintf("thread:%s stack overflow\n", thread->name);

level = rt_hw_interrupt_disable();
        while (level);
    }
#ifdef ARCH_CPU_STACK_GROWS_UPWARD
    else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
    {
        rt_kprintf("warning: %s stack is close to the top of stack address.\n",
                   thread->name);
    }
#else
    else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
    {
        rt_kprintf("warning: %s stack is close to end of stack address.\n",
                   thread->name);
    }
#endif /* ARCH_CPU_STACK_GROWS_UPWARD */
}
#endif /* RT_USING_OVERFLOW_CHECK */
```
RTT调度器内目前对于栈溢出的处理还是比较粗暴的，直接把系统while循环死机。
调度器执行过程：
1、在调度器内找到就绪的最高优先级的线程对象。
2、判断该线程对象是否优先级比当前优先级高。
3、判断是否需要调度线程。
4、把from_thread插入就绪对象链表
5、把to_thread从就绪线程对象链表中剔除
6、检查线程栈溢出，如果发现线程栈溢出，则令系统while循环死机?

while循环死机的操作感觉过于粗暴了，对于我们而言，有时候发生栈溢出只是某种情况没考虑周到导致的，因为某个报文或者某种配置，导致了系统内存越界，这种千载难逢的机会不希望设备出现死机，而错过了发现问题的钥匙，尽可能把当前的触发系统异常的线程信息通过日志文件记录下来，帮助分析现场问题，能对系统开发提供反馈的信息。
既然栈溢出已经发生，则说明目前处于该线程的栈地址空间以下的所有线程对象都是不可靠的，反过来说栈地址空间以上的线程对象是相对安全的，可以通过一个能尽可能保证安全且稳定的线程处于所有业务线程的线程对象内存地址空间之上（对象结构体的内容未被破坏），来记录该系统异常的现象并保存到日志文件中或者其他方法，然后自行触发系统重启。
如果这个议题有意义的话，希望RTT能为我们这种偶尔会犯错误的开发人员提供一种调试手段，能在发现系统栈溢出时，像硬件错误中断一样，提供一个钩子函数让我们去选择默认处理方式还是不执行调度这个异常线程可选择切换至其他安全线程继续运行。