4. 进程状态机：UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE 状态转换图

xv6 的进程管理核心是一个有限状态机。每个 struct proc 实例都维护一个 state 字段，该字段在以下六种状态之间转换：UNUSED、EMBRYO、SLEEPING、RUNNABLE、RUNNING、ZOMBIE。理解这个状态机是掌握 fork 与 exec 底层实现的前提。

4.1 六种状态定义与语义

4.2 状态转换图

下图展示了 xv6 进程完整的生命周期状态转换。箭头上的标签标注了触发转换的内核函数或系统调用。

4.3 关键转换路径详解

4.3.1 创建路径：UNUSED → EMBRYO → RUNNABLE

这是 fork() 系统调用的核心路径。在 sys_fork() 中调用 fork()，后者调用 allocproc()：

// kernel/proc.c
static struct proc*
allocproc(void)
{
  struct proc *p;

  for(p = proc; p < &proc[NPROC]; p++) {
    acquire(&p->lock);
    if(p->state == UNUSED) {
      p->state = EMBRYO;  // 第一步：标记为 EMBRYO
      release(&p->lock);
      // 分配内核栈、trapframe 等资源
      if((p->kstack = kalloc()) == 0){
        p->state = UNUSED;
        return 0;
      }
      // ...
      return p;
    } else {
      release(&p->lock);
    }
  }
  return 0;
}

随后 fork() 复制父进程的地址空间和上下文，最后将子进程状态设置为 RUNNABLE：

// kernel/proc.c
int
fork(void)
{
  // ...
  np = allocproc();  // 状态变为 EMBRYO
  // 复制父进程内存、文件描述符、上下文...
  // ...
  acquire(&np->lock);
  np->state = RUNNABLE;  // 第二步：变为 RUNNABLE
  release(&np->lock);
  return pid;
}

4.3.2 调度路径：RUNNABLE → RUNNING → RUNNABLE

调度器 scheduler() 在 main.c 启动后无限循环，扫描所有进程：

// kernel/proc.c
void
scheduler(void)
{
  struct proc *p;
  struct cpu *c = mycpu();

  for(;;){
    // 避免死锁
    intr_on();

    for(p = proc; p < &proc[NPROC]; p++) {
      acquire(&p->lock);
      if(p->state == RUNNABLE) {
        p->state = RUNNING;  // RUNNABLE → RUNNING
        c->proc = p;
        swtch(&c->context, &p->context);  // 上下文切换
        // 进程让出 CPU 后回到此处
        c->proc = 0;
      }
      release(&p->lock);
    }
  }
}

当进程主动调用 yield()（时钟中断触发）或 sleep() 时，会从 RUNNING 状态离开：

// kernel/proc.c
void
yield(void)
{
  struct proc *p = myproc();
  acquire(&p->lock);
  p->state = RUNNABLE;  // RUNNING → RUNNABLE
  sched();  // 调用 swtch 切换回调度器
  release(&p->lock);
}

4.3.3 退出路径：RUNNING → ZOMBIE → UNUSED

进程通过 exit() 系统调用终止自身：

// kernel/proc.c
void
exit(int status)
{
  struct proc *p = myproc();

  // 关闭所有打开的文件
  for(int fd = 0; fd < NOFILE; fd++){
    if(p->ofile[fd]){
      fileclose(p->ofile[fd]);
      p->ofile[fd] = 0;
    }
  }

  // 唤醒父进程（如果父进程在 wait 中休眠）
  wakeup(p->parent);

  // 将子进程托付给 init 进程
  reparent(p);

  // 标记为 ZOMBIE，释放 CPU
  acquire(&p->lock);
  p->state = ZOMBIE;  // RUNNING → ZOMBIE
  sched();
  // 不会返回
}

父进程调用 wait() 回收子进程：

// kernel/proc.c
int
wait(uint64 addr)
{
  struct proc *p = myproc();

  for(;;){
    // 查找 ZOMBIE 子进程
    for(np = proc; np < &proc[NPROC]; np++){
      if(np->parent == p && np->state == ZOMBIE){
        // 复制退出状态
        // 释放子进程内核栈、trapframe
        kfree((void*)np->kstack);
        np->kstack = 0;
        // 重置为 UNUSED
        acquire(&np->lock);
        np->state = UNUSED;  // ZOMBIE → UNUSED
        release(&np->lock);
        return pid;
      }
    }
    // 没有 ZOMBIE 子进程，休眠等待
    sleep(p, &p->lock);
  }
}

4.4 状态转换汇总表

4.5 状态机的不变量与安全约束

• 互斥性： 每个进程在同一时刻只能处于一种状态。状态转换必须持有 p->lock。
• 调度器独占 RUNNING： 每个 CPU 上最多只有一个进程处于 RUNNING 状态，由 c->proc 指针标识。
• ZOMBIE 不可调度： 调度器只扫描 RUNNABLE 状态的进程，ZOMBIE 进程永远不会被选中执行。
• EMBRYO 不可见： 调度器不会选中 EMBRYO 进程，因为其状态不是 RUNNABLE。
• 父进程必须回收： 如果父进程先于子进程退出，子进程通过 reparent() 托付给 init 进程（PID=1），由 init 负责 wait() 回收。

4.6 状态机与系统调用的对应关系

下表将 fork 和 exec 系统调用映射到状态转换路径上：