: u" m0 T; N# D. F" X0 z8 MRTOS 系统线程栈溢出检查实现方式

在实现的时候主要考量哪些因素？我只想到下面两个方向，说说我自己的理解：
# I& W6 u: h0 i7 f1 p2 v" k

• 线程栈溢出检查方式
• 什么情况、什么时候检查线程栈
  

( ?" {3 V5 T( u" ?& q- H5 }1. RT-Thread 线程栈的检查
4 v6 q( C% s4 V" V* E0 p9 g' h! K
1.1 线程栈溢出检查方式分析
线程栈溢出检查函数：
6 g* R, m) W8 K1 ~2 }/ P$ {/ X" A

1. static void _rt_scheduler_stack_check(struct rt_thread *thread)
   
2. {
   
3.     RT_ASSERT(thread != RT_NULL);
   ' m2 [8 |) @/ k& K( {" W
4. 
   4 m/ o9 @6 a7 `# f* n) d
5. #if defined(ARCH_CPU_STACK_GROWS_UPWARD)
   
6.         if (*((rt_uint8_t *)((rt_ubase_t)thread->stack_addr + thread->stack_size - 1)) != '#' ||
   
7. #else
   ! R# X; n7 o# Y
8.     if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
   & G% ^0 P5 q+ r# J" T, @
9. #endif
   
10.         (rt_ubase_t)thread->sp <= (rt_ubase_t)thread->stack_addr ||
    
11.         (rt_ubase_t)thread->sp >
    
12.         (rt_ubase_t)thread->stack_addr + (rt_ubase_t)thread->stack_size)
    6 I* b& T6 `/ A2 x- a1 z; E4 J
13.     {
    
14.         rt_ubase_t level;
    ( A+ }, T% i# `4 c1 D% k) G* V, l
15. 
    8 A5 f/ v6 O+ E, p9 @
16.         rt_kprintf("thread:%s stack overflow\n", thread->name);
    
17. #ifdef RT_USING_FINSH
    
18.         {
    
19.             extern long list_thread(void);
    
20.             list_thread();
    
21.         }
    0 O# a  u8 {0 F
22. #endif
    
23.         level = rt_hw_interrupt_disable();
      i6 C" p1 k& ?7 c2 z3 g& O
24.         while (level);
    ( \! A$ ]* n4 d$ t- `' c7 x. l
25.     }
    
26. #if defined(ARCH_CPU_STACK_GROWS_UPWARD)
      [+ _- i/ p0 \0 G* l& Y3 R
27.     else if ((rt_ubase_t)thread->sp > ((rt_ubase_t)thread->stack_addr + thread->stack_size))
    * h5 x" {- @6 @
28.     {
    6 d* H3 l# |$ Q
29.         rt_kprintf("warning: %s stack is close to the top of stack address.\n",
    ! B& B$ t5 s$ }  N6 |
30.                    thread->name);
    
31.     }
    - ^# E& X1 m+ `! W5 h7 n# W
32. #else
    
33.     else if ((rt_ubase_t)thread->sp <= ((rt_ubase_t)thread->stack_addr + 32))
    
34.     {
    
35.         rt_kprintf("warning: %s stack is close to end of stack address.\n",
    
36.                    thread->name);
    5 \: _: e& x1 o: ~) S2 [
37.     }
    
38. #endif
    : D6 Z8 v' j+ y7 q
39. }

复制代码

+ h. N0 t. ^) ]. Y& I从上面的代码中可以直观地看到，RT-Thread 线程栈的检查方式分为两种情况：

• 栈向下增长
• 栈向上增长
  5 i9 m- M7 }: r  q, M* N

* T# r9 L1 p, t, T
判断栈的增长方向这个是必须的，因为系统要适配不同的 CPU 架构，而有些 CPU 架构的栈增长方向是可配置的。
) O4 B, J  w: B
虽然根据栈的增长方向分为两种检查方式，但核心的检查功能确是一样的，通过判断栈尾地址内容是否为 "#" 来进行初步溢出判断，如果栈尾地址内容不是 "#"，那么栈溢出。另外，代码还配合检查了线程栈帧地址是否超出栈的地址空间范围来辅助判断。

  f9 [* z% R2 _) q6 _+ x【这里感觉不严谨，如果线程栈刚好用到这个末尾，那就会误判；另外，无法检查其它任务改写栈的问题】
1 w0 u8 V  t# V' I5 E: u5 ~

1.2. 什么时候检查
& |9 C% e$ c  R' j5 A4 e
, @" ~1 O" H, ]+ z- g9 s通常的做法就是在调度器切换线程的时候检查，调度器简化代码如下：
) z. I+ |4 W- _& O" r
0 r, g9 @8 t5 t

1. void rt_schedule(void)
   
