fork/execve系统调用与写时复制COW

可视化演示

系统调用入口：递交入职申请

新员工入职的第一步，是走到人事窗口（系统调用接口）递上一张“入职申请”。这张申请就是 fork()。员工在工位上（用户态）不能直接闯进档案室（内核态）拿东西，必须通过这扇专门的窗口，把申请递进去，再由人事专员转交给后台处理。这扇窗口在 CPU 上对应一条 syscall 指令：它会触发一次“陷入（trap）”，把 CPU 从用户态切换到内核态，并在系统调用表中查找对应的处理函数。

人事窗口后台的专员叫 do_fork。它先核对申请单上要复制哪些资源（内存、文件表、信号等），再向下转交。而这张申请单有一个有趣的“双重回执”规则：它返回给父进程一个“新员工工号”（子进程 PID），返回给子进程一个“0 表示我是新来的”，如果申请失败则返回负数错误码。同一个函数，在两个进程里拿到不同的返回值，这就是 fork 最著名的“一次调用、两次返回”。

人事窗口受理后，在登记簿上记下新员工的工号（PID），申请单被转交到档案室。新员工现在正式进入了“待建档”状态——接下来就看档案室如何复印他的手册了。

描述符复制：逐项复印员工档案

档案室收到申请后，要为新员工复制一整套“档案”。这套档案的封面（task_struct 进程描述符）记录了姓名、状态、优先级等基本信息；内页则登记了员工能访问的各种资源：内存手册（mm_struct）、打开的文件（files_struct）、当前目录（fs_struct）、信号处理方式（sighand_struct）等。复制整个档案的总工作量，就是逐项复印这些部分所需时间之和。

内核中负责这项工作的主管理员叫 copy_process。它就像一个流水线班长，依次调用 copy_task（复印封面）、copy_mm（复印内存档案）、copy_files（复印文件表）、copy_fs、copy_sighand……不过流水线有个聪明的策略：并非每样东西都硬复印。文件表、信号处理这些“公共文档”常常采用共享引用计数的方式——大家一起看同一份文件，只在需要修改时才真正拆分。

档案室把封面和目录复制完毕后，突然意识到一个关键问题：整本手册的正文纸张（物理内存页）如果也全部复印，成本太高！于是管理层拍板：正文纸张先不印，父子员工共用原件。这个“共用手册”的规则，正是下一节的主角——写时复制。

写时复制：共享手册的智慧

公司新规生效了：新员工入职时，不再整本复印手册，而是由档案室发一张“共用手册凭证”。父子两人共享同一叠正文纸张，但有一个铁律：任何人想拿笔在手册上写笔记，必须先把这一页复印成自己的专属页，然后才能动笔。这个规则就叫写时复制（Copy On Write，COW）。它把“复制成本”从入职时刻，推迟到了第一次动笔的时刻。

在内核里，fork 调用 copy_mm 后并不会复制物理内存页，而是进入 copy_page_range，把父进程页表里的映射关系逐条抄给子进程——子页表和父页表指向同一批物理页。同时，内核会把所有共享页的页表项（PTE）里的“可写位”清除，标记为只读。物理页本身也有一个“借阅人数”计数器（引用计数 refcount），每多一个进程共享就加一。

有了“共用手册”的规则，入职成本骤降。但这样一来，手册的目录（页表）就成了关键——它必须被精确复制，才能让两个人找到同一叠纸。下一节我们看看档案室如何“只复印目录，不印正文”。

页表复制：只复印目录不印正文

手册翻开第一页是目录索引：它告诉读者“第 3 章在第 50 页”。在进程的内存世界里，这个目录就是页表。为了让父子进程共享正文纸张，档案室必须把整个目录完整地抄一份给子进程——但纸上的正文一页都不用印。这就是页表复制的精髓：只复制“映射关系”，不复制“数据本身”。

现代 CPU 的页表不是一张大表，而是像图书馆一样的多层索引结构。以 x86-64 为例，虚拟地址被切分成几段：最前面的位用来查顶层目录（PGD），接着查中间目录（PMD），再查页表项（PTE），最后的低位是页内偏移。copy_page_range 就是沿着这套层级逐层往下走，把叶子层的 PTE 一条条复制到子进程的目录里，同时应用 COW 规则。

目录复印完成后，父子两人都能顺着目录找到同一叠正文纸。然而共享有共享的风险——万一其中一个人开始乱涂乱画怎么办？别急，正是前面设置的“只读”标记，会让任何动笔行为都惊动管理员。这就是缺页异常登场的时机。

execve替换：换一本全新手册

前面讲的都是“复制旧手册”。但如果员工转岗到 AI 算法组，旧手册里的销售话术、财务流程全都没用了——这时候需要直接换一本全新手册。这个动作对应的系统调用就是 execve。它和 fork 截然相反：fork 是“复印归档”，execve 是“废旧立新”。

execve 的执行路径像一场大扫除：内核先调用 flush_old_exec 释放旧的内存描述符和旧页表，把旧手册连同目录、纸张一起归还档案室；然后创建全新的 mm_struct，读取可执行文件的 ELF 格式头，把代码段、数据段、栈段逐一映射到新地址空间；最后从零搭建一套全新的页表，重置程序计数器并跳转到新程序的入口。父子之间此前共享的一切物理页，在这一刻被彻底切断。

新手册启用，旧手册化为纸浆。这也解释了为什么 shell 里 fork + execve 总是成对出现：fork 让 COW 机制下几乎不复制任何物理页，execve 再彻底抛弃这些映射。两者配合，既高效又干净。不过，如果某位员工真的要在共享手册上写第一笔，缺页异常就该上场了。

