上下文简析

一、概念

嵌入式中的上下文：现场保存≠上下文全部

1. 任务/中断上下文（现场保存型，最典型） ：RTOS/裸机中，任务切换/中断嵌套时，必须保存CPU寄存器（PC、SP、通用寄存器等）和栈指针，这部分是执行上下文 （也叫硬件上下文）。
   • 例：裸机中断服务函数，入栈保存R0-R12、LR、PC，出栈恢复；RTOS任务栈中保存的任务现场。
   • 但GPIO/外设上下文（之前示例）是软件上下文，存储的是设备配置、状态、句柄，并非CPU现场。
2. 核心区分：硬件上下文（CPU现场） 是执行层面的上下文；软件上下文（设备/业务状态） 是逻辑层面的上下文，二者都属于上下文范畴。

Linux中的上下文（分层定义，场景明确）

Linux内核的上下文，本质是执行实体（进程/线程/中断）的运行环境，按场景分为以下几类，且严格区分上下文边界（比如中断上下文不能睡眠）。

1. 进程上下文（用户态+内核态）
   • 定义：进程执行时的完整环境，包含内存空间（mm_struct）、进程控制块（task_struct）、CPU寄存器（pt_regs）、栈（内核栈/用户栈）、文件描述符表、信号掩码等。
   • 触发：进程调度切换时，内核保存当前进程的硬件上下文（寄存器+栈）到task_struct，加载目标进程的上下文，实现无缝切换；系统调用时，从用户态上下文切换到内核态上下文。
2. 中断上下文（硬件中断/异常）
   • 定义：中断服务程序（ISR）执行时的环境，无进程地址空间（不关联task_struct），使用内核中断栈，只能访问内核全局数据/中断向量表。
   • 核心：中断发生时，内核保存当前进程的硬件上下文（到内核栈），进入中断上下文执行ISR；执行完毕后，恢复进程上下文，返回用户态/内核态。
   • 约束：不能睡眠（无调度）、不能调用阻塞函数、不能使用用户态内存。
3. 软中断/Tasklet上下文
   • 定义：内核中延迟处理中断任务的环境，属于中断上下文的延伸，运行在中断栈上，比硬中断优先级低，可被硬中断抢占。
   • 例：网络数据包的软中断处理、块设备的IO完成处理。
4. 内核线程上下文
   • 定义：内核线程（无用户态）的执行环境，属于进程上下文的特殊形式，有自己的task_struct、内核栈，可被调度，可睡眠。
   • 例：kworker、ksoftirqd。

关键区分与补充

上下文类型	核心载体	能否睡眠	典型场景
进程上下文	task_struct+用户/内核栈	能	系统调用、进程调度
中断上下文	中断栈+pt_regs	不能	硬件中断服务函数
软中断上下文	中断栈	不能	软中断处理函数
外设上下文（嵌入式）	结构体/类	-	GPIO、UART等驱动

二、进程上下文

Linux内核进程上下文切换代码示例**适配x86架构。

#include <cstdint>

// 模拟x86 CPU通用寄存器+控制寄存器结构（硬件上下文载体）
struct pt_regs {
    // 通用寄存器：中断/调度切换时必须保存的核心寄存器
    uint32_t eax;
    uint32_t ebx;
    uint32_t ecx;
    uint32_t edx;
    uint32_t esi;
    uint32_t edi;
    uint32_t ebp;
    // 栈指针与指令指针（核心，决定执行位置）
    uint32_t esp;
    uint32_t eip;
    // 段寄存器+标志寄存器（x86保护模式必需）
    uint32_t cs;
    uint32_t eflags;
};

// 模拟Linux进程控制块（task_struct）核心字段
struct task_struct {
    pt_regs regs;          // 进程的硬件上下文（保存寄存器现场）
    void* kernel_stack;    // 进程专属内核栈（内核态执行时使用）
    bool is_running;       // 进程运行状态
};

// 全局变量：模拟当前运行的进程
task_struct* current;

/**
 * @brief 保存当前进程的硬件上下文
 * 核心功能：将CPU寄存器的值写入当前进程的task_struct->regs中
 * 注：真实内核中这是汇编实现，这里用C++模拟逻辑
 */
void save_context() {
    // 模拟汇编指令：将寄存器值压入内核栈，再转存到regs结构
    // 这里直接用赋值模拟（实际是硬件级别的寄存器读写）
    current->regs.eax = __builtin_ia32_geteax();  // GCC内置函数获取eax
    current->regs.ebx = __builtin_ia32_getebx();
    current->regs.ecx = __builtin_ia32_getecx();
    current->regs.edx = __builtin_ia32_getedx();
    current->regs.esi = __builtin_ia32_getesi();
    current->regs.edi = __builtin_ia32_getedi();
    current->regs.ebp = __builtin_ia32_getebp();
    current->regs.esp = __builtin_ia32_getesp();
    current->regs.eip = __builtin_ia32_geteip();  // 获取当前指令指针
    current->regs.eflags = __builtin_ia32_readeflags_u32();  // 获取标志寄存器
}