2. {
   
3.     rt_base_t level;
   
4.     struct rt_thread *to_thread;
   
5.     struct rt_thread *from_thread;
   ( S& A: S9 b+ n; Y
6. 
   
7.     /* disable interrupt */
   
8.     level = rt_hw_interrupt_disable();
   
9.    
   * k/ u1 W1 g( Y
10.     to_thread = _get_highest_priority_thread(&highest_ready_priority);
    
11.    
    
12.     from_thread         = rt_current_thread;
    
13.     rt_current_thread   = to_thread;
    
14.    
    . I+ t4 j0 q4 U( w: P
15.     _rt_scheduler_stack_check(to_thread);
    
16.    
    
17.     rt_hw_interrupt_enable(level);
    . P! x, j, W) v
18. }

复制代码

' @! k" M+ @; M+ j" Y, O6 [从上面的代码可以看到 RT-Thread 在调度器中调用 _rt_scheduler_stack_check(to_thread); 函数检查 to_thread 线程的线程栈。
; i' h' _8 T+ g4 h; R: P" j【有个疑问：为什么仅仅检查 to_thread，不同时检查 from_thread？】

6 W' N# @7 e% n) y# m1 \2. FreeRTOS 线程栈检查
4 V% o! O. u& W) }- Z1.1 线程栈溢出检查方式分析
线程栈溢出检查函数：
8 g4 r$ x/ _/ V0 e. ?7 b
0 `7 i7 W* j9 f' b
FreeRTOS 的栈溢出检查就有了一个特点，首先使用了 taskFIRST_CHECK_FOR_STACK_OVERFLOW 函数，如下所示：（这里粘贴的代码实在看不下去，放图吧）


0 |' n: J* s3 q/ @% f6 g5 ]+ r
然后，使用了 taskSECOND_CHECK_FOR_STACK_OVERFLOW 函数：


( \! J% w2 m4 A% ?8 @5 o% K0 g
从上面的两段代码，可以看到，FreeRTOS 的栈溢出检查分为第一次和第二次，但同 RT-Thread 类似，也分了栈的增长方向。
第一次检查，仅仅判断栈顶指针是否超出了栈尾，具体的栈溢出操作实现交给了 vApplicationStackOverflowHook 回调函数。
第二次检查，通过内存比较函数，比较 pcEndOfStack 栈尾 20 个字节大小的空间是否与栈的填充值 tskSTACK_FILL_BYTE 匹配（填充值为 0xa5）。

/ P$ D" e- y; t6 a) t当然，FreeRTOS 关键起作用的是第二次检查，看着相对还是比较靠谱的（相对 RT-Thread 仅检查一个字节）。FreeRTOS 这种检查方式肯定是与其线程栈的分配方式有关系的，因为它检查的是栈尾部的 20 字节，也就是说，FreeRTOS 为每一个线程栈都预留了 20 字节的空档，造成一部分空间的浪费。

1.2. 什么时候检查
* {9 F% ^# X  B9 @; i) p
当然，FreeRTOS 也是在调度器切换任务的时候检查。直接上代码了，如下：
! k+ m% Y$ L) M& s, Z

1. void vTaskSwitchContext( void )
   
2. {
   ' ~0 Y3 q: H3 U+ j* z
3.         /* Check for stack overflow, if configured. */
   % M% ]: _1 F, X" X8 b- X
4.         taskFIRST_CHECK_FOR_STACK_OVERFLOW();
   
5.         taskSECOND_CHECK_FOR_STACK_OVERFLOW();
   " e$ ~5 K; O9 |$ N
6. 
   
7.         /* Select a new task to run using either the generic C or port
   0 o' L' u8 _! Q. e* b8 f; f4 h% G, Z
8.         optimised asm code. */
   
9.         taskSELECT_HIGHEST_PRIORITY_TASK();
   0 P. g& B! j1 ^: m8 k
10.         traceTASK_SWITCHED_IN();
    
11. }

复制代码

! A( z+ W0 M7 ~  z8 p+ o) E
% O. A. z: T; Z" `9 m& o如上，注意到一个问题，FreeRTOS 的栈检查，貌似是检查的 from_thread，而不是像 RT-Thread 一样检查的 to_thread？

) c" ]$ k# ~0 e) m. S! Z总结

5 m' ~# Z* e# U, x% d, s* \# p2 o/ P不知道设计栈溢出检查的时候有哪些考究，RT-Thread 和 FreeRTOS 都没有对同时检查 from_thread 和 to_thread。这两个系统的栈检查方式差不多，相对来说，感觉 FreeRTOS 的更严谨些，但都不能完全检查到，也没法检查线程栈被其它任务错误修改的情况。
' t: e' D: `, T  v( ?
----

如上分析，如有问题，请拍砖
+ d1 {2 V: d9 r- ^


0 o- G& ]7 D% c1 f

这里上传代码还是很费劲，整理出来的代码没法看，就直接上图了，比较直观

感谢楼主的分享，还没研究过嵌入式OS，支持一下楼主

学习下

楼主的代码截的很好看啊，怎么弄的？

梦中的飞鸿 发表于 2019-6-28 18:06
楼主的代码截的很好看啊，怎么弄的？

用这个工具，非常好用 http://blog.csdn.net/u012349679/article/details/89787697

梦中的飞鸿 发表于 2019-6-28 18:06
楼主的代码截的很好看啊，怎么弄的？

这个图是使用 Carbon 在线工具，使用参考 http://blog.csdn.net/u012349679/article/details/89787697 这个

梦中的飞鸿 发表于 2019-6-28 18:06
' I( v9 K# M% t' @) x0 o. a楼主的代码截的很好看啊，怎么弄的？

Carbon 在线工具，百度好像直接搜不到，我还贴不了链接
# q* V' Q' S1 ^; i: x2 m
放个图总可以吧

5 R8 _5 [% D" F9 N

军涛，想不想干了，敢说RTT不好？价值观有问题哈哈哈哈哈