rCore：进程管理详解

pub struct TaskControlBlock {
    // Immutable
    /// Process identifier
    pub pid: PidHandle,

    /// Kernel stack corresponding to PID
    pub kernel_stack: KernelStack,

    /// Mutable
    inner: UPSafeCell<TaskControlBlockInner>,
}

pub struct TaskControlBlockInner {
    /// The physical page number of the frame where the trap context is placed
    pub trap_cx_ppn: PhysPageNum,

    /// Application data can only appear in areas
    /// where the application address space is lower than base_size
    pub base_size: usize,

    /// Save task context
    pub task_cx: TaskContext,

    /// Maintain the execution status of the current process
    pub task_status: TaskStatus,

    /// Application address space
    pub memory_set: MemorySet,

    /// Parent process of the current process.
    /// Weak will not affect the reference count of the parent
    pub parent: Option<Weak<TaskControlBlock>>,

    /// A vector containing TCBs of all child processes of the current process
    pub children: Vec<Arc<TaskControlBlock>>,

    /// It is set when active exit or execution error occurs
    pub exit_code: i32,

    /// Heap bottom
    pub heap_bottom: usize,

    /// Program break
    pub program_brk: usize,

    /// Current stride of this process, used by the stride scheduler.
    pub stride: usize,

    /// Scheduling pass: `BIG_STRIDE / priority`.
    pub pass: usize,

    /// Priority of this process, always `>= 2`.
    pub priority: isize,
}

pub enum TaskStatus {
    /// uninitialized
    UnInit,
    /// ready to run
    Ready,
    /// running
    Running,
    /// exited
    Zombie,
}

用户态 P 运行
  │ 时钟中断
  ▼
__alltraps（跳板页）: 存 TrapContext → satp 切内核 → sp 切 P 的内核栈
  ▼
trap_handler（内核页表，P 的栈）: suspend_current_and_run_next()
  ├─ take_current_task()       P 离开 PROCESSOR
  ├─ P.status = Ready
  ├─ add_task(P)               回就绪队列
  └─ schedule(&mut P.task_cx)
       └─ __switch(P.task_cx, idle_task_cx)   存 P 的内核现场
  ▼
run_tasks（boot stack）: fetch_task() 选 stride 最小的 Q，Q.status = Running
       └─ __switch(idle_task_cx, Q.task_cx)   存调度器现场，载入 Q
  ▼
Q 的内核栈: ra = trap_return（首次）或 schedule() 的返回点（恢复）
  ▼
trap_return → jr 跳板页 __restore → satp 切 Q 的页表 → 恢复 TrapContext → sret
  ▼
用户态 Q 运行

pub fn sys_fork() -> isize {
    let current_task = current_task().unwrap();
    let new_task = current_task.fork();
    let new_pid = new_task.pid.0;
    // modify trap context of new_task, because it returns immediately after switching
    let trap_cx = new_task.inner_exclusive_access().get_trap_cx();
    // we do not have to move to next instruction since we have done it before
    // for child process, fork returns 0
    trap_cx.x[10] = 0;
    // add new task to scheduler
    add_task(new_task);
    new_pid as isize

pub struct TaskManager {
    ready_queue: Vec<Arc<TaskControlBlock>>,
}

lazy_static! {
    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> =
        unsafe { UPSafeCell::new(TaskManager::new()) };
}

pub fn add(&mut self, task: Arc<TaskControlBlock>) {
    self.ready_queue.push(task);
}

pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
    let mut min_stride = usize::MAX;
    let mut min_idx = None;
    for (idx, task) in self.ready_queue.iter().enumerate() {
        let stride = task.inner_exclusive_access().stride;
        if stride < min_stride {
            min_stride = stride;
            min_idx = Some(idx);
        }
    }
    let idx = min_idx?;
    let task = self.ready_queue.remove(idx);
    {
        let mut inner = task.inner_exclusive_access();
        inner.stride += inner.pass;
    }
    Some(task)
}