/**
 * @brief 恢复目标进程的硬件上下文
 * 核心功能：将目标进程的task_struct->regs值写入CPU寄存器，完成现场还原
 * @param next 目标进程的task_struct指针
 */
void restore_context(task_struct* next) {
    // 1. 切换内核栈（x86内核态必须使用进程专属内核栈）
    __asm__ volatile("mov %0, %%esp" : : "r"(next->kernel_stack));

    // 2. 恢复寄存器现场（模拟汇编指令，将regs的值写入CPU寄存器）
    __builtin_ia32_seteax(next->regs.eax);
    __builtin_ia32_setebx(next->regs.ebx);
    __builtin_ia32_setecx(next->regs.ecx);
    __builtin_ia32_setedx(next->regs.edx);
    __builtin_ia32_setsi(next->regs.esi);
    __builtin_ia32_setdi(next->regs.edi);
    __builtin_ia32_setbp(next->regs.ebp);
    __builtin_ia32_writeeflags_u32(next->regs.eflags);

    // 3. 跳转至目标进程的eip（指令指针），恢复执行
    __asm__ volatile("jmp *%0" : : "r"(next->regs.eip));
}

/**
 * @brief 模拟进程调度器的上下文切换入口
 * @param next 待切换的目标进程
 */
void context_switch(task_struct* next) {
    if (current == next) {
        return; // 避免切换到自身
    }

    // 步骤1：保存当前进程的硬件上下文
    save_context();
    current->is_running=false;

    // 步骤2：更新current指针，指向目标进程
    task_struct* prev=current;
    current=next;
    current->is_running=true;

    // 步骤3：恢复目标进程的硬件上下文，完成切换
    restore_context(next);
}

// 测试代码（模拟两个进程的上下文切换）
int main() {
    // 初始化两个进程的内核栈和上下文
    task_struct task1, task2;
    task1.kernel_stack=malloc(8192);  // 内核栈默认8KB
    task2.kernel_stack=malloc(8192);

    // 初始化进程1的上下文（模拟初始执行状态）
    task1.regs.eip=(uint32_t)[]() {
        printf("Task1 is running\n");
        return 0;
    };
    task1.is_running=true;

    // 初始化进程2的上下文
    task2.regs.eip=(uint32_t)[]() {
        printf("Task2 is running\n");
        return 0;
    };
    task2.is_running=false;

    // 启动进程1
    current = &task1;
    printf("Initial current task: Task1\n");

    // 模拟调度：切换到进程2
    context_switch(&task2);

    // 释放资源
    free(task1.kernel_stack);
    free(task2.kernel_stack);
    return 0;
}

---

核心原理说明

1. 硬件上下文的核心 ：pt_regs 结构体是上下文的载体，保存了CPU执行必需的寄存器集合；save_context 负责"存现场"，restore_context 负责"还原现场"。
2. 内核栈的作用 ：x86架构下，内核态必须使用进程专属的内核栈，避免栈数据冲突；restore_context 中首先切换内核栈，再恢复寄存器。
3. 上下文切换的触发 ：Linux中，时钟中断、系统调用、进程阻塞等场景会触发调度器，调用 context_switch 完成上下文切换。
4. 真实内核差异 ：
   • 实际 save_context 和 restore_context 是用汇编实现的（效率要求），C++只能模拟逻辑。
   • 完整的 task_struct 包含大量字段（内存管理、文件系统、信号等），这里只保留了上下文相关的核心字段。
   • 切换时还需要处理页表切换（CR3寄存器）、TLB刷新等内存相关操作。

---

编译说明

• 编译器：GCC（支持x86内置函数）
• 编译命令：g++ -m32 -o context_switch context_switch.cpp（-m32 生成32位x86代码）
• 运行环境：32位Linux系统或支持32位兼容模式的64位系统

三、外设上下文

GPIO外设操作上下文

以下示例模拟嵌入式开发中 GPIO设备的上下文管理，通过封装上下文类，集中存储GPIO的配置信息和操作状态，实现对GPIO引脚的统一管理。

#include <iostream>
#include <cstdint>
#include <functional>

// GPIO方向枚举
enum class GpioDirection {
    INPUT,
    OUTPUT
};

// GPIO电平枚举
enum class GpioLevel {
    LOW = 0,
    HIGH = 1
};

/**
 * @brief GPIO操作上下文类
 * 封装GPIO的硬件信息、配置状态和操作函数，作为GPIO操作的环境载体
 */
class GpioContext {
public:
    // 回调函数类型：用于GPIO输入中断触发时的处理
    using InterruptCallback = std::function<void(GpioLevel)>;

    /**
     * @brief 构造函数：初始化GPIO上下文
     * @param port GPIO端口号（如嵌入式中的GPIOA/GPIOB）
     * @param pin GPIO引脚号（如0-15）
     * @param dir GPIO方向（输入/输出）
     */
    GpioContext(uint8_t port, uint8_t pin, GpioDirection dir)
        : port_(port), pin_(pin), dir_(dir), level_(GpioLevel::LOW), callback_(nullptr) {
        // 模拟硬件初始化：配置GPIO方向
        configGpioDirection();
    }

