优先级反转：RTOS 调度的隐形杀手

在抢占式 RTOS 中，任务按优先级调度，高优先级任务理应获得 CPU 控制权。然而，当多个任务共享互斥资源（如信号量、队列）时，可能出现一种反常现象：低优先级任务持有资源，而中优先级任务持续抢占 CPU，导致高优先级任务无法运行。这就是经典的优先级反转（Priority Inversion）。

反转的典型场景

任务 A（高优先级）等待信号量 S
任务 C（低优先级）持有 S，但被任务 B（中优先级）抢占
任务 B 运行，任务 A 和 C 都得不到 CPU，系统实时性崩溃

FreeRTOS 提供了优先级继承机制（Priority Inheritance），可缓解此问题，但并非万能。尤其在复杂系统中，反转可能由嵌套锁、中断延迟等引发，因此实时观测成为调试的关键手段。

观测方案：内核钩子 + 时间戳

FreeRTOS 允许用户注册多个钩子函数（Hook），其中 vApplicationTaskSwitchHook() 会在每次任务切换时被调用。结合一个高精度时间戳（如 DWT 或 SysTick），我们可以记录每次切换的：

时间点（tick 或 cycle）
离开任务句柄
进入任务句柄

将这些数据存入环形缓冲区，并通过 UART 或 RTT 导出，即可绘制任务切换时间线，直观识别反转窗口。

硬件与软件准备

硬件：STM32F407 开发板（或任意 Cortex-M4/M7）
软件：STM32CubeIDE + FreeRTOS（CMSIS-OS v2 或原生 API）
调试工具：SEGGER RTT（推荐）或串口

配置步骤

1. 启用内核钩子

在 FreeRTOSConfig.h 中设置：

#define configUSE_TRACE_FACILITY    1
#define configUSE_STATS_FORMATTING_FUNCTIONS 1
#define configUSE_IDLE_HOOK         0
#define configUSE_TICK_HOOK         0
#define configCHECK_FOR_STACK_OVERFLOW 2
#define configUSE_MUTEXES           1
#define configUSE_RECURSIVE_MUTEXES 1

关键：必须定义 configUSE_TRACE_FACILITY 为 1，否则任务句柄无法转换为名称。

2. 实现钩子函数

在 main.c 或单独模块中实现：

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"

#define TRACE_BUF_SIZE 256

typedef struct {
    uint32_t timestamp;
    TaskHandle_t from;
    TaskHandle_t to;
} SwitchEvent;

static SwitchEvent trace_buf[TRACE_BUF_SIZE];
static volatile uint32_t trace_idx = 0;

// 使用 DWT 周期计数器（Cortex-M 专用）
void DWT_Init(void) {
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT->CYCCNT = 0;
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}

void vApplicationTaskSwitchHook(void) {
    uint32_t idx = trace_idx;
    if (idx < TRACE_BUF_SIZE) {
        trace_buf[idx].timestamp = DWT->CYCCNT;
        trace_buf[idx].from = xTaskGetCurrentTaskHandle();
        trace_buf[idx].to = (TaskHandle_t)pxCurrentTCB; // 注意：此变量在钩子中可用
        trace_idx = idx + 1;
    }
}

注意：pxCurrentTCB 是 FreeRTOS 内部变量，在钩子中可直接访问（需包含 task.h）。但更安全的方式是使用 vTaskGetRunTimeStats()，不过钩子中无法调用。因此我们直接读取 TCB 指针。

3. 导出时间线数据

添加一个导出函数，通过 RTT 或串口发送：

void Trace_Print(void) {
    uint32_t count = trace_idx;
    for (uint32_t i = 0; i < count; i++) {
        char from_name[configMAX_TASK_NAME_LEN];
        char to_name[configMAX_TASK_NAME_LEN];
        vTaskGetTaskName(trace_buf[i].from, from_name);
        vTaskGetTaskName(trace_buf[i].to, to_name);
        printf("%u: %s -> %s\n", trace_buf[i].timestamp, from_name, to_name);
    }
}