缺页异常：动笔前的临时复印

员工翻开共享手册，提起笔想在页边写一行笔记——只听“咔”一声，笔被锁住，册页纹丝不动。因为这一页被标记为“只读共享”。员工只好举手报告管理员：“这页纸是共享的，我要动笔！”管理员核查共享人数后，立刻复印一页新的纸交给他，此后这笔账就归他一个人管。这套“举手—复印—放行”的流程，就是缺页异常（Page Fault）处理。

CPU 在执行写入指令时发现 PTE 没有写权限，会触发缺页异常，陷入内核的 do_page_fault。异常处理程序顺着虚拟地址找到对应页表项，判断这页是否属于 COW 页——条件是有映射、可读但不可写，且物理页引用计数大于 1。满足条件，就分配一个新物理页（alloc_page），把旧页内容拷贝过去（copy_page），更新子进程的 PTE 指向新页并恢复写权限，同时把旧页的引用计数减一。如果引用计数恰好是 1，说明没人跟你共享了，直接把 PTE 改为可写即可，连拷贝都省了。

管理员把新复印件交给员工，员工终于写下属于自己的笔记。从此父进程改父进程的，子进程改子进程的，互不干扰。但新问题来了：当员工离职时，他手里的手册——以及那些曾经共享过的纸张——该怎么处理？这就是 exit 的回收艺术。

exit回收：离职时的纸张清理

员工离职那天，要把员工手册交回档案室并在扉页的“借阅人数”栏减一。如果这本手册还有人共用，档案室只做登记，并不销毁——毕竟其他同事还在看呢。只有当借阅人数归零，手册才能被碎纸销毁。这个“最后一人离开才销毁”的机制，就是 exit 路径上的资源回收逻辑。

进程调用 exit 后进入 do_exit，沿路释放文件、信号等资源，并调用 exit_mm 把手上的内存描述符交还给内核。exit_mm 最终走到 mmput：它先递减内存描述符的引用计数，只有当计数归零，说明没有任何进程再引用这枚 mm，才真正调用 mmput 尾部逻辑销毁页表、回收所有物理页。COW 中共享的物理页同理——每个页框有自己的引用计数，父子各自退出时各减一次，减到零才回收到伙伴系统。

至此，一个进程走完了“入职复印—共享手册—动笔复印—换新手册—离职销毁”的完整一生。COW 的延迟复制思想贯穿始终：申请时少复印、共用时少占用、动笔时才真正分配、离职时等最后一人走才销毁。这四个“延迟”，共同成就了现代操作系统高效创建进程的秘密。

AI 应用场景

Python 演示

"""写时复制（COW）机制迷你模拟器演示 fork 后父子进程共享物理页，子进程首次写入触发缺页复制。"""  class Frame:    """物理页帧：保存一页数据，记录有几个页表项引用它"""     def __init__(self, value=0):        self.value = value        self.refs = 1  # 引用计数  class Process:    """进程：用字典模拟页表，虚拟页号 -> PTE 字典"""     def __init__(self, pid):        self.pid = pid        self.pt = {}     def read(self, vpage):        return self.pt[vpage]["frame"].value     def write_to(self, vpage, value):        pte = self.pt[vpage]        if pte["ro"]:            # CPU 写只读页 -> 触发 COW 缺页异常            old = pte["frame"]            new = Frame(old.value)     # 分配新物理页并拷贝内容            old.refs -= 1              # 旧页引用计数减一            pte["frame"] = new            pte["ro"] = False            print(f"  [进程{self.pid}] COW缺页：分配新页并拷贝数据={new.value}")        pte["frame"].value = value        print(f"  [进程{self.pid}] 写入 虚拟页{vpage} = {value}")     def fork(self):        """创建子进程：共享物理帧，PTE 全部标记只读"""        child = Process(self.pid * 10 + 1)        for vpage, pte in self.pt.items():            pte["frame"].refs += 1     # 共享帧，引用计数 +1            child.pt[vpage] = {"frame": pte["frame"], "ro": True}            pte["ro"] = True           # 父进程 PTE 也变只读        print(f"  [进程{self.pid}] fork 出子进程{child.pid}，物理帧共享、PTE只读")        return child  def main():    parent = Process(1)    parent.pt[0] = {"frame": Frame(100), "ro": False}    parent.pt[1] = {"frame": Frame(200), "ro": False}    print("1) 初始：父进程有两个虚拟页 0 和 1")    child = parent.fork()    print("2) fork 之后：")    print(f"   父进程{parent.pid}: 页0={parent.read(0)} 页1={parent.read(1)}")    print(f"   子进程{child.pid}:  页0={child.read(0)} 页1={child.read(1)}")    print("3) 子进程修改页 0：")    child.write_to(0, 999)    print("4) 写后检查：")    print(f"   父进程{parent.pid}: 页0={parent.read(0)}（不受影响）")    print(f"   子进程{child.pid}:  页0={child.read(0)}（已修改）")    print(f"   页1 仍是共享帧，父子都能读到：{child.read(1)}")  if __name__ == "__main__":    main()

1. old.refs -= 1触发 COW 后，旧物理页的共享人数减少，为将来回收做准备。
2. child.pt[vpage] = {"frame": pte["frame"], "ro": True}子进程页表项指向父亲同一帧，但强制只读，这是 COW 的核心。
3. if pte["ro"]:模拟 CPU 写入只读页时触发缺页异常，进入复制流程。
4. new = Frame(old.value)分配新物理页并把旧页内容拷贝过去，对应内核的 alloc_page + copy_page。
5. pte["frame"] = new; ro = False更新 PTE 指向新页并恢复写权限，之后子进程可以随意改写。

常见误区

面试题