[痞子衡]Cortex-M裸机环境下临界区保护的三种实现

NXP管管

大家好，我是痞子衡，是正经搞技术的痞子。今天痞子衡给大家分享的是Cortex-M裸机环境下临界区保护的三种实现。


搞嵌入式玩过 RTOS 的朋友想必都对 OS_ENTER_CRITICAL(）、OS_EXIT_CRITICAL() 这个功能代码对特别眼熟，在 RTOS 里常常会有多任务（进程）处理，有些情况下一些特殊操作（比如 XIP 下 Flash 擦写、低功耗模式切换）不能被随意打断，或者一些共享数据区不能被无序访问（A 任务正在读，B 任务却要写），这时候就要用到临界区保护策略了。


所谓临界区保护策略，简单说就是系统中硬件临界资源或者软件临界资源，多个任务必须互斥地对它们进行访问。RTOS 环境下有现成的临界区保护接口函数，而裸机系统里其实也有这种需求。在裸机系统里，临界区保护主要就是跟系统全局中断控制有关。痞子衡之前写过一篇 《嵌入式MCU中通用的三重中断控制设计》，文中介绍的第三重也是最顶层的中断控制是系统全局中断控制，今天痞子衡就从这个系统全局中断控制使用入手给大家介绍三种临界区保护做法：


一、临界区保护测试场景
关于临界区保护的测试场景无非两种。第一种场景是受保护的多个任务间并无关联，也不会互相嵌套，如下面的代码所示，task1 和 task2 是按序被保护的，因此 enter_critical() 和 exit_critical() 这两个临界区保护函数总是严格地成对执行：

1. void critical_section_test(void)
   
2. {
   
3.     // 进入临界区
   
4.     enter_critical();
   
5.     // 做受保护的任务1
   
6.     do_task1();
   
7.     // 退出临界区
   
8.     exit_critical();
   
9. 
   
10.     // 进入临界区
    
11.     enter_critical();
    
12.     // 做受保护的任务2，与任务1无关联
    
13.     do_task2();
    
14.     // 退出临界区
    
15.     exit_critical();
    
16. }

复制代码

第二种场景就是多个任务间可能有关联，会存在嵌套情况，如下面的代码所示，task2 是 task1 的一个子任务，这种情况下，你会发现实际上是先执行两次 enter_critical()，然后再执行两次 exit_critical()。需要注意的是 task1 里面的子任务 task3 虽然没有像子任务 task2 那样被主动加一层保护，但由于主任务 task1 整体是受保护的，因此子任务 task3 也应该是受保护的。

1. void do_task1(void)
   
2. {
   
3.     // 进入临界区
   
4.     enter_critical();
   
5.     // 做受保护的任务2，是任务1中的子任务
   
6.     do_task2();
   
7.     // 退出临界区
   
8.     exit_critical();
   
9. 
   
10.     // 做任务3
    
11.     do_task3();
    
12. }
    
13. 
    
14. void critical_section_test(void)
    
15. {
    
16.     // 进入临界区
    
17.     enter_critical();
    
18.     // 做受保护的任务1
    
19.     do_task1();
    
20.     // 退出临界区
    
21.     exit_critical();
    
22. }

复制代码

二、临界区保护三种实现
上面的临界区保护测试场景很清楚了，现在到 enter_critical()、exit_critical() 这对临界区保护函数的实现环节了：


2.1 入门做法
首先是非常入门的做法，直接就是对系统全局中断控制函数 __disable_irq()、__enable_irq() 的封装。回到上一节的测试场景里，这种实现可以很好地应对非嵌套型任务的保护，但是对于互相嵌套的任务保护就失效了。上一节测试代码里，task3 应该也要受到保护的，但实际上并没有被保护，因为紧接着 task2 后面的 exit_critical() 直接就打开了系统全局中断。

1. void enter_critical(void)
   
2. {
   
3.     // 关闭系统全局中断
   
4.     __disable_irq();
   
5. }
   
6. 
   
7. void exit_critical(void)
   
8. {
   
9.     // 打开系统全局中断
   
10.     __enable_irq();
    
11. }

复制代码

2.2 改进做法
针对入门做法，可不可以改进呢？当然可以，我们只需要加一个全局变量 s_lockObject 来实时记录当前已进入的临界区保护的次数，即如下代码所示。每调用一次 enter_critical() 都会直接关闭系统全局中断（保证临界区一定是受保护的），并记录次数，而调用 exit_critical() 时仅当当前次数是 1 时（即当前不是临界区保护嵌套情况），才会打开系统全局中断，否则只是抵消一次进入临界区次数而已。改进后的实现显然可以保护上一节测试代码里的 task3 了。

1. static uint32_t s_lockObject;
   
2. 
   
3. void init_critical(void)
   
4. {
   
5.     __disable_irq();
   
6.     // 清零计数器
   
7.     s_lockObject = 0;
   
8.     __enable_irq();
   
9. }
   
10. 
    
11. void enter_critical(void)
    
12. {
    
13.     // 关闭系统全局中断
    
14.     __disable_irq();
    
15.     // 计数器加 1
    
16.     ++s_lockObject;
    
17. }
    
18. 
    
19. void exit_critical(void)
    
20. {
    
21.     if (s_lockObject <= 1)
    
22.     {
    
23.         // 仅当计数器不大于 1 时，才打开系统全局中断，并清零计数器
    
24.         s_lockObject = 0;
    
25.         __enable_irq();
    
26.     }
    
27.     else
    
28.     {
    
29.         // 当计数器大于 1 时，直接计数器减 1 即可
    
30.         --s_lockObject;
    
31.     }
    
32. }

复制代码

2.3 终极做法
上面的改进做法虽然解决了临界区任务嵌套保护的问题，但是增加了一个全局变量和一个初始化函数，实现不够优雅，并且嵌入式系统里全局变量极容易被篡改，存在一定风险，有没有更好的实现呢？当然有，这要借助 Cortex-M 处理器内核的特殊屏蔽寄存器 PRIMASK，下面是 PRIMASK 寄存器位定义（取自 ARMv7-M 手册），其仅有最低位 PM 是有效的，当 PRIMASK[PM] 为 1 时，系统全局中断是关闭的（将执行优先级提高到 0x0/0x80）；当 PRIMASK[PM] 为 0 时，系统全局中断是打开的（对执行优先级无影响）。

看到这，你应该明白了 __disable_irq()、__enable_irq() 功能其实就是操作 PRIMASK 寄存器实现的。既然 PRIMASK 寄存器控制也保存了系统全局中断的开关状态，我们可以通过获取 PRIMASK 值来替代上面改进做法里的全局变量 s_lockObject 的功能，代码实现如下：

1. uint32_t enter_critical(void)
   
2. {
   
3.     // 保存当前 PRIMASK 值
   
4.     uint32_t regPrimask = __get_PRIMASK();
   
5.     // 关闭系统全局中断（其实就是将 PRIMASK 设为 1）
   
6.     __disable_irq();
   
7. 
   
8.     return regPrimask;
   
9. }
   
10. 
    
11. void exit_critical(uint32_t primask)
    
12. {
    
13.     // 恢复 PRIMASK
    
14.     __set_PRIMASK(primask);
    
15. }

复制代码

因为 enter_critical()、exit_critical() 函数原型有所变化，因此使用上也要相应改变下：

1. void critical_section_test(void)
   
2. {
   
3.     // 进入临界区
   
4.     uint32_t primask = enter_critical();
   
5.     // 做受保护的任务
   
6.     do_task();
   
7.     // 退出临界区
   
8.     exit_critical(primask);
   
9. 
   
10.     // ...
    
11. }

复制代码

附录、PRIMASK寄存器设置函数在各 IDE 下实现

1. //////////////////////////////////////////////////////
   
2. // IAR 环境下实现（见 cmsis_iccarm.h 文件）
   
3. #define __set_PRIMASK(VALUE)        (__arm_wsr("PRIMASK", (VALUE)))
   
4. #define __get_PRIMASK()             (__arm_rsr("PRIMASK"))
   
5. 
   
6. //////////////////////////////////////////////////////
   
7. // Keil 环境下实现（见 cmsis_armclang.h 文件）
   
8. __STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
   
9. {
   
10.   __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
    
11. }
    
12. 
    
13. __STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
    
14. {
    
15.   uint32_t result;
    
16. 
    
17.   __ASM volatile ("MRS %0, primask" : "=r" (result) );
    
18.   return(result);
    
19. }

复制代码

至此，Cortex-M裸机环境下临界区保护的三种实现痞子衡便介绍完毕了，掌声在哪里~~~

阅读全文