操作系统回收进程详解（基于rCore源码）

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,

    /// System calls
    pub system_calls: [u32; MAX_SYSCALL_NUM],

    /// execution time
    pub time: usize,
}

pub task_cx: TaskContext,
pub task_status: TaskStatus,
pub trap_cx_ppn: PhysPageNum,
pub exit_code: i32,
pub system_calls: [u32; MAX_SYSCALL_NUM],
pub time: usize,

pub memory_set: MemorySet,

pub parent: Option<Weak<TaskControlBlock>>,

pub children: Vec<Arc<TaskControlBlock>>,

#[no_mangle]
#[link_section = ".text.entry"]
pub extern "C" fn _start(argc: usize, argv: usize) -> ! {
    clear_bss();
    unsafe {
        HEAP.lock()
            .init(HEAP_SPACE.as_ptr() as usize, USER_HEAP_SIZE);
    }
    let mut v: Vec<&'static str> = Vec::new();
    for i in 0..argc {
        let str_start =
            unsafe { ((argv + i * core::mem::size_of::<usize>()) as *const usize).read_volatile() };
        let len = (0usize..)
            .find(|i| unsafe { ((str_start + *i) as *const u8).read_volatile() == 0 })
            .unwrap();
        v.push(
            core::str::from_utf8(unsafe {
                core::slice::from_raw_parts(str_start as *const u8, len)
            })
            .unwrap(),
        );
    }
    exit(main(argc, v.as_slice()));
}

pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
    let task = current_task().unwrap();
    
    // 1. 检查是否有符合条件的子进程
    let mut inner = task.inner_exclusive_access();
    if !inner.children.iter()
        .any(|p| pid == -1 || pid as usize == p.getpid()) {
        return -1;  // 没有这样的子进程
    }
    
    // 2. 查找已经变成僵尸进程的子进程
    let pair = inner.children.iter().enumerate()
        .find(|(_, p)| {
            // 检查是否是僵尸进程且匹配 pid
            p.inner_exclusive_access().is_zombie() && 
            (pid == -1 || pid as usize == p.getpid())
        });
    
    if let Some((idx, _)) = pair {
        // 3. 找到僵尸子进程，开始回收
        let child = inner.children.remove(idx);
        // 确保这是最后一个引用
        assert_eq!(Arc::strong_count(&child), 1);
        
        // 4. 获取退出码
        let found_pid = child.getpid();
        let exit_code = child.inner_exclusive_access().exit_code;
        
        // 5. 将退出码写入用户空间
        *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code;
        
        found_pid as isize
    } else {
        -2  // 子进程还在运行
    }
}

进程A (正在退出)           进程P (A的父进程)          进程C (A的子进程)
----------------------     ----------------------     ----------------------
获取自己的锁 (A_lock)      正在执行 wait 
                          获取自己的锁 (P_lock)
试图获取父进程P的锁        试图获取子进程A的锁
(等待 P_lock)             (等待 A_lock)
...                       ...
死锁!                     死锁!

fn main() -> i32 {
    if fork() == 0 {
        // 子进程：执行 user_shell
        exec("user_shell");
    } else {
        // 父进程：循环等待回收子进程
        loop {
            let mut exit_code: i32 = 0;
            let pid = wait(&mut exit_code);
            if pid == -1 { // 没有子进程了
                // continue
            }
            println!("[initproc] Released a zombie process, pid={}, exit_code={}", pid, exit_code);
        }
    }
    0
}