Linux CFS 的 switched_from/switched_to：调度类切换的处理

一、简介

在Linux内核的调度子系统中，任务在不同调度类之间切换是一个复杂且关键的操作。当应用程序调用sched_setscheduler()将任务从普通调度策略（SCHED_NORMAL）切换为实时策略（SCHED_FIFO/SCHED_RR），或者从实时策略降级为普通策略时，内核必须完成一系列精细的状态迁移操作。

CFS（Completely Fair Scheduler）作为Linux默认的普通任务调度器，通过switched_from_fair()和switched_to_fair()这两个回调函数来处理任务进出CFS调度类的状态转换。这两个函数定义在fair_sched_class调度类中，是struct sched_class接口的重要组成部分。

掌握这一机制对于以下场景至关重要：

• 实时系统调优：理解任务在RT与CFS之间切换时的延迟开销

• 容器资源管控：分析CFS Bandwidth Control在调度类切换时的节流行为

• 性能问题定位：排查因调度类切换导致的vruntime异常或负载不均衡问题

• 内核开发：编写自定义调度类或修改现有调度逻辑时的参考实现

二、核心概念

2.1 调度类（sched_class）架构

Linux内核采用模块化调度类设计，每个调度类通过struct sched_class结构体注册一组回调函数。CFS调度类的定义位于kernel/sched/fair.c，其核心回调包括：

