简介

在工业控制、航空航天、车载自动驾驶等硬实时场景中，Linux RT 调度器（SCHED_FIFO/SCHED_RR）承担着保障关键任务确定性调度与低延迟响应的核心职责。任务优先级作为 RT 调度的核心驱动因子，其动态调整的处理逻辑直接决定调度的实时性、正确性与高效性。

prio_changed_rt作为 RT 调度类的核心回调函数，是任务优先级变更后的核心处理入口，负责完成旧优先级队列出队、新优先级队列入队、优先级位图更新、最高优先级刷新及调度抢占触发等全链路操作，确保优先级变更即时生效、调度无错乱、数据结构一致性。

掌握prio_changed_rt的底层逻辑，是理解 Linux RT 调度器动态优先级管理、解决实时系统调度抖动、优化硬实时任务响应延迟的关键。本文基于 Linux 5.4/6.2 内核源码，从核心概念、环境搭建、源码解析、实战案例、问题排查到最佳实践，全链路拆解prio_changed_rt的实现机制，为嵌入式实时开发、内核调试、学术研究提供实战参考。

一、核心概念解析

1.1 RT 调度器基础

Linux RT 调度器针对硬实时任务设计，支持两种调度策略：

• SCHED_FIFO：静态优先级 FIFO 调度，同优先级任务按入队顺序执行，高优先级任务可抢占低优先级任务，无时间片轮转。
• SCHED_RR：带时间片的 FIFO 调度，同优先级任务按时间片轮转，时间片耗尽后移至同优先级队列尾部。

RT 任务优先级范围为0-99（数值越小，优先级越高），普通 CFS 任务优先级为 100-139，RT 任务天然抢占 CFS 任务。优先级转换公式：prio = 100 - 1 - rt_priority，如rt_priority=20时，prio=79。

1.2 核心数据结构

1.2.1 struct rt_rq（CPU 实时运行队列）

每个 CPU 的struct rq中内嵌rt_rq，管理该 CPU 的所有 RT 就绪任务：

// kernel/sched/rt.h
struct rt_rq {
    struct rt_prio_array active;  // 就绪任务优先级队列（核心）
    unsigned int rt_nr_running;  // 就绪RT任务总数
    int highest_prio;             // 当前CPU最高RT优先级
    // ... 负载均衡、迁移相关字段
};

1.2.2 struct rt_prio_array（优先级数组）

RT 调度 O (1) 调度的核心，绑定active就绪队列：

// kernel/sched/rt.h
#define MAX_RT_PRIO 100  // RT优先级0-99
struct rt_prio_array {
    DECLARE_BITMAP(bitmap, MAX_RT_PRIO);  // 优先级位图（O(1)查找）
    struct list_head queue[MAX_RT_PRIO];  // 100个优先级链表
};

• bitmap：每 1 位对应 1 个优先级，位为 1 表示该优先级队列非空，通过find_first_bit快速定位最高优先级。
• queue：数组元素为链表头，同优先级 RT 任务通过run_list挂载至对应链表。

1.3 prio_changed_rt 核心作用

prio_changed_rt是struct sched_class的回调函数，原型如下：

// kernel/sched/rt.c
static void prio_changed_rt(struct rq *rq, struct task_struct *p, int oldprio);

触发场景：

• 通过sched_setscheduler()/nice()修改 RT 任务优先级；
• 任务调度策略在 SCHED_FIFO/SCHED_RR 间切换；
• 内核内部调整实时任务优先级（如优先级继承）。

核心职责：优先级变更后，更新运行队列与位图，触发抢占，确保新优先级立即生效。

二、环境准备

2.1 软硬件环境

• 硬件：x86_64 开发机（4 核 CPU+8G 内存），支持内核调试（Kdump/GDB）；
• 内核版本：Linux 5.4.0-rt64 / 6.2.0-rt10（带 PREEMPT-RT 补丁，硬实时支持）；
• 编译工具：gcc-9.4、make-4.2、bison/flex、libncurses-dev；
• 调试工具：gdb-10.2、crash-7.3、trace-cmd、perf、ftrace；
• 系统环境：Ubuntu 20.04 LTS（安装 rt 补丁内核）。

2.2 内核源码获取与编译

2.2.1 源码下载

# 下载5.4内核源码
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.4.150.tar.xz
# 下载对应PREEMPT-RT补丁
wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/5.4/older/patch-5.4.150-rt64.patch.xz
# 解压并打补丁
tar -xf linux-5.4.150.tar.xz
cd linux-5.4.150
xzcat ../patch-5.4.150-rt64.patch.xz | patch -p1