    // 禁止拷贝：上下文是设备的唯一环境描述，避免重复操作硬件
    GpioContext(const GpioContext&) = delete;
    GpioContext& operator=(const GpioContext&) = delete;

    // 允许移动：支持上下文的转移（如任务间传递）
    GpioContext(GpioContext&&) = default;
    GpioContext& operator=(GpioContext&&) = default;

    /**
     * @brief 设置GPIO输出电平
     * @param level 目标电平（高低）
     */
    void setOutputLevel(GpioLevel level) {
        if (dir_ != GpioDirection::OUTPUT) {
            std::cerr << "Error: GPIO" << (int)port_ << "_" << (int)pin_ << " is not output mode!" << std::endl;
            return;
        }
        // 模拟硬件寄存器写操作：更新电平状态
        level_ = level;
        std::cout << "Set GPIO" << (int)port_ << "_" << (int)pin_ << " to " << (int)level_ << std::endl;
    }

    /**
     * @brief 获取GPIO输入电平
     * @return 当前输入电平
     */
    GpioLevel getInputLevel() const {
        if (dir_ != GpioDirection::INPUT) {
            std::cerr << "Error: GPIO" << (int)port_ << "_" << (int)pin_ << " is not input mode!" << std::endl;
            return GpioLevel::LOW;
        }
        // 模拟硬件寄存器读操作：返回当前电平
        return level_;
    }

    /**
     * @brief 注册输入中断回调函数
     * @param cb 回调函数
     */
    void registerInterruptCallback(InterruptCallback cb) {
        if (dir_ != GpioDirection::INPUT) {
            std::cerr << "Error: Only input GPIO can register interrupt!" << std::endl;
            return;
        }
        callback_ = std::move(cb);
    }

    /**
     * @brief 模拟中断触发（硬件层调用）
     */
    void triggerInterrupt() {
        if (callback_ && dir_ == GpioDirection::INPUT) {
            // 模拟电平变化
            level_ = (level_ == GpioLevel::LOW) ? GpioLevel::HIGH : GpioLevel::LOW;
            callback_(level_);
        }
    }

private:
    // 硬件相关参数
    uint8_t port_;                 // GPIO端口号
    uint8_t pin_;                  // GPIO引脚号
    GpioDirection dir_;            // GPIO方向
    GpioLevel level_;              // 当前电平状态
    InterruptCallback callback_;   // 中断回调函数

    /**
     * @brief 模拟硬件配置：设置GPIO方向
     */
    void configGpioDirection() {
        std::cout << "Config GPIO" << (int)port_ << "_" << (int)pin_ 
                  << " as " << (dir_ == GpioDirection::INPUT ? "INPUT" : "OUTPUT") << std::endl;
    }
};

// 测试函数
int main() {
    // 1. 创建输出GPIO上下文：端口0，引脚1，输出模式
    GpioContext ledCtx(0, 1, GpioDirection::OUTPUT);
    ledCtx.setOutputLevel(GpioLevel::HIGH);
    ledCtx.setOutputLevel(GpioLevel::LOW);

    std::cout << "-------------------------" << std::endl;

    // 2. 创建输入GPIO上下文：端口0，引脚2，输入模式
    GpioContext keyCtx(0, 2, GpioDirection::INPUT);
    // 注册中断回调：电平变化时打印信息
    keyCtx.registerInterruptCallback([](GpioLevel level) {
        std::cout << "Interrupt triggered! Current level: " << (int)level << std::endl;
    });

    // 模拟中断触发2次
    keyCtx.triggerInterrupt();
    keyCtx.triggerInterrupt();

    return 0;
}

示例解析

1. 上下文的核心作用

   • GpioContext 类封装了GPIO的硬件参数 （端口、引脚）、配置状态 （方向）、运行状态 （当前电平）和回调资源（中断函数），这些信息共同构成了GPIO操作的完整环境。
   • 外部代码无需关心硬件底层细节，只需通过上下文对象提供的接口操作GPIO，实现了硬件解耦。

2. 嵌入式开发中的典型应用

   • 驱动层：每个外设（UART、SPI、I2C）对应一个上下文结构体/类，存储寄存器基地址、波特率/时钟频率等配置参数。
   • 中断处理：中断服务函数（ISR）通过上下文获取设备状态，避免使用全局变量，提升代码的可重入性。
   • 任务调度：RTOS中任务切换时，会保存当前任务的上下文（寄存器值、堆栈指针），恢复时加载上下文即可继续执行。

编译运行结果

Config GPIO0_1 as OUTPUT
Set GPIO0_1 to 1
Set GPIO0_1 to 0
-------------------------
Config GPIO0_2 as INPUT
Interrupt triggered! Current level: 1
Interrupt triggered! Current level: 0

---