const struct sched_class fair_sched_class = { .enqueue_task = enqueue_task_fair, .dequeue_task = dequeue_task_fair, .pick_next_task = pick_next_task_fair, .task_tick = task_tick_fair, .switched_from = switched_from_fair, // 离开CFS时调用 .switched_to = switched_to_fair, // 进入CFS时调用 .prio_changed = prio_changed_fair, // ... 其他回调 };

2.2 调度实体（sched_entity）与CFS运行队列（cfs_rq）

每个任务在CFS中通过sched_entity结构体表示，该实体维护着关键的调度状态：

• vruntime：虚拟运行时间，决定任务在红黑树中的位置

• load.weight：权重值，反映任务的优先级

• on_rq：标记任务是否已在运行队列中

• cfs_rq：指向任务所属CFS运行队列的指针

当任务在不同CPU或不同cgroup之间迁移时，必须正确处理这些状态字段，以保证调度公平性。

2.3 调度类切换的触发点

调度类切换通常发生在以下场景：

1. 显式策略变更：用户调用sched_setscheduler()修改任务调度策略

2. 优先级继承（PI）：RT互斥锁导致的优先级提升/恢复

3. cgroup迁移：任务在不同CPU cgroup之间移动时可能涉及调度类变更

核心切换逻辑位于check_class_changed()函数：

void check_class_changed(struct rq *rq, struct task_struct *p, const struct sched_class *prev_class, int oldprio) { if (prev_class != p->sched_class) { if (prev_class->switched_from) prev_class->switched_from(rq, p); // 旧类清理 p->sched_class->switched_to(rq, p); // 新类初始化 } else if (oldprio != p->prio) { p->sched_class->prio_changed(rq, p, oldprio); } }

三、环境准备

3.1 硬件与软件要求

3.2 内核编译与配置

# 1. 获取内核源码 git clone https://github.com/torvalds/linux.git cd linux git checkout v6.6 # 2. 配置内核选项（关键调度相关配置） make menuconfig # 必须启用的选项： # CONFIG_SCHED_DEBUG=y # 调度器调试 # CONFIG_CGROUP_SCHED=y # cgroup调度支持 # CONFIG_FAIR_GROUP_SCHED=y # CFS组调度 # CONFIG_CFS_BANDWIDTH=y # CFS带宽控制 # CONFIG_SCHEDSTATS=y # 调度统计信息 # 3. 编译并安装 make -j$(nproc) sudo make modules_install sudo make install

3.3 调试环境搭建

# 安装调试工具 sudo apt-get install -y \ linux-headers-$(uname -r) \ bpftrace \ trace-cmd \ kernelshark \ sysstat # 挂载debugfs以访问调度器调试信息 sudo mount -t debugfs none /sys/kernel/debug # 启用调度器事件跟踪 echo 1 > /sys/kernel/debug/tracing/events/sched/sched_switch/enable echo 1 > /sys/kernel/debug/tracing/events/sched/sched_wakeup/enable

四、应用场景

在工业自动化控制系统中，典型的应用场景是PLC（可编程逻辑控制器）软实时任务与后台数据分析任务的混合部署。假设某产线监控系统需要：

1. 数据采集任务：以SCHED_FIFO策略运行，优先级50，周期1ms采集传感器数据

2. 日志处理任务：以SCHED_NORMAL策略运行，批量处理历史数据

3. 动态降级机制：当系统负载过高时，将非关键RT任务降级为CFS任务

在这种场景下，当运维人员通过sched_setscheduler()将日志处理任务从SCHED_NORMAL切换为SCHED_BATCH以优化吞吐量时，内核会触发switched_from_fair()完成CFS状态的清理；反之，当系统负载降低需要将某个CFS任务提升为RT任务时，switched_to_fair()的逆过程会被执行。理解这两个函数的底层实现，有助于预测调度延迟、分析上下文切换开销，并设计合理的任务迁移策略。

五、实际案例与步骤

5.1 案例一：从CFS切换到RT类（switched_from_fair分析）

当任务从CFS切换到RT调度类时，switched_from_fair()负责清理任务在CFS中的状态。

// 位于 kernel/sched/fair.c static void switched_from_fair(struct rq *rq, struct task_struct *p) { // 1. 将任务从其所属的cfs_rq中分离 detach_task_cfs_rq(p); // 2. 如果启用了CFS带宽控制，取消任务的节流状态 if (cfs_bandwidth_used()) task_throttle_cancel(p); }

detach_task_cfs_rq()的核心逻辑：

static void detach_task_cfs_rq(struct task_struct *p) { struct sched_entity *se = &p->se; struct cfs_rq *cfs_rq = cfs_rq_of(se); // 如果任务当前在运行队列上，先出队 if (task_on_rq_queued(p)) { dequeue_entity(cfs_rq, se, DEQUEUE_SAVE | DEQUEUE_MOVE); } // 分离任务组关联（如果启用了组调度） #ifdef CONFIG_FAIR_GROUP_SCHED if (se->cfs_rq) { // 更新cfs_rq的负载统计 update_cfs_rq_load_avg(cfs_rq); // 从父调度实体链中分离 for_each_sched_entity(se) { struct cfs_rq *qcfs_rq = cfs_rq_of(se); if (qcfs_rq->tg) set_task_rq(p, task_cpu(p)); } } #endif // 清除任务在CFS中的运行时统计关联 se->cfs_rq = NULL; }

操作步骤与验证：

# 步骤1：创建测试任务并监控其调度状态 cat > /tmp/test_task.c << 'EOF' #include <stdio.h> #include <stdlib.h> #include <sched.h> #include <unistd.h> #include <sys/syscall.h> int main() { pid_t pid = getpid(); struct sched_param param; printf("Task %d started with policy %d\n", pid, sched_getscheduler(0)); // 模拟工作负载 for (int i = 0; i < 5; i++) { sleep(1); // 切换到SCHED_FIFO param.sched_priority = 50; if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) { perror("sched_setscheduler"); exit(1); } printf("Switched to SCHED_FIFO, priority %d\n", param.sched_priority); sleep(1); // 切换回SCHED_NORMAL param.sched_priority = 0; if (sched_setscheduler(0, SCHED_NORMAL, &param) == -1) { perror("sched_setscheduler"); exit(1); } printf("Switched back to SCHED_NORMAL\n"); } return 0; } EOF gcc -o /tmp/test_task /tmp/test_task.c # 步骤2：使用ftrace跟踪调度类切换 sudo trace-cmd start -e sched_switch -e sched_wakeup -e sched_setscheduler /tmp/test_task & sudo trace-cmd stop sudo trace-cmd report > /tmp/sched_trace.txt # 步骤3：分析trace结果，观察switched_from/switched_to调用路径 grep -A 5 -B 5 "sched_setscheduler\|switched_from\|switched_to" /tmp/sched_trace.txt

5.2 案例二：从RT类切换到CFS（switched_to_fair分析）

当任务从RT类降级到CFS时，switched_to_fair()负责初始化任务在CFS中的状态：

static void switched_to_fair(struct rq *rq, struct task_struct *p) { // 1. 将任务附加到目标cfs_rq attach_task_cfs_rq(p); // 2. 如果启用了带宽控制且任务需要节流，设置节流状态 if (cfs_bandwidth_used() && task_needs_throttling(p)) task_throttle_setup(p); // 3. 设置任务的最大允许容量（与CPU容量管理相关） set_task_max_allowed_capacity(p); // 4. 如果任务在运行队列上，检查是否需要抢占当前任务 if (task_on_rq_queued(p)) { /* * 任务很可能从sched_rt切换而来，如果当前正在运行则触发调度， * 否则检查是否还能抢占当前任务 */ if (rq->curr == p) resched_curr(rq); // 触发重新调度 else check_preempt_curr(rq, p, 0); // 检查抢占条件 } }

attach_task_cfs_rq()的核心逻辑：

static void attach_task_cfs_rq(struct task_struct *p) { struct sched_entity *se = &p->se; struct cfs_rq *cfs_rq = cfs_rq_of(se); // 设置任务所属的cfs_rq se->cfs_rq = cfs_rq; // 初始化或同步vruntime if (!se->avg.last_update_time) { // 新加入CFS的任务，需要合理设置初始vruntime place_entity(cfs_rq, se, 0); } else { // 从其他CPU迁移或从RT降级，同步min_vruntime基准 se->vruntime += cfs_rq->min_vruntime; } // 如果任务在运行队列上，执行入队操作 if (task_on_rq_queued(p)) { enqueue_entity(cfs_rq, se, ENQUEUE_WAKEUP); update_load_avg(cfs_rq, se, 0); } #ifdef CONFIG_FAIR_GROUP_SCHED // 更新任务组层级结构 if (se->cfs_rq->tg) { update_cfs_rq_load_avg(cfs_rq); propagate_entity_cfs_rq(se); } #endif }

vruntime同步的关键性：

当任务从RT切换到CFS时，必须正确处理vruntime，否则会导致严重的公平性问题：

// vruntime同步示例代码（概念性展示） static inline void sync_vruntime(struct sched_entity *se, struct cfs_rq *cfs_rq) { /* * 如果se->vruntime是相对值（存储时减去了原cfs_rq的min_vruntime）， * 则需要加上新cfs_rq的min_vruntime进行还原 */ if (se->sum_exec_runtime == 0) { // 新任务或首次进入CFS，放置在合适位置 se->vruntime = cfs_rq->min_vruntime + calc_delta_fair(sysctl_sched_latency, se); } }

操作步骤与验证：

# 步骤1：使用bpftrace跟踪switched_to_fair调用 cat > /tmp/trace_switched_to.bt << 'EOF' #!/usr/bin/env bpftrace kprobe:switched_to_fair { printf("switched_to_fair called for pid %d on CPU %d\n", ((struct task_struct *)arg1)->pid, cpu); } kprobe:attach_task_cfs_rq { printf("attach_task_cfs_rq called for pid %d\n", ((struct task_struct *)arg0)->pid); } kprobe:enqueue_entity { printf("enqueue_entity: se=%p, vruntime=%lu\n", arg1, ((struct sched_entity *)arg1)->vruntime); } EOF sudo bpftrace /tmp/trace_switched_to.bt & # 步骤2：运行测试程序观察切换过程 sudo chrt -f 50 /tmp/test_task # 步骤3：检查CFS运行队列状态 cat /sys/kernel/debug/sched/debug | grep -A 10 "cfs_rq"

5.3 案例三：CFS带宽控制在调度类切换中的应用

在容器化环境中，CFS Bandwidth Control用于限制cgroup的CPU使用量。当任务在不同cgroup或调度类之间迁移时，节流状态需要正确处理：

// 带宽控制相关的辅助函数（内核6.x版本） static inline bool task_needs_throttling(struct task_struct *p) { struct cfs_bandwidth *cfs_b = &task_group(p)->cfs_bandwidth; // 检查任务所属组的运行时是否已耗尽 if (cfs_b->quota == RUNTIME_INF) return false; return cfs_b->runtime <= 0; } static inline void task_throttle_setup(struct task_struct *p) { struct sched_entity *se = &p->se; // 设置节流标记 se->sched_delayed = 1; // 启动节流计时器 start_cfs_bandwidth_timer(); } static inline void task_throttle_cancel(struct task_struct *p) { struct sched_entity *se = &p->se; // 清除节流标记 se->sched_delayed = 0; // 如果任务因节流而延迟调度，立即触发调度 if (task_on_rq_queued(p) && p->state == TASK_RUNNING) { resched_curr(task_rq(p)); } }

配置CFS带宽控制并测试：

# 步骤1：创建带带宽限制的cgroup sudo mkdir -p /sys/fs/cgroup/cpu/test_cgroup echo 100000 | sudo tee /sys/fs/cgroup/cpu/test_cgroup/cpu.cfs_quota_us echo 1000000 | sudo tee /sys/fs/cgroup/cpu/test_cgroup/cpu.cfs_period_us # 步骤2：启动测试任务并加入cgroup sudo echo $$ | sudo tee /sys/fs/cgroup/cpu/test_cgroup/cgroup.procs # 步骤3：运行CPU密集型任务并观察节流情况 stress-ng --cpu 4 --timeout 60 & # 步骤4：监控节流统计 watch -n 1 'cat /sys/fs/cgroup/cpu/test_cgroup/cpu.stat' # 步骤5：在任务运行期间切换调度策略，观察switched_from_fair中的节流处理 sudo chrt -f 50 -p <pid_of_stress_ng_thread> sudo chrt -o -p 0 <pid_of_stress_ng_thread>

六、常见问题与解答

Q1：为什么任务从CFS切换到RT后，重新切回CFS时vruntime会异常？

A：这通常是由于min_vruntime基准不一致导致的。在switched_from_fair()中，任务被detach时会保存相对vruntime（减去min_vruntime），而在switched_to_fair()中需要正确还原。如果CPU在此期间发生了负载均衡，min_vruntime可能已变化，导致任务获得不公平的CPU份额。

排查方法：

# 启用调度器调试输出 echo 1 > /sys/kernel/debug/sched/verbose # 使用ftrace跟踪vruntime变化 trace-cmd record -e sched:sched_stat_runtime -e sched:sched_switch trace-cmd report | grep <pid>

Q2：调度类切换时出现死锁或长时间延迟，如何定位？

A：调度类切换涉及rq->lock和p->pi_lock的复杂锁交互。switched_from()回调可能会释放rq->lock，而switched_to()通常在持有锁的情况下执行。

排查方法：

# 启用lockdep检测锁问题 CONFIG_LOCKDEP=y CONFIG_LOCK_STAT=y # 查看锁争用统计 cat /proc/lock_stat | head -50 # 使用perf分析调度延迟 perf sched record -- sleep 10 perf sched latency

Q3：CFS带宽控制在调度类切换后未正确生效？

A：检查switched_from_fair()和switched_to_fair()中的cfs_bandwidth_used()判断。如果带宽控制未启用（CONFIG_CFS_BANDWIDTH未设置或运行时禁用），节流逻辑会被跳过。

验证方法：

# 检查内核配置 grep CONFIG_CFS_BANDWIDTH /boot/config-$(uname -r) # 检查运行时启用状态 cat /proc/sys/kernel/sched_cfs_bandwidth_slice_us # 查看任务是否被正确节流 cat /sys/fs/cgroup/cpu/<cgroup>/cpu.stat

Q4：多核系统中，任务在不同CPU之间迁移与调度类切换的交互问题？

A：migrate_task_rq_fair()处理CPU迁移，switched_from/to_fair()处理调度类切换。当两者同时发生时，需要确保detach_task_cfs_rq()和attach_task_cfs_rq()的正确调用顺序。

排查方法：

# 监控任务迁移事件 perf trace -e sched:sched_migrate_task -e sched:sched_setscheduler # 检查迁移后的运行队列状态 cat /sys/kernel/debug/sched/debug | grep -E "cpu#|cfs_rq|curr"

七、实践建议与最佳实践

7.1 调试技巧

1. 使用dynamic debug输出调度类切换详情

# 启用fair.c文件的动态调试 echo 'file kernel/sched/fair.c +p' > /sys/kernel/debug/dynamic_debug/control # 查看dmesg输出 dmesg -w | grep -E "switched_from|switched_to|attach|detach"

1. 通过/proc/sched_debug分析运行队列状态：

# 提取特定任务的调度信息 grep -A 20 "task <pid>" /proc/sched_debug

7.2 性能优化建议

1. 避免频繁的调度类切换：每次切换都涉及红黑树操作和锁竞争，高频切换会引入显著开销。

2. 合理设置CFS带宽控制参数：在容器环境中，确保cfs_quota_us和cfs_period_us的比值反映真实的CPU需求，避免因节流导致的频繁switched_from/to处理。

3. NUMA感知：在NUMA系统中，任务迁移时应考虑numa_node与cfs_rq的亲和性，减少跨节点内存访问开销。

7.3 常见错误规避

八、总结与应用场景

本文深入剖析了Linux CFS调度器中switched_from_fair()和switched_to_fair()的实现机制，这两个回调函数是调度类切换时的关键路径。通过detach_task_cfs_rq()和attach_task_cfs_rq()的配对操作，内核确保了任务在离开和进入CFS时，其调度实体状态、vruntime基准和负载统计的正确性。

在实时Linux系统（PREEMPT_RT）和云原生容器环境中，理解这一机制尤为重要：

• 实时系统：当RT任务临时降级为CFS任务时，需要保证平滑过渡，避免优先级反转

• 容器平台：Kubernetes等编排系统频繁调整任务的cgroup和调度策略，正确的状态迁移保证了资源隔离的可靠性

建议读者在实际项目中结合ftrace、bpftrace等工具，对调度类切换进行动态跟踪，深入理解内核调度器的运行时行为。同时，关注Linux内核邮件列表中关于调度子系统的最新补丁（如2024年提出的per-task throttling改进），持续跟踪这一领域的技术演进。