2.2.2 内核配置（开启 RT 调试）

# 复制当前系统配置
cp /boot/config-$(uname -r) .config
# 开启关键配置（make menuconfig）
# 1. General setup -> Preemption Model -> Fully Preemptible Kernel (RT)
# 2. Kernel hacking -> Compile-time checks and compiler options -> Compile the kernel with debug info
# 3. Kernel hacking -> Tracers -> Enable ftrace (开启sched调度跟踪)
# 4. Processor type and features -> Symmetric multi-processing support (SMP支持)
make menuconfig

2.2.3 编译与安装

# 编译（4核加速）
make -j4
# 安装模块与内核
sudo make modules_install
sudo make install
# 更新grub，重启选择rt内核
sudo update-grub
sudo reboot
# 验证rt内核
uname -r  # 输出5.4.150-rt64

2.3 调试环境配置

2.3.1 开启 ftrace 调度跟踪

# 挂载debugfs
sudo mount -t debugfs none /sys/kernel/debug
# 开启sched事件跟踪
echo 1 > /sys/kernel/debug/tracing/events/sched/enable
echo 1 > /sys/kernel/debug/tracing/tracing_on

2.3.2 GDB 调试内核准备

# 安装crash工具
sudo apt install crash
# 生成内核vmlinux（带调试信息）
cp /usr/lib/debug/boot/vmlinux-5.4.150-rt64 .

三、应用场景（300 字）

在工业机器人运动控制场景中，伺服电机控制任务（SCHED_FIFO，prio=10）、传感器数据采集任务（SCHED_FIFO，prio=20）、人机交互任务（SCHED_RR，prio=50）需协同运行。当机器人切换至高速运动模式时，需动态提升伺服控制任务优先级至 prio=5，降低传感器采集任务优先级至 prio=30。此时prio_changed_rt触发，将伺服任务从旧优先级队列移除、更新位图、加入新优先级队列，标记最高优先级并触发抢占，确保伺服任务立即抢占 CPU，运动控制无抖动；传感器任务同步完成队列迁移，避免调度错乱。该逻辑保障动态优先级调整场景下硬实时任务的确定性调度，是工业实时系统动态优先级管理的核心支撑。

四、实际案例与源码步骤解析

4.1 案例：RT 任务优先级动态调整

4.1.1 测试代码（用户态）

编写rt_prio_test.c，创建 SCHED_FIFO 任务并动态修改优先级：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sched.h>
#include <unistd.h>

// 线程函数：RT任务循环
void *rt_task(void *arg) {
    struct sched_param param;
    int policy = SCHED_FIFO;
    // 设置初始优先级：rt_priority=20 → prio=79
    param.sched_priority = 20;
    if (sched_setscheduler(0, policy, &param) == -1) {
        perror("sched_setscheduler failed");
        exit(1);
    }
    printf("RT任务启动，初始rt_priority=20 (prio=79)\n");

    // 循环5秒后修改优先级为rt_priority=10 → prio=89
    sleep(5);
    param.sched_priority = 10;
    if (sched_setscheduler(0, policy, &param) == -1) {
        perror("sched_setscheduler failed");
        exit(1);
    }
    printf("RT任务优先级修改为rt_priority=10 (prio=89)\n");

    while(1) { sleep(1); }
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, rt_task, NULL);
    pthread_join(tid, NULL);
    return 0;
}

编译运行：

gcc rt_prio_test.c -o rt_prio_test -pthread
sudo ./rt_prio_test  # 必须root权限

4.1.2 触发 prio_changed_rt

用户态调用sched_setscheduler()时，内核最终调用prio_changed_rt，核心流程：参数校验→旧优先级出队→新优先级入队→位图更新→最高优先级刷新→抢占判断。

4.2 源码步骤解析（prio_changed_rt）

4.2.1 函数入口与参数校验