若使用 RTT，可用 SEGGER_RTT_printf() 替代 printf。

4. 构造反转场景

创建三个任务：

SemaphoreHandle_t mutex;

void vHighTask(void *arg) {
    while (1) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        // 模拟高优先级处理
        vTaskDelay(10);
        xSemaphoreGive(mutex);
        vTaskDelay(1);
    }
}

void vMidTask(void *arg) {
    while (1) {
        // 中优先级任务持续运行
        vTaskDelay(2);
    }
}

void vLowTask(void *arg) {
    while (1) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        // 模拟低优先级长时间占用
        vTaskDelay(100);
        xSemaphoreGive(mutex);
        vTaskDelay(1);
    }
}

在 main 中创建任务并启动调度器。

完整代码示例

以下为整合后的核心代码（省略初始化部分）：

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "SEGGER_RTT.h"

#define TRACE_SIZE 512

typedef struct {
    uint32_t time;
    TaskHandle_t from;
    TaskHandle_t to;
} TraceEntry;

static TraceEntry trace[TRACE_SIZE];
static volatile uint32_t head = 0;

void vApplicationTaskSwitchHook(void) {
    uint32_t idx = head;
    if (idx < TRACE_SIZE) {
        trace[idx].time = DWT->CYCCNT;
        trace[idx].from = xTaskGetCurrentTaskHandle();
        trace[idx].to = (TaskHandle_t)pxCurrentTCB;
        head = idx + 1;
    }
}

void Trace_Init(void) {
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT->CYCCNT = 0;
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}

void Trace_Dump(void) {
    uint32_t n = head;
    for (uint32_t i = 0; i < n; i++) {
        char f[configMAX_TASK_NAME_LEN];
        char t[configMAX_TASK_NAME_LEN];
        vTaskGetTaskName(trace[i].from, f);
        vTaskGetTaskName(trace[i].to, t);
        SEGGER_RTT_printf(0, "%u: %s -> %s\n", trace[i].time, f, t);
    }
}

// 任务函数略...

结果分析与注意事项

观察结果

运行程序后，通过 RTT Viewer 导出数据，可看到类似输出：

1000: IDLE -> Low
1020: Low -> Mid
1050: Mid -> Low
...

当发生优先级反转时，时间线会显示：High 任务等待期间，Mid 任务频繁切换，而 Low 任务持有锁。通过时间戳间隔可计算阻塞时长。

注意事项

钩子函数执行时间：vApplicationTaskSwitchHook 在任务切换上下文执行，应保持极短，避免影响实时性。建议只记录数据，不进行打印。
缓冲区溢出：环形缓冲区需足够大，否则丢失早期事件。可设计为覆盖式或停止采集。
时间戳精度：DWT 计数器在调试模式下可能停止，需确保 DWT->CTRL 正确配置。也可使用 SysTick 或 TIM。
任务名称获取：vTaskGetTaskName 需要 configUSE_TRACE_FACILITY 为 1，且任务创建时需指定名称。
优先级继承：若使用互斥量（xSemaphoreCreateMutex），FreeRTOS 会自动启用优先级继承，反转现象可能被掩盖。若要复现原始反转，可使用二进制信号量（xSemaphoreCreateBinary）模拟。

扩展：自动化分析

可将导出的时间线数据导入 Python 脚本，绘制甘特图，自动标记反转窗口。例如，检测到高优先级任务等待时间超过阈值，即触发警告。这为持续集成测试提供了有力工具。

总结

通过 FreeRTOS 内核钩子与 DWT 时间戳，我们成功构建了任务切换时间线，能够实时观测优先级反转的发生过程。该方法不仅适用于调试，也可用于性能分析和调度验证。掌握这一技巧，能让嵌入式开发者更从容地应对复杂实时系统的挑战。

RTOS 优先级反转实时观测：FreeRTOS 内核钩子与任务切换时间线打印实战