深入理解进程切换

实验目的

1. 跟踪分析进程切换的过程完成实验
2. 总结进程切换的工作机制以及sp和ip在不同体系结构下汇编代码的切换方法
3. 深入理解进程切换

实验过程

进程上下文切换的入口是__schedule()，其主要的逻辑为：

1. 根据CPU获取运行队列，进而得到运行队列当前的task，也就是切换前的prev。
2. 根据prev的状态进行处理，比如pending信号的处理等，如果该任务是一个worker线程还需要将其睡眠，并唤醒同CPU上的另一个worker线程。
3. 根据调度类来选择需要切换过去的下一个task，也就是next。
   context_switch()完成进程的切换。该函数位于 Linux 内核源码目录下的 kernel/sched/core.c 中，代码如下：

static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
         struct task_struct *next, struct rq_flags *rf)
{
  prepare_task_switch(rq, prev, next);
 
  /*
   * For paravirt, this is coupled with an exit in switch_to to
   * combine the page table reload and the switch backend into
   * one hypercall.
   */
  arch_start_context_switch(prev);
 
  /*
   * kernel -> kernel   lazy + transfer active
   *   user -> kernel   lazy + mmgrab() active
   *
   * kernel ->   user   switch + mmdrop() active
   *   user ->   user   switch
   */
  if (!next->mm) {                                // to kernel
    enter_lazy_tlb(prev->active_mm, next);
 
    next->active_mm = prev->active_mm;
    if (prev->mm)                           // from user
      mmgrab(prev->active_mm);
    else
      prev->active_mm = NULL;
  } else {                                        // to user
    membarrier_switch_mm(rq, prev->active_mm, next->mm);
    /*
     * sys_membarrier() requires an smp_mb() between setting
     * rq->curr / membarrier_switch_mm() and returning to userspace.
     *
     * The below provides this either through switch_mm(), or in
     * case 'prev->active_mm == next->mm' through
     * finish_task_switch()'s mmdrop().
     */
    switch_mm_irqs_off(prev->active_mm, next->mm, next);
 
    if (!prev->mm) {                        // from kernel
      /* will mmdrop() in finish_task_switch(). */
      rq->prev_mm = prev->active_mm;
      prev->active_mm = NULL;
    }
  }
 
  rq->clock_update_flags &= ~(RQCF_ACT_SKIP|RQCF_REQ_SKIP);
 
  prepare_lock_switch(rq, next, rf);
 
  /* Here we just switch the register state and the stack. */
  switch_to(prev, next, prev);
  barrier();
 
  return finish_task_switch(prev);
}

content_switch 函数有三个参数：rq、prev、next。其中 rq 指向本次进程切换发生的 running queue；prev 和 next 分别指向切换前后进程的进程描述符。

可把 context_switch 函数具体分为几个部分。

1. prepare_task_switch( ) 与 finish_task_switch( )

在进程切换之前，执行调用的每个体系结构都必须与定义的 prepare_task_switch 函数挂钩。内核会执行与体系结构相关的一些调测指令, 为切换做事前准备。

static inline void
prepare_task_switch(struct rq *rq, struct task_struct *prev,
            struct task_struct *next)
{
    sched_info_switch(rq, prev, next);
    perf_event_task_sched_out(prev, next);
    fire_sched_out_preempt_notifiers(prev, next);
    prepare_lock_switch(rq, next);
    prepare_arch_switch(next);
}

上下文切换完成后，必须调用 finish_task_switch 函数。它与 prepare_task_switch 函数一定要成对出现。
2. arch_start_context_switch( )
该函数给各个体系结构开始上下文切换工作提供了入口，不同体系结构的实现不同。
3. 进程地址空间切换
判断 next 是用户进程还是内核线程。
如果是内核线程，进入 lazy tlb mode，借用或释放用户地址空间。
如果是用户进程，建立内存屏障，切换 mm_struct，清除或解除对 active_mm 的借用。
4. 内核在switch_to()中执行如下操作：

ENTRY(__switch_to_asm)
  UNWIND_HINT_FUNC
  /*
   * Save callee-saved registers
   * This must match the order in inactive_task_frame
   */
  pushq  %rbp
  pushq  %rbx
  pushq  %r12
  pushq  %r13
  pushq  %r14
  pushq  %r15
 
  /* switch stack */
  movq  %rsp, TASK_threadsp(%rdi) // 保存旧进程的栈顶
  movq  TASK_threadsp(%rsi), %rsp // 恢复新进程的栈顶
 
  /* restore callee-saved registers */
  popq  %r15
  popq  %r14
  popq  %r13
  popq  %r12
  popq  %rbx
  popq  %rbp
 
  jmp  __switch_to
END(__switch_to_asm)

进程切换, 即esp的切换, 由于从esp可以找到进程的描述符。
硬件上下文切换, 设置ip寄存器的值, 并jmp到__switch_to函数。
堆栈的切换, 即ebp的切换, ebp是栈底指针, 它确定了当前用户空间属于哪个进程。
最后，finish_task_switch()完成清理工作。
综上所述：
Linux中的进程切换主要包括以下几个步骤

1. 进程切换，即esp的切换，由于从esp可以找到进程的描述符。
2. 硬件上下文切换，设置ip寄存器的值，并jmp到__switch_to函数。
3. 堆栈的切换，即ebp的切换，ebp是栈底指针，它确定了当前用户空间属于哪个进程。
4. __switch_to函数完成寄存器和内核栈的保存和恢复，以及地址空间的切换。

不同体系结构下汇编代码的切换方法可能有所不同，例如ARM体系结构下，进程切换由context_switch函数实现，它调用switch_mm完成用户空间切换，调用switch_to完成内核栈及寄存器切换3。