RTEMS 进程切换分析（基于i386体系）

在支持多任务操作系统中，进程切换是不可避免的，以使进程能在单个CPU上并发执行。进程的调度涉及到的东西较多，例如调度的时机、调度的策略等等，在这里我们只讨论RTEMS任务调度中进程切换的细节，通过分析以明白操作系统如何做到使一个CPU的使用权如何从一个任务上切换到另一个任务。

下面假设两个任务TASK1和TASK2，当前正在执行的任务executing = TASK1，需要切换到的任务 heir = TASK2，下面为进程调度进行上下文切换的代码（最精简的一个函数，除去多核的配置、其他一些扩展函数、可配置的浮点上下文保存恢复等代码）：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

void _Thread_Dispatch( void ) {   Thread_Control   *executing;   Thread_Control   *heir;   ISR_Level         level;   /*    *  Now determine if we need to perform a dispatch on the current CPU.    */   executing   = _Thread_Executing;   _ISR_Disable( level );   while ( _Thread_Dispatch_necessary == true ) {     heir = _Thread_Heir;     _Thread_Dispatch_necessary = false;     _Thread_Executing = heir;     /*      *  When the heir and executing are the same, then we are being      *  requested to do the post switch dispatching.  This is normally      *  done to dispatch signals.      */     if ( heir == executing )       goto post_switch;     /*      *  Since heir and executing are not the same, we need to do a real      *  context switch.      */     _ISR_Enable( level );     _Context_Switch( &executing->Registers, &heir->Registers );     executing = _Thread_Executing;     _ISR_Disable( level );   } post_switch:   _ISR_Enable( level ); }

此函数执行之前，有两个全局变量_Thread_Executing 和 _Heir_Executing 分别指向 Task1 和 Task2 的进程控制块TCB，下面对此函数进行分析：

首先：切换之后全局变量 _Thread_Executing 应该指向 Task2（第15行）;

其次，如果切换之前和切换之后是同一个任务，就无需进行上下文切换（第22行）；

若不同，则必须进行上下文切换，使CPU的控制权转到Task2上。所谓的上下文切换，就是保存Task1进程执行的上下文（主要是一些重要的寄存器），并且恢复Task2进程被切换出去之前执行的上下文。

进程控制块TCB中有个字段Context_Control  Registers 是用来保存/恢复上下文的，该结构体在i386体系下定义为：

typedef struct
{
    uint32_t    eflags;   /* extended flags register                   */
    void       *esp;      /* extended stack pointer register           */
    void       *ebp;      /* extended base pointer register            */
    uint32_t    ebx;      /* extended bx register                      */
    uint32_t    esi;      /* extended source index register            */
    uint32_t    edi;      /* extended destination index flags register */
} Context_Control;

也即意味着两个进程进行切换时，需要保存的寄存器有EFLAGS、ESP、EBP、EBX、ESI、EDI等，第32行_Context_Switch 函数完成：切换之前将这些寄存器的值保存在需要切换的进程（此处为Task1）TCB的Registers中，切换时这些寄存器的值从即将切换的进程（此处为Task2）TCB的Registers中恢复。这是一个与体系结构相关的操作，需要使用汇编去完成，我们看看_Context_Switch( &executing->Registers, &heir->Registers ) 的汇编实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

/* * Format of i386 Register structure */ .set REG_EFLAGS,  0 .set REG_ESP,     REG_EFLAGS + 4 .set REG_EBP,     REG_ESP + 4 .set REG_EBX,     REG_EBP + 4 .set REG_ESI,     REG_EBX + 4 .set REG_EDI,     REG_ESI + 4 .set SIZE_REGS,   REG_EDI + 4         BEGIN_CODE /* *  void _CPU_Context_switch( run_context, heir_context ) * *  This routine performs a normal non-FP context. */         .p2align  1         PUBLIC (_CPU_Context_switch) .set RUNCONTEXT_ARG,   4                   /* save context argument */ .set HEIRCONTEXT_ARG,  8                   /* restore context argument */ SYM (_CPU_Context_switch):         movl      RUNCONTEXT_ARG(esp),eax  /* eax = running threads context */         pushf                              /* push eflags */         popl      REG_EFLAGS(eax)          /* save eflags */         movl      esp,REG_ESP(eax)         /* save stack pointer */         movl      ebp,REG_EBP(eax)         /* save base pointer */         movl      ebx,REG_EBX(eax)         /* save ebx */         movl      esi,REG_ESI(eax)         /* save source register */         movl      edi,REG_EDI(eax)         /* save destination register */         movl      HEIRCONTEXT_ARG(esp),eax /* eax = heir threads context */ restore:         pushl     REG_EFLAGS(eax)          /* push eflags */         popf                               /* restore eflags */         movl      REG_ESP(eax),esp         /* restore stack pointer */         movl      REG_EBP(eax),ebp         /* restore base pointer */         movl      REG_EBX(eax),ebx         /* restore ebx */         movl      REG_ESI(eax),esi         /* restore source register */         movl      REG_EDI(eax),edi         /* restore destination register */         ret

在进入此汇编代码之前，Task1 栈为：

