深入理解操作系统中的进程管理：nuta/operating-system-in-1000-lines项目解析-CSDN博客

本文链接：https://blog.csdn.net/gitblog_00809/article/details/148862592

深入理解操作系统中的进程管理：nuta/operating-system-in-1000-lines项目解析

引言

在现代操作系统中，进程是最基本也是最重要的概念之一。本文将通过分析nuta/operating-system-in-1000-lines项目中的进程实现，深入探讨操作系统如何管理和调度进程。我们将从进程的基本概念开始，逐步深入到进程控制块、上下文切换和调度器等核心机制。

进程基础概念

进程可以理解为正在运行的程序的实例。每个进程都拥有独立的执行环境和资源，包括：

独立的虚拟地址空间
程序计数器（PC）
寄存器集合
调用栈
系统资源（如打开的文件）

在nuta/operating-system-in-1000-lines项目中，为了简化实现，每个进程只包含一个线程。在实际操作系统中，进程和线程通常是分开的概念，一个进程可以包含多个线程。

进程控制块（PCB）

操作系统通过进程控制块（Process Control Block，PCB）来管理进程。PCB是操作系统内核中的一种数据结构，包含了进程的所有关键信息。在项目中，PCB的定义如下：

#define PROCS_MAX 8       // 最大进程数量
#define PROC_UNUSED   0   // 未使用的进程控制结构
#define PROC_RUNNABLE 1   // 可运行的进程

struct process {
    int pid;             // 进程ID
    int state;           // 进程状态
    vaddr_t sp;          // 栈指针
    uint8_t stack[8192]; // 内核栈
};

这个结构体包含了几个关键字段：

pid：进程的唯一标识符
state：进程的当前状态（未使用或可运行）
sp：栈指针，指向进程的当前栈位置
stack：为进程分配的内核栈空间

每个进程都有自己独立的内核栈，用于保存CPU寄存器、返回地址和局部变量等上下文信息。这种设计使得通过保存和恢复CPU寄存器并切换栈指针来实现上下文切换成为可能。

上下文切换机制

上下文切换是操作系统中最核心的机制之一，它允许CPU在不同进程之间切换执行。在nuta/operating-system-in-1000-lines项目中，上下文切换的实现非常精妙：

__attribute__((naked)) void switch_context(uint32_t *prev_sp,
                                         uint32_t *next_sp) {
    __asm__ __volatile__(
        // 保存当前进程的上下文
        "addi sp, sp, -13 * 4\n"
        "sw ra,  0  * 4(sp)\n"
        "sw s0,  1  * 4(sp)\n"
        // ... 保存其他寄存器
        "sw s11, 12 * 4(sp)\n"

        // 切换栈指针
        "sw sp, (a0)\n"
        "lw sp, (a1)\n"

        // 恢复下一个进程的上下文
        "lw ra,  0  * 4(sp)\n"
        "lw s0,  1  * 4(sp)\n"
        // ... 恢复其他寄存器
        "lw s11, 12 * 4(sp)\n"
        "addi sp, sp, 13 * 4\n"
        "ret\n"
    );
}

这个函数主要完成三个关键操作：

保存当前进程的上下文（寄存器状态）到栈上
切换栈指针到目标进程的栈
从目标进程的栈中恢复其上下文

值得注意的是，这里只保存和恢复了被调用者保存的寄存器（s0-s11）。这是因为其他寄存器（如参数寄存器a0-a7）由调用者负责保存，这是RISC-V调用约定的一部分。

进程创建与初始化

创建新进程需要初始化PCB和进程的执行上下文。项目的create_process函数实现了这一功能：

struct process *create_process(uint32_t pc) {
    // 查找空闲的PCB
    struct process *proc = NULL;
    for (int i = 0; i < PROCS_MAX; i++) {
        if (procs[i].state == PROC_UNUSED) {
            proc = &procs[i];
            break;
        }
    }
    
    // 初始化栈和寄存器状态
    uint32_t *sp = (uint32_t *) &proc->stack[sizeof(proc->stack)];
    *--sp = 0;                      // s11
    *--sp = 0;                      // s10
    // ... 初始化其他寄存器
    *--sp = (uint32_t) pc;          // ra (返回地址)
    
    // 设置PCB字段
    proc->pid = i + 1;
    proc->state = PROC_RUNNABLE;
    proc->sp = (uint32_t) sp;
    return proc;
}

这个函数的主要工作包括：

在进程表中找到一个空闲的PCB
初始化进程的栈空间
设置进程的初始寄存器状态
设置进程ID和状态

特别值得注意的是返回地址(ra)被设置为进程的入口点(pc)，这样当进程第一次被调度时，就会从指定的入口开始执行。

进程调度器

随着进程数量的增加，直接指定下一个运行的进程会变得复杂。因此，项目实现了一个简单的调度器：

void yield(void) {
    // 寻找下一个可运行的进程
    struct process *next = idle_proc;
    for (int i = 0; i < PROCS_MAX; i++) {
        struct process *proc = &procs[(current_proc->pid + i) % PROCS_MAX];
        if (proc->state == PROC_RUNNABLE && proc->pid > 0) {
            next = proc;
            break;
        }
    }
    
    // 执行上下文切换
    struct process *prev = current_proc;
    current_proc = next;
    switch_context(&prev->sp, &next->sp);
}

这个调度器实现了简单的轮转调度算法，它会：

从当前进程开始，按顺序查找下一个可运行的进程
如果找到符合条件的进程，就切换到该进程
如果没有其他可运行进程，就切换到空闲进程

异常处理与内核栈安全

在多进程环境中，异常处理需要特别注意内核栈的安全性。项目通过sscratch寄存器来确保内核栈的安全：

void kernel_entry(void) {
    __asm__ __volatile__(
        // 从sscratch中获取运行进程的内核栈
        "csrrw sp, sscratch, sp\n"
        // ... 保存寄存器
        // 获取并保存异常发生时的sp
        "csrr a0, sscratch\n"
        "sw a0,  4 * 30(sp)\n"
        // 重置内核栈
        "addi a0, sp, 4 * 31\n"
        "csrw sscratch, a0\n"
    );
}

这种设计确保了：