// kernel/sched/rt.c
static void prio_changed_rt(struct rq *rq, struct task_struct *p, int oldprio)
{
    struct rt_rq *rt_rq = &rq->rt;
    int newprio = p->prio;

    // 步骤1：任务不在运行队列，直接返回
    if (!task_on_rq_queued(p))
        return;

    // 步骤2：优先级未变化，直接返回
    if (oldprio == newprio)
        return;

• task_on_rq_queued(p)：判断任务是否在就绪队列，未入队无需处理。

4.2.2 旧优先级队列出队（关键）

    // 步骤3：从旧优先级队列移除任务
    rt_dequeue_task(rq, p);

    // 步骤4：更新旧优先级位图与最高优先级
    if (list_empty(&rt_rq->active.queue[oldprio])) {
        // 旧优先级队列为空，清除位图对应位
        __clear_bit(oldprio, rt_rq->active.bitmap);
        // 若旧优先级是最高优先级，重新查找
        if (oldprio == rt_rq->highest_prio)
            rt_rq->highest_prio = find_first_bit(rt_rq->active.bitmap, MAX_RT_PRIO);
    }

• rt_dequeue_task：将任务从oldprio对应的链表移除；
• __clear_bit：原子操作清除位图位，标记旧优先级队列空；
• find_first_bit：O (1) 查找新的最高优先级。

4.2.3 新优先级队列入队

    // 步骤5：加入新优先级队列
    rt_enqueue_task(rq, p);

    // 步骤6：更新新优先级位图与最高优先级
    if (!test_bit(newprio, rt_rq->active.bitmap)) {
        // 新优先级队列首次加入任务，置位位图
        __set_bit(newprio, rt_rq->active.bitmap);
        // 更新最高优先级
        if (newprio < rt_rq->highest_prio)
            rt_rq->highest_prio = newprio;
    }

• rt_enqueue_task：将任务挂载至newprio对应的链表尾部；
• __set_bit：原子操作置位位图位，标记新优先级队列非空；
• 新优先级更高（数值更小）时，直接更新highest_prio，避免重复查找。

4.2.4 抢占触发（核心实时性保障）

    // 步骤7：判断是否需要抢占
    if (rq->curr == p) {
        // 场景1：任务当前正在运行
        if (oldprio < newprio) {
            // 优先级降低：触发重新调度，允许高优先级任务抢占
            resched_curr(rq);
#ifdef CONFIG_SMP
            // SMP环境：可能需要pull其他CPU高优先级任务
            pull_rt_task(rq);
#endif
        }
    } else {
        // 场景2：任务未运行，但新优先级高于当前运行任务
        if (newprio < rq->curr->prio) {
            // 触发抢占，立即调度高优先级任务
            resched_curr(rq);
        }
    }
}

• 运行任务优先级降低：调用resched_curr设置TIF_NEED_RESCHED标志，触发调度，允许其他高优先级 RT 任务抢占；
• 非运行任务优先级升高：若新优先级高于当前 CPU 运行任务，立即触发抢占，保障高优先级任务即时调度；
• SMP 环境：优先级降低时调用pull_rt_task，从其他 CPU 拉取高优先级 RT 任务，平衡负载。

4.3 关键辅助函数解析

4.3.1 rt_dequeue_task（出队）

// kernel/sched/rt.c
static void rt_dequeue_task(struct rq *rq, struct task_struct *p)
{
    struct rt_rq *rt_rq = &rq->rt;
    struct sched_rt_entity *rt_se = &p->rt;

    // 从旧优先级链表移除
    list_del(&rt_se->run_list);
    // RT任务计数减1
    rt_rq->rt_nr_running--;
}

4.3.2 rt_enqueue_task（入队）

// kernel/sched/rt.c
static void rt_enqueue_task(struct rq *rq, struct task_struct *p)
{
    struct rt_rq *rt_rq = &rq->rt;
    struct sched_rt_entity *rt_se = &p->rt;
    int prio = p->prio;

    // 加入新优先级链表尾部
    list_add_tail(&rt_se->run_list, &rt_rq->active.queue[prio]);
    // RT任务计数加1
    rt_rq->rt_nr_running++;
}

五、常见问题与解答

5.1 问题 1：RT 任务优先级修改后未生效，无抢占

现象：高优先级 RT 任务设置后，仍被低优先级任务抢占，调度无变化。原因：

1. 未开启PREEMPT-RT补丁，内核非完全抢占模式；
2. prio_changed_rt中抢占判断逻辑未触发（如新优先级不高于当前任务）；
3. 位图更新失败，最高优先级未刷新。排查与解决：

# 1. 验证内核rt补丁
uname -r | grep rt  # 输出带rt后缀，如5.4.150-rt64
# 2. 查看ftrace跟踪prio_changed_rt
cat /sys/kernel/debug/tracing/trace | grep prio_changed_rt
# 3. 检查位图与最高优先级（crash工具）
crash> vmlinux /proc/kcore
crash> struct rt_rq rq.rt  # 查看active.bitmap与highest_prio

解决：开启完全抢占模式、确保新优先级数值更小、修复位图原子操作异常。

5.2 问题 2：SMP 环境下，CPU 间 RT 任务负载不均衡