解释一下，C语言通过堆栈传参惯例，参数从右到左依次压栈，然后将下一条程序指针压栈，因此在进入_CPU_Context_Switch函数之后Task1栈如上图所示。函数体完成的功能：

第一步：将Task1上下文保存在Task1->Registers结构体中（第28~35行）。

28：将Task1->Register的指针（esp+4）保存在eax寄存器中；

29：将eflags寄存器压栈（pushl）；

30：再出栈，存放在(&Task1->Register)->eflags中；

31~35：分别将esp、ebp、ebx、esi、edi寄存器的值保存在Task1->Register结构的相关字段中。

到此为止，完成了保存Task1进程的上下文，Task1切换出去之前栈还是如上图所示。

同理可以想象Task2被其他进程切换走之后一定也具有类似的栈结构，Task2->Registers中保存的是切换出去之前的它的上下文。

第二步：从Task2->Register结构中恢复Task2的上下文（第37~46行）。

37：将Task2->Registers的指针（esp+8）保存在eax寄存器中；

40：将Task2->Registers.eflags（即Task2切换出去之前保存的eflags寄存器）压栈；

41：出栈popf，此时eflags寄存器恢复为Task2上下文的eflags；

42：恢复esp，此步最为关键，因为此步之后esp寄存器将由Task1栈顶转移到Task2栈顶，此后操作将在Task2的栈上进行；

43~46：依次恢复esp、ebp、ebx、esi、edi寄存器。

至此，完成了恢复Task2进程的上下文。

第三步：从_CPU_Context_Switch 函数返回。

47：ret操作，弹出栈顶到eip中，注意esp此时已经指向的是Task2的栈，但是上面我们说过Task2栈与Task1栈切换之前的结构是类似的，因此Task2栈顶保存的仍然是_Context_Switch 下一条语句的代码。

从汇编函数中返回之后，又回到_Thread_Dispatch 函数体中，只不过与之前不同的是，此时处理器运行在Task2的上下文环境中。

 

---

 

还有一个问题需要我们去探索：如果Task2是第一次被调度执行，即Task2之前没有被切换出去，不曾执行到_Thread_Dispatch 中的 _Context_Switch 切换出去，也就是Task2栈并不是我们上面讨论的那样，同样我们也不希望Task2第一次被调度执行的第一条代码不是_Context_Switch 的下一条语句，因为Task2栈上并不存在_Thread_Dispatch函数的栈帧，如果这样，肯定会出现不可预期的错误。

所以，我们在创建任务时，就需要先初始化好Task2的栈，使得其第一次调度时，执行的是我们需要它需要执行的代码。

在rtems_task_start –> _Thread_Start –> _Thread_Load_environment –> _Context_initialize 函数会在任务加入就绪队列的时候进行上下文初始化。函数调用如下：

1 2 3 4 5 6 7 8

_Context_Initialize(   &the_thread->Registers,                   //任务上下文结构指针                    the_thread->Start.Initial_stack.area,     //指向新建的一个任务栈区域的基址   the_thread->Start.Initial_stack.size,     //任务栈的大小   the_thread->Start.isr_level,              //中断级别   _Thread_Handler,                          //任务执行时第一次要执行的代码   is_fp );

 

我们看看这个函数实现的汇编代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#define _CPU_Context_Initialize( _the_context, _stack_base, _size, \                                    _isr, _entry_point, _is_fp ) \   do { \     uint32_t   _stack; \     \     if ( (_isr) ) (_the_context)->eflags = CPU_EFLAGS_INTERRUPTS_OFF; \     else          (_the_context)->eflags = CPU_EFLAGS_INTERRUPTS_ON; \     \     _stack  = ((uint32_t)(_stack_base)) + (_size); \     _stack &= ~ (CPU_STACK_ALIGNMENT - 1); \     _stack -= 2*sizeof(proc_ptr*);  \     *((proc_ptr *)(_stack)) = (_entry_point); \     (_the_context)->ebp     = (void *) 0; \     (_the_context)->esp     = (void *) _stack; \   } while (0)

第6&7行通过参数isr来决定应初始化elfags寄存器的值；

第9&10行根据栈基址以及栈的大小计算出初始时栈顶的位置（需要对齐）；

第11行将栈顶的位置往下移两个指针大小；

第12行将程序入口指针_entry_point写入栈顶；

第13&14行分别初始化ebp、esp寄存器。

初始任务栈的示意图如下：

至此，任务初始上下文初始化完成，主要初始化了eflags、esp、ebp等寄存器，保存在TCB的registers结构体中。

当一个从未执行的任务第一次被调度执行时，回到上下文切换函数_Context_Switch中，保存和恢复和上面一样，只不过在第三步ret操作时，会返回栈顶位置的值当作程序指针，和上面区别的是：这种情形eip不是跳到_Context_Switch的下一句，而是我们初始化保存在栈顶的值_entry_point。返回之后，就会执行所_entry_point指向的函数_Thread_Handle，在这个函数会执行到我们创建的任务体中。

 

结束语：上面讨论的是基于i386体系下RTEMS任务切换上下文的过程，虽然是基于特定的体系结构特定的操作系统，但对于任一个多任务的操作系统任务切换都大相径庭，无非就是保存上下文、恢复上下文，而若移植操作系统，这是需要针对特定平台进行改写的一段代码。