Raspberry Pi OS 与 Linux 调度器:scheduler_tick、schedule 与上下文切换的深入剖析

原创2026-09-21 11:45:231,632 阅读
文章标签:操作系统教程文档嵌入式系统编程

Raspberry Pi OS 与 Linux 调度器:scheduler_tick、schedule 与上下文切换的深入剖析

本篇技术指南以 Linux v4.14 内核的 CFS 调度器为参照,聚焦两个关键入口——每个定时器中断都会调用的 scheduler_tick() 与需要重新调度时调用的 schedule(),并深入剖析架构高度相关的上下文切换(context switch)过程。文中所有概念均与 Raspberry Pi OS(RPi OS)项目第四课(lesson04)的调度器实现一一对照,读者学完后既能理解 Linux 调度器的最基本工作流,也能在 RPi OS 的 sched.c、sched.S 与 sched.h 中看到同一机制的简化实现。

一、为什么还要研究调度器

在阅读了进程调度的基础结构与任务派生机制之后(参见 4.3 Forking a task),Linux 调度器的内部工作细节大多已了然于心。为了让整幅画面完整,本章只需要再审视两个重要的调度器入口点:

  1. scheduler_tick():在每一次定时器中断时被调用(Linux v4.14 中定义于 kernel/sched/core.c)。
  2. schedule():在当前任务需要被重新调度时被调用(定义于 kernel/sched/core.c)。

除此之外,本章要研究的第三个核心主题是上下文切换(context switch)。上下文切换是一个"挂起当前任务、改而运行另一个任务"的过程,它高度依赖处理器架构,与我们在 RPi OS 中已经做过的许多工作密切相关——实际上,RPi OS 中的 cpu_switch_to 汇编例程几乎就是照搬自 Linux 内核。

二、scheduler_tick:每个定时器中断的调度心跳

scheduler_tick() 之所以重要,有两个原因:

  1. 它为调度器提供了更新当前任务时间统计与运行信息(runtime information)的机会。
  2. 这些运行信息随后被用来判断当前任务是否应当被抢占;如果需要,则调用 schedule()。

与之前探索过的大多数函数一样,scheduler_tick() 过于复杂、难以完整解释,这里只突出最重要的部分。

1. 主要工作在 CFS 的 task_tick_fair 中完成

scheduler_tick() 的主干工作在 CFS 调度类的 task_tick_fair 方法中完成(kernel/sched/fair.c)。该方法会为当前任务对应的 sched_entity 调用 entity_tick。

阅读源码时你可能会疑惑:为什么不是直接对当前的 sched_entity 调用 entity_tick,而是使用 for_each_sched_entity 宏?关键在于:for_each_sched_entity 并不遍历系统中所有的 sched_entity,它只沿着 sched_entity 的继承树向上遍历直到根节点。当任务被分组(task group)时这非常有用——在更新某个特定任务的运行信息之后,整个组对应的 sched_entity 也会一并被更新。

2. entity_tick 的两大职责

entity_tick 主要做两件事:

  • 调用 update_curr(kernel/sched/fair.c),负责更新任务的 vruntime 以及运行队列(runqueue)的 min_vruntime。这里需要牢记:vruntime 始终基于两件事——任务实际被运行了多久以及任务的优先级。
  • 调用 check_preempt_tick(kernel/sched/fair.c),检查当前任务是否需要被抢占。

3. check_preempt_tick 的两种抢占情形

check_preempt_tick 在以下两种情况下判定需要抢占:

  1. 当前任务运行时间过长:比较时使用的是普通时间(normal time),而不是 vruntime。
  2. 存在 vruntime 更小的任务,且两者 vruntime 之差大于某个阈值。

在这两种情况下,当前任务都会通过调用 resched_curr(kernel/sched/core.c)被标记为"需要被抢占"。

我们在上一章(fork 的流程)中已经看到,调用 resched_curr 最终会导致当前任务的 TIF_NEED_RESCHED 标志被置位,并在适当的时候触发对 schedule() 的调用。

三、schedule:比想象中简单得多的核心函数

