1、背景

????????本文章主要说明 rtthread 内核线程是如何切换的，初学者刚从裸机开发接触 RTOS 时难免会有些不适应，明白这部分原理之后就会对 RTOS 有更深的理解。在学习内核线程切换原理之前需要有以下基础知识铺垫。本文以 arm 公司的 Cortex-M3 内核为例。

2、基础知识

CM3 拥有通用寄存器 R0-R15 以及一些特殊功能寄存器(中断屏蔽寄存器等等）

R0-R12 都是通用寄存器，用来临时存储程序运行时产生的数据

R13 这个寄存器存储堆栈指针，在 CM3 内核中一共有两个堆栈指针（MSP、PSP），于是 CM3 支持两个堆栈。在启动文件中定义的那个栈空间属于主栈，还有一个在我们创建线程时的栈属于线程栈。这两个栈空间不是同一个空间。

主堆栈指针（MSP）,这是默认的堆栈指针，在裸机开发中只是用这一个指针，由 OS 内核、中断服务程序以及所有需要特权访问的应用程序代码使用。

进程堆栈指针(PSP),用于常规的应用程序代码，比如线程。
R14 也叫做连接寄存器LR,在调用子程序时存储返回地址
R15 也叫做程序计数器 (PC，program counter)，因为 CM3 内部使用了指令流水线，PC 中存放的是当前指令的地址+4，也就是下一条指令的地址。
栈空间的定义：向下生长的栈。也就是说每次执行一个 push(压栈)命令，栈指针向下减小一个单元，每次执行pop命令，栈指针增加一个单元。如下图所示

3、代码分析

3.1 内核寄存器结构体定义

struct exception_stack_frame
?{
? ? ?rt_uint32_t r0;
? ? ?rt_uint32_t r1;
? ? ?rt_uint32_t r2;
? ? ?rt_uint32_t r3;
? ? ?rt_uint32_t r12;
? ? ?rt_uint32_t lr;
? ? ?rt_uint32_t pc;
? ? ?rt_uint32_t psr;
?};
?struct stack_frame
?{
? ? ?/* r4 ~ r11 register */
? ? ?rt_uint32_t r4;
? ? ?rt_uint32_t r5;
? ? ?rt_uint32_t r6;
? ? ?rt_uint32_t r7;
? ? ?rt_uint32_t r8;
? ? ?rt_uint32_t r9;
? ? ?rt_uint32_t r10;
? ? ?rt_uint32_t r11;
? ? ?struct exception_stack_frame exception_stack_frame;
?};
?struct exception_info
?{
? ? ?rt_uint32_t exc_return;
? ? ?struct stack_frame stack_frame;
?};

3.2 初始化线程栈

rt_uint8_t *rt_hw_stack_init(void ? ? ? *tentry, ?//线程函数入口地址
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? void ? ? ? *parameter,//线程函数参数
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? rt_uint8_t *stack_addr,//栈地址
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? void ? ? ? *texit)//线程退出时的函数地址
?{
? ? ?struct stack_frame *stack_frame;
? ? ?rt_uint8_t ? ? ? ? *stk;
? ? ?unsigned long ? ? ? i;
??
? ? ?stk ?= stack_addr + sizeof(rt_uint32_t);//栈地址 + 4 个字节
? ? ?stk ?= (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8);//向下8个字节对齐
? ? ?stk -= sizeof(struct stack_frame);//偏移16个字(16*4个字节)
??
? ? ?stack_frame = (struct stack_frame *)stk;//强制转换为 struct stack_frame 类型
??
? ? ?/* init all register */
? ? ?for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)
? ?  {
? ? ? ?  ((rt_uint32_t *)stack_frame)[i] = 0xdeadbeef;//初始化这16个字的空间为 0xdeadbeef
? ?  }
?    /* 初始化高8个字的内存空间 */
? ? ?stack_frame->exception_stack_frame.r0 ?= (unsigned long)parameter; /* r0 : argument */
? ? ?stack_frame->exception_stack_frame.r1 ?= 0; ? ? ? ? ? ? ? ? ? ? ? ?/* r1 */
? ? ?stack_frame->exception_stack_frame.r2 ?= 0; ? ? ? ? ? ? ? ? ? ? ? ?/* r2 */
? ? ?stack_frame->exception_stack_frame.r3 ?= 0; ? ? ? ? ? ? ? ? ? ? ? ?/* r3 */
? ? ?stack_frame->exception_stack_frame.r12 = 0; ? ? ? ? ? ? ? ? ? ? ? ?/* r12 */
? ? ?stack_frame->exception_stack_frame.lr ?= (unsigned long)texit; ? ? /* lr */
? ? ?stack_frame->exception_stack_frame.pc ?= (unsigned long)tentry; ? ?/* entry point, pc */
? ? ?stack_frame->exception_stack_frame.psr = 0x01000000L; ? ? ? ? ? ? ?/* PSR */
??
?#if USE_FPU
? ? ?stack_frame->flag = 0;
?#endif /* USE_FPU */
??
? ? ?/* return task's current stack address */
? ? ?return stk;
?}

