lab5：深入理解进程切换

一、进程调度时机就是内核调用schedule函数的时机

• 用户进程上下文中主动调用特定的系统调用进入中断上下文，系统调用返回用户态之前进行进程调度。
• 内核线程或可中断的中断处理程序，执行过程中发生中断进入中断上下文，在中断返回前进行进程调度。
• 内核线程主动调用schedule函数进行进程调度。

以上第一种和第二种情况可以统一起来，中断处理程序执行过程主动调用schedule函数进行进程调度，与前述两类调度时机对应

 二、分析schedule函数

2.1 源码

static void __sched notrace __schedule(bool preempt)
{
	struct task_struct *prev, *next;
	unsigned long *switch_count;
	struct rq_flags rf;
	struct rq *rq;
	int cpu;

	cpu = smp_processor_id();
	rq = cpu_rq(cpu);
	prev = rq->curr;

	schedule_debug(prev, preempt);

	if (sched_feat(HRTICK))
		hrtick_clear(rq);

	local_irq_disable();
	rcu_note_context_switch(preempt);
	rq_lock(rq, &rf);
	smp_mb__after_spinlock();

	/* Promote REQ to ACT */
	rq->clock_update_flags <<= 1;
	update_rq_clock(rq);

	switch_count = &prev->nivcsw;
	if (!preempt && prev->state) {
		if (signal_pending_state(prev->state, prev)) {
			prev->state = TASK_RUNNING;
		} else {
			deactivate_task(rq, prev, DEQUEUE_SLEEP | DEQUEUE_NOCLOCK);

			if (prev->in_iowait) {
				atomic_inc(&rq->nr_iowait);
				delayacct_blkio_start();
			}
		}
		switch_count = &prev->nvcsw;
	}

	next = pick_next_task(rq, prev, &rf);
	clear_tsk_need_resched(prev);
	clear_preempt_need_resched();

	if (likely(prev != next)) {
		rq->nr_switches++;
		++*switch_count;

		trace_sched_switch(preempt, prev, next);

		/* Also unlocks the rq: */
		rq = context_switch(rq, prev, next, &rf);
	} else {
		rq->clock_update_flags &= ~(RQCF_ACT_SKIP|RQCF_REQ_SKIP);
		rq_unlock_irq(rq, &rf);
	}

从代码中可以看到，schedule主要有两个工作：

1. 首先，schedule()函数会调用next = pick_next_task(rq,prev);所做的工作就是根据调度算法策略，选取要执行的下一个进程。
2. 其次，调用context_switch(rq, prev,next);，完成进程上下文切换。其中，最关键的switch_to(prev,next, last)：切换堆栈和寄存器的状态。

2.2 分析 context_switch源码

static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
	       struct task_struct *next, struct rq_flags *rf)
{
    /*
     * 准备进行进程切换，置 prev 和 next 的一些状态，例如 prev 的状态设置为
     * TASK_RUNNING，同时更新 rq 的 curr 和 next 任务的时间戳等
     */
	prepare_task_switch(rq, prev, next);
    /*
     * 切换前的准备工作，包括更新上下文寄存器、设置栈等
     */
	arch_start_context_switch(prev);
    /*
     * 此段代码实现了进程地址空间的切换
     */
	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);
		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);
    /*
     * 切换寄存器状态和栈，后面详细分析
     */
	switch_to(prev, next, prev);
	barrier();
	return finish_task_switch(prev);
}

三、分析X86和ARM结构下的switch_to()汇编代码

3.1 X86下的汇编源码分析

/*
 * %rdi: prev task
 * %rsi: next task
 */
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

#ifdef CONFIG_STACKPROTECTOR
	movq	TASK_stack_canary(%rsi), %rbx
	movq	%rbx, PER_CPU_VAR(fixed_percpu_data) + stack_canary_offset
#endif

#ifdef CONFIG_RETPOLINE
	/*
	 * When switching from a shallower to a deeper call stack
	 * the RSB may either underflow or use entries populated
	 * with userspace addresses. On CPUs where those concerns
	 * exist, overwrite the RSB with entries which capture
	 * speculative execution to prevent attack.
	 */
	FILL_RETURN_BUFFER %r12, RSB_CLEAR_LOOPS, X86_FEATURE_RSB_CTXSW
#endif

	/* restore callee-saved registers */
	popq	%r15
	popq	%r14
	popq	%r13
	popq	%r12
	popq	%rbx
	popq	%rbp

	jmp	__switch_to
END(__switch_to_asm)

• 中间的两条 movq 语句就是新旧进程的分界线，保存旧进程的栈顶并恢复新进程的栈顶，随着内核栈顶的切换，内核栈空间也就切换到了新进程，之后只需要弹出栈中保存的各个寄存器的值即可恢复寄存器状态
• 但是上述代码并没有显式的完成RIP寄存器的切换。原因是这段汇编的结尾是jmp __switch_to，__switch_to函数是C代码最后有个return，也就是ret指令。将__switch_to_asm和__switch_to结合起来，正好是call指令和ret指令的配对出现。

3.2 ARM下的汇编源码分析

ENTRY(cpu_switch_to)
  mov  x10, #THREAD_CPU_CONTEXT  // 寄存器x10存放thread.cpu_context偏移，与进程task_struct地址相加后即可获得该进程的cpu_context
  add  x8, x0, x10               // x0与偏移量相加后存入x8，获取旧进程cpu_context的地址
  mov  x9, sp                    // 将栈顶sp存入x9，以备后续保存

  // 保存x19~x28寄存器的值，每条指令执行完毕后x8的值会自动+16，以便保存后续寄存器值
  stp  x19, x20, [x8], #16
  stp  x21, x22, [x8], #16
  stp  x23, x24, [x8], #16
  stp  x25, x26, [x8], #16
  stp  x27, x28, [x8], #16

  stp  x29, x9, [x8], #16        // 保存x29(栈基址)与x9(栈顶sp)
  str  lr, [x8]                  // 保存寄存器LR，该寄存器存放了cpu_switch_to函数的返回地址

  add  x8, x1, x10               // x1与偏移量相加后存入x8，获取新进程cpu_context的地址

  // 恢复x19~x28寄存器的值
  ldp  x19, x20, [x8], #16
  ldp  x21, x22, [x8], #16
  ldp  x23, x24, [x8], #16
  ldp  x25, x26, [x8], #16
  ldp  x27, x28, [x8], #16

  ldp  x29, x9, [x8], #16        // 恢复x29(栈基址)与x9(栈顶sp)
  ldr  lr, [x8]                  // 恢复寄存器LR，这样函数cpu_switch_to返回后就会从新进程上次被中断的位置处继续执行
  mov  sp, x9                    // 从x9处恢复sp的值
  msr  sp_el0, x1                // 将新进程进程task_struct地址放入sp_el0
  ret
ENDPROC(cpu_switch_to)
NOKPROBE(cpu_switch_to)

• arm64 也没有显式保存和恢复程序计数器 PC 的值，这和 x86_64 的处理方法类似