前面已经见过大量使用 schedule() 的例子,现在来看它内部到底如何工作。令人惊讶的是,这个函数的内部其实相当简单。

  1. 主要工作都发生在 __schedule 函数中(kernel/sched/core.c)。
  2. __schedule 调用 pick_next_task(kernel/sched/core.c),后者将绝大部分工作转交给 CFS 调度类的 pick_next_task_fair 方法(kernel/sched/fair.c)。
  3. 正如你所预料的,pick_next_task_fair 在一般情况下就是选取红黑树(red-black tree)最左侧的节点并返回——因为 vruntime 最小的任务就位于树的最左端,它就是最应该被运行的任务。
  4. __schedule 调用 context_switch(kernel/sched/core.c),context_switch 做一些准备工作后,调用架构相关的 __switch_to(arm64 下定义于 arch/arm64/kernel/process.c),在这里准备好用于切换的底层架构相关任务参数。
  5. __switch_to 首先切换一些额外的任务组件,例如 TLS(Thread-local Storage,线程局部存储) 以及保存的浮点与 NEON 寄存器。
  6. 真正的切换发生在汇编函数 cpu_switch_to(arch/arm64/kernel/entry.S)中。这个函数你应当已经很熟悉了,因为它几乎被原封不动地复制到了 RPi OS 里。如你所记得的,这个函数切换被调用者保存的寄存器(callee-saved registers)以及任务栈。当它返回后,新任务将使用自己的内核栈继续运行。

四、对照 RPi OS:定时器驱动的抢占与轮转调度

理解了 Linux 的 scheduler_tick 之后,再看 RPi OS 的实现就一目了然。在 RPi OS 中,定时器中断经由 timer.c 的 handle_timer_irq 最终进入调度器:

  • timer.c 每 200000 个时钟周期触发一次系统定时器中断(SYSTEM_TIMER_IRQ_1),由 irq.c 的 handle_irq 分发到 handle_timer_irq。
  • handle_timer_irq 调用 timer_tick(),其实现位于 sched.c:
void timer_tick()
{
	--current->counter;
	if (current->counter>0 || current->preempt_count >0) {
		return;
	}
	current->counter=0;
	enable_irq();
	_schedule();
	disable_irq();
}

这段代码与 Linux scheduler_tick 的语义一一对应:

  • 每次定时器中断递减当前任务的 counter(时间片计数器)——这相当于"更新任务的运行时间统计"。
  • 如果时间片还有剩余(counter > 0),或者当前处于不可抢占区域(preempt_count > 0),则直接返回——相当于 Linux 中抢占被禁止的情形。
  • 否则将 counter 清零、临时使能中断(让新任务启动时中断可用),调用 _schedule() 触发重新调度,再关中断。

五、对照 RPi OS:schedule 与基于优先级的任务选择

Linux 的 schedule() 依赖 CFS 红黑树选取最左节点;RPi OS 则用更朴素的优先级 + 时间片轮转方式实现同样的"选择下一个任务"逻辑,见 sched.c:

void _schedule(void)
{
	preempt_disable();
	int next,c;
	struct task_struct * p;
	while (1) {
		c = -1;
		next = 0;
		for (int i = 0; i < NR_TASKS; i++){
			p = task[i];
			if (p && p->state == TASK_RUNNING && p->counter > c) {
				c = p->counter;
				next = i;
			}
		}
		if (c) {
			break;
		}
		for (int i = 0; i < NR_TASKS; i++) {
			p = task[i];
			if (p) {
				p->counter = (p->counter >> 1) + p->priority;
			}
		}
	}
	switch_to(task[next]);
	preempt_enable();
}

流程要点:

  1. _schedule 先调用 preempt_disable() 关闭抢占,防止切换过程中再被中断打断。
  2. 在所有 NR_TASKS(定义于 sched.h,值为 64)个任务中,挑选状态为 TASK_RUNNING 且 counter 最大的任务作为下一个运行对象——这相当于 Linux 中 pick_next_task_fair 选择 vruntime 最小的任务。
  3. 如果所有任务 counter 都已耗尽(c 为 0/负),则对所有任务执行重算公式 counter = (counter >> 1) + priority 再重新选择——这是 Linux 旧式 O(1)/轮转调度中经典的"时间片重置"思想,保证高优先级任务获得更长运行时间。
  4. 选定后调用 switch_to(task[next]) 完成切换。

schedule() 则是主动让出 CPU 的入口:它先把当前任务的 counter 清零(等价于"用尽时间片"),再调用 _schedule()。在 kernel.c 的 kernel_main 中,主循环就是反复调用 schedule() 来让两个内核进程交替运行:

while (1){
	schedule();
}

六、对照 RPi OS:上下文切换与 cpu_switch_to

上下文切换是本章的第三个核心概念。在 RPi OS 中,switch_to 负责更新全局 current 指针并调用架构相关的 cpu_switch_to,见 sched.c:

void switch_to(struct task_struct * next)
{
	if (current == next)
		return;
	struct task_struct * prev = current;
	current = next;
	cpu_switch_to(prev, next);
}