现象：某 CPU 运行低优先级任务，其他 CPU 有高优先级 RT 任务就绪，但未迁移。原因：prio_changed_rt中pull_rt_task未生效，SMP 负载均衡逻辑异常。排查与解决：

// 检查pull_rt_task调用逻辑（kernel/sched/rt.c）
if (oldprio < newprio && rq->curr == p)
    pull_rt_task(rq);

解决：开启CONFIG_SMP配置、检查rt_queue_pull_task回调注册、验证 CPU 间中断亲和性。

5.3 问题 3：优先级频繁修改导致内核崩溃（Oops）

现象：高频调用sched_setscheduler()修改 RT 任务优先级，触发内核空指针异常。原因：

1. 未加锁保护，prio_changed_rt并发访问rt_rq数据结构；
2. 任务已出队，再次调用rt_dequeue_task导致链表空指针。解决：

• 内核中prio_changed_rt由rq->lock自旋锁保护，确保串行执行；
• 用户态避免高频（>1ms / 次）修改同一任务优先级，增加间隔。

六、实践建议与最佳实践

6.1 优先级设计最佳实践

1. 优先级分层：关键硬实时任务（伺服控制、中断处理）设 0-30，次关键任务（数据采集）设 31-60，非关键任务（日志、交互）设 61-99，避免优先级反转；
2. 避免频繁变更：RT 任务优先级变更间隔≥10ms，减少prio_changed_rt调用次数，降低调度抖动；
3. 优先级继承：使用rt_mutex替代普通mutex，避免高优先级任务因等待低优先级任务锁而阻塞。

6.2 调试与性能优化技巧

6.2.1 ftrace 跟踪优先级变更

# 跟踪prio_changed_rt函数调用
echo 'prio_changed_rt' > /sys/kernel/debug/tracing/set_ftrace_filter
# 查看跟踪日志
cat /sys/kernel/debug/tracing/trace

6.2.2 perf 分析调度延迟

# 采样调度事件，统计RT任务抢占延迟
perf record -e sched:sched_switch -g ./rt_prio_test
perf report  # 查看prio_changed_rt耗时与抢占延迟

6.2.3 内核参数优化

# 提高RT任务调度频率
echo 1000000 > /proc/sys/kernel/sched_rt_period_us
echo 950000 > /proc/sys/kernel/sched_rt_runtime_us  # RT任务占比95%
# 关闭CFS任务抢占RT任务
echo 0 > /proc/sys/kernel/sched_compat_yield

6.3 内核代码修改规范

1. 锁保护：修改rt_rq/rt_prio_array数据结构时，必须持有rq->lock自旋锁，避免并发异常；
2. 原子操作：位图更新必须使用__set_bit/__clear_bit原子函数，防止位操作撕裂；
3. 抢占安全：prio_changed_rt中调用resched_curr前，确保 CPU 处于可抢占状态，避免死锁。

七、总结与应用场景

7.1 核心要点回顾

本文基于 Linux 5.4-rt 内核，深度拆解了 RT 调度器prio_changed_rt的底层逻辑，核心要点：

1. 核心作用：优先级变更的核心回调，完成出队→位图更新→入队→抢占触发全链路处理；
2. 数据结构：rt_prio_array的位图 + 链表设计，实现 O (1) 最高优先级查找与任务调度；
3. 实时性保障：优先级升高触发抢占、优先级降低允许抢占、SMP 环境负载拉取，确保调度确定性；
4. 关键细节：位图原子操作、最高优先级动态刷新、并发锁保护，保障数据一致性。

7.2 实时 Linux 应用场景

prio_changed_rt作为 RT 调度动态优先级管理的核心，广泛应用于：

• 工业控制：PLC、运动控制器，动态调整伺服 / IO 任务优先级，保障运动精度；
• 车载自动驾驶：感知、决策、执行任务优先级动态切换，满足功能安全要求；
• 航空航天：飞控、导航、遥测任务，高优先级任务即时调度，保障飞行稳定；
• 医疗设备：手术机器人、呼吸机，实时响应控制指令，保障设备安全运行。

7.3 实践价值与展望

掌握prio_changed_rt的底层逻辑，是解决实时 Linux 调度抖动、优化硬实时响应延迟、设计高可靠实时系统的关键。建议读者结合内核源码，通过修改测试代码、添加内核打印、跟踪调度事件等方式，深入理解优先级变更的全链路逻辑，并应用于实际项目中。

未来，随着 Linux 实时化技术的演进，prio_changed_rt将进一步优化 SMP 负载均衡、降低调度延迟、增强优先级管理灵活性，为硬实时场景提供更强大的调度支撑。