stack_addr 这个参数为当前线程栈的结束地址，也就是最高的地址。为什么是最高地址？原因是上面说过的栈空间的定义。
struct stack_frame 这个结构体的定义可不是胡乱定义的，里面是有顺序要求的。
stk -= sizeof(struct stack_frame);//偏移16个字(16*4个字节) 为何偏移这么多字节，因为这16个字的空间的每个地址要按照结构体成员变量的地址去存放，即 psr 要放到这个栈的最高地址，r4 在最低的地址。如图所示,此图出自野火。

3.3 执行线程切换

????????阅读这段代码之前得知道，cm3 内核执行中断或异常时，r0、r1、r2、r3、r12、lr、pc、psr，这些寄存器是自动压栈的。

?rt_hw_context_switch ? ?PROC
? ? ?EXPORT rt_hw_context_switch ;导出函数，此操作能够让C侧代码调用，C侧的第一个参数为当前线程栈sp的指针，第二个
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?;为将要执行的线程栈 sp 的指针
? ? ?; set rt_thread_switch_interrupt_flag to 1
? ? ?LDR ? ? r2, =rt_thread_switch_interrupt_flag;中断标志位  L2 = &rt_thread_switch_interrupt_flag
? ? ?LDR ? ? r3, [r2];r3 = *r2也就是 r3 = rt_thread_switch_interrupt_flag
? ? ?CMP ? ? r3, #1  ;判断rt_thread_switch_interrupt_flag 与 1是否相等
? ? ?BEQ ? ? _reswitch ;相等跳转 _reswitch，当第2次执行线程切换时，rt_thread_switch_interrupt_flag被pendsv置0
? ?                   ?;既然是第二次，所以当前线程具有上文所以要把sp存到rt_interrupt_from_thread，直接跳转_reswitch
? ?                   ?;表示的是第一次切换线程，因为没有上文，所以直接跳到 _reswitch
? ? ?MOV ? ? r3, #1  ;不等则置1
? ? ?STR ? ? r3, [r2] ;rt_thread_switch_interrupt_flag = 1
??
? ? ?LDR ? ? r2, =rt_interrupt_from_thread ? ; set rt_interrupt_from_thread
? ? ?STR ? ? r0, [r2] ? ? ? ? ? ? ? ? ? ? ? ?;rt_interrupt_from_thread = r0,&sp,当前线程sp的地址
??
?_reswitch
? ? ?LDR ? ? r2, =rt_interrupt_to_thread ? ? ; set rt_interrupt_to_thread
? ? ?STR ? ? r1, [r2] ? ? ? ? ? ? ? ? ? ? ? ?;rt_interrupt_to_thread = r1,&sp,将要只要的线程的sp的地址
?    ;触发 pendsv 中断，线程切换的核心
? ? ?LDR ? ? r0, =NVIC_INT_CTRL ? ? ? ? ? ? ?; trigger the PendSV exception (causes context switch)
? ? ?LDR ? ? r1, =NVIC_PENDSVSET
? ? ?STR ? ? r1, [r0]
? ? ?BX ? ? ?LR
? ? ?ENDP
??
?; r0 --> switch from thread stack
?; r1 --> switch to thread stack
?; psr, pc, lr, r12, r3, r2, r1, r0 are pushed into [from] stack
?PendSV_Handler ? PROC
? ? ?EXPORT PendSV_Handler
??
? ? ?; 关闭所有中断以保护这一过程不被打断
? ? ?MRS ? ? r2, PRIMASK
? ? ?CPSID ? I
??
? ? ?; rt_thread_switch_interrupt_flag 为 1时才继续接下来的操作，为0则跳转 pendsv_exit
? ? ?LDR ? ? r0, =rt_thread_switch_interrupt_flag
? ? ?LDR ? ? r1, [r0]
? ? ?CBZ ? ? r1, pendsv_exit ? ? ? ? ; pendsv already handled
??
? ? ?; 清楚中断标志位
? ? ?MOV ? ? r1, #0x00
? ? ?STR ? ? r1, [r0]
?    ;判断 rt_interrupt_from_thread 是否为0，即是否是第一次切换线程，是0则跳转至switch_to_thread
? ? ?LDR ? ? r0, =rt_interrupt_from_thread
? ? ?LDR ? ? r1, [r0]
? ? ?CBZ ? ? r1, switch_to_thread ? ?; skip register save at the first time
??
? ? ?MRS ? ? r1, psp ? ? ? ? ? ? ? ? ; 获取当前线程栈指针到r1中
? ? ?STMFD ? r1!, {r4 - r11} ? ? ? ? ; 将r4 - r11寄存器中的值压入当前栈空间中
? ? ?LDR ? ? r0, [r0]
? ? ?STR ? ? r1, [r0] ? ? ? ? ? ? ? ?; 把当前线程栈指针记录到 rt_interrupt_from_thread 中，即当前栈指针 sp 中
??
?switch_to_thread
? ? ?LDR ? ? r1, =rt_interrupt_to_thread;获取将要执行的栈的sp的地址
? ? ?LDR ? ? r1, [r1]                
? ? ?LDR ? ? r1, [r1] ? ? ? ? ? ? ? ?
??
? ? ?LDMFD ? r1!, {r4 - r11} ? ? ? ? ; 从将要执行的栈中弹出这个线程中的寄存器r4-r11
? ? ?MSR ? ? psp, r1 ? ? ? ? ? ? ? ? ; 并把要执行的线程的栈指针给到 psp
??
?pendsv_exit
? ? ?; 恢复中断
? ? ?MSR ? ? PRIMASK, r2
?    ;由于cm3 内核发生中断时，堆栈指针使用的是msp,因此退出中断时，确保使用psp指针，实际操作就是对，lr寄存的位3进行置1就控制  ? ; 退出中断后使用psp中断
? ? ?ORR ? ? lr, lr, #0x04
? ? ?BX ? ? ?lr ;退出中断时使用psp指针
? ? ?ENDP

通过解读 pendsv 中断代码我们知道，在进入 pendsv 中断前，r0、r1、r2、r3、r12、lr、pc、psr 这些寄存器已经自动压入了当前栈中。
当 pendsv 中断退出时，新的将要执行的线程的中断上下文(r0、r1、r2、r3、r12、lr、pc、ps)会自动的从这个线程栈中弹出，程序计数器 PC 就得到了这个将要执行的线程的pc值，这个线程中用到的其他寄存器的值也从这个新的线程栈中得到了(一部分手动pop,一部分自动pop)。

问题点一：我可以通过这个线程栈指针访问到R0~R15的值吗？

答案是肯定的，因为我们传入的 sp 地址就指向了线程栈地址的偏移16个字处，而内核压栈时，先自动压入 r0、r1、r2、r3、r12、lr、pc、psr 这8个字的空间，按照顺序压，先压psr，然后我们手动压 r4 - r11 ，也是按照顺序压，先压r11。此时这16个字的空间就被填满了，这也是为什么线程栈结构体中的成员变量的顺序不是随便填的(个人理解)。

问题点二：当我进入hard_fault 异常时，我能否获取到当前线程栈指针，从而拿到 pc 指针来判断程序出错的位置？