cpu_switch_to 的汇编实现位于 sched.S,与 Linux 内核 arch/arm64/kernel/entry.S 中的同名函数几乎一致:

.globl cpu_switch_to
cpu_switch_to:
	mov	x10, #THREAD_CPU_CONTEXT
	add	x8, x0, x10
	mov	x9, sp
	stp	x19, x20, [x8], #16		// store callee-saved registers
	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
	str	x30, [x8]
	add	x8, x1, x10
	ldp	x19, x20, [x8], #16		// restore callee-saved registers
	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
	ldr	x30, [x8]
	mov	sp, x9
	ret

对照 Linux 的 cpu_switch_to,可以确认以下几点:

  • THREAD_CPU_CONTEXT 是 cpu_context 在 task_struct 中的偏移,在 sched.h 中定义为 0(cpu_context 恰好是 task_struct 的第一个字段)。
  • 切换的寄存器正是 callee-saved 寄存器:x19~x28、帧指针 x29、栈指针 sp 与返回地址 x30(pc)。这保证了函数调用约定要求的"被调用者保存"寄存器在新任务中完好无损。
  • 通过 mov sp, x9 把栈指针切换到新任务的内核栈顶,随后 ret 跳转到新任务预先设定的返回地址——即 ret_from_fork(见下文)。

linux cpu_switch_to 的上下文 中还定义了对齐的 cpu_context 结构,RPi OS 的 sched.h 中与之对应:

struct cpu_context {
	unsigned long x19;
	unsigned long x20;
	unsigned long x21;
	unsigned long x22;
	unsigned long x23;
	unsigned long x24;
	unsigned long x25;
	unsigned long x26;
	unsigned long x27;
	unsigned long x28;
	unsigned long fp;
	unsigned long sp;
	unsigned long pc;
};

新任务如何"凭空"开始运行

上下文切换能让新任务从某个"已暂停"的位置继续,但首次运行的新任务并没有可恢复的现场——这正是 copy_process 的职责所在。在 fork.c 中,新任务的 cpu_context 被人工构造出来:

  • cpu_context.x19 = fn:新任务要执行的函数地址(相当于 Linux copy_thread 中 x19 = stack_start)。
  • cpu_context.x20 = arg:传给该函数的参数。
  • cpu_context.pc = (unsigned long)ret_from_fork:首次切换返回时进入 ret_from_fork(定义于 entry.S)。
  • cpu_context.sp = (unsigned long)p + THREAD_SIZE:内核栈顶端(THREAD_SIZE 为 4096)。

这与 Linux copy_thread(arch/arm64/kernel/process.c)的核心思路完全一致:cpu_context.pc 指向 ret_from_fork,sp 指向新任务自己的栈,x19/x20 携带入口函数与参数。当调度器第一次通过 switch_to 切到这个任务时,cpu_switch_to 会加载这些寄存器并 ret 到 ret_from_fork,再由后者跳转到 fn(arg) 开始执行。

七、在 RPi OS 中观察完整调度流程

综合以上各节,RPi OS 中一次完整的"抢占式调度 + 上下文切换"工作流如下:

  1. 系统定时器中断到达,handle_irq(irq.c)识别出 SYSTEM_TIMER_IRQ_1,调用 handle_timer_irq(timer.c)。
  2. handle_timer_irq 重装定时器比较值并调用 timer_tick()(sched.c),后者递减当前任务 counter。
  3. 时间片耗尽且未禁止抢占时,调用 _schedule() 选出 counter 最大的就绪任务,经 switch_to → cpu_switch_to(sched.S)完成寄存器与栈的切换。
  4. 若被选中的是新任务,cpu_switch_to 的 ret 会跳转到 ret_from_fork,进而执行 kernel.c 中 process 函数,两个进程分别循环输出 "12345" 与 "abcde"。
  5. 每次定时器中断都会重复上述过程,从而在两个任务之间实现时间片轮转;而 kernel.c 主循环中的主动 schedule() 则对应 Linux 中的主动让出调度。

八、结论

至此,我们对 Linux 调度器的学习告一段落。好消息是:如果只关注最基本的工作流,调度器其实并不难。scheduler_tick 在每次定时器中断时更新任务运行信息并判断抢占;schedule 通过 pick_next_task_fair 从红黑树选出 vruntime 最小的任务,再经由 context_switch、__switch_to 与汇编级 cpu_switch_to 完成上下文切换。理解了这条主线之后,你或许还想沿着调度代码再走一遍、多关注其中的细节,因为细节实在太多了。但对目前来说,这份理解已经足够支撑我们进入下一课——用户进程与系统调用。

登录后查看全文
raspberry-pi-os