第 4 章 进程、线程与写时复制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fork 之后：两套页表各自独立，但 PTE 指向同一物理页、且均为只读
  父页表 PTE@VA 0x7f2a...1000        子页表 PTE@VA 0x7f2a...1000
    PFN = 0x1A3C0  P=1  W=0  U=1       PFN = 0x1A3C0  P=1  W=0  U=1
            └──────────────┬──────────────┘
                           ▼
              ┌──────────────────────────────┐
              │ 物理页框 0x1A3C0（只有一份数据）│
              │   _refcount = 2  总引用数     │                │   _mapcount = 2  被几个页表映射│  ← COW 判据
              └──────────────────────────────┘
  权限位：bit0 P present 映射有效；bit1 W writable 可写 —— COW 拦截写的全部依据就是把它清 0。
  ★ 父子共享的是"它指向的页框"，不是 PTE 本身：改一方可写不必动另一方。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

一次 COW 写的完整路径（子进程写地址 A）；子进程: mov [A], eax
  ① MMU 翻译 A：PTE 有效（P=1）但 W=0 且本次是写 ⟹ 保护违例 → #PF →
     陷入 do_page_fault()（与"页不在内存"共用入口，靠 error code 区分
     protection / not-present）
  ② 判定是否可 COW：查 VMA 权限（不允许写 → SIGSEGV，与 COW 无关）；
     匿名页或 MAP_PRIVATE 私有文件映射 → 候选；_mapcount > 0 ⟹ 还有人映射它
     ⟹ 必须真复制；若 _mapcount == 0（对方已退出/页已换出）⟹ 原地加速路径：
     不分配不拷贝，只把 PTE 的 W 位置 1
  ③ 分配新物理页 B，memcpy(旧页 → B)，改**子进程** PTE：PFN 0x1A3C0 →
     0x2B77F、W 0 → 1；旧页 _mapcount -=1、_refcount -=1，新页计数置 1；
     TLB 该地址旧表项必须失效（否则反复缺页）
  ④ 返回用户态重执行那条写指令：PTE 已可写，命中完成
  ★ 父进程 PTE 完全没有被改动，仍指向 0x1A3C0 且仍只读 ——
     "谁写谁付钱"：只有触发写的一方分摊复制成本。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

  T_fork ≈ T_task + T_vma + T_pagetable + T_ref
    T_task      ：复制 task_struct、线程组信息、信号队列、fs_struct —— 常数级、μs
    T_vma       ：复制 VMA（虚拟内存区域）描述符 —— 正比于"区域个数"而非字节数；
                  频繁 mmap/munmap 造成碎片化时显著上升
    T_pagetable ：遍历页表，为每个**已映射页**写一条新 PTE —— 大内存进程的主要成本
    T_ref       ：每个匿名页 _refcount += 1 —— 每页一次原子加
  换算（x86-64，4 级页表，4 KB 页，PTE 8 字节）：
    4 GB  → 4×2³⁰ ÷ 4096 = 2²⁰ ≈ 1.05 M 页；10 GB → 2.62 M 页
    仅 PTE 本身 = 2.62 M × 8 B ≈ 21 MB
    上层页表：每个 PTE 页覆盖 512 × 4 KB = 2 MB，每个 PMD 页覆盖 1 GB
             ⟹ 10 GB 最少 5120 个 PTE 页 + 10 个 PMD 页，碎片化后多用几倍
    ⟹ fork 要新建的页表总量在 20 ~ 40 MB，耗时毫秒级

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static char shared_buf[64] = "before";
static int child_ret(void *arg) {
    // 为什么直接改静态变量：CLONE_VM 下父子共用同一地址空间，
    // 这次写对父进程立即可见 —— 这正是"线程"与"进程"的分水岭。
    snprintf(shared_buf, sizeof(shared_buf), "written by child");
    return 0;
}

int main(void) {
    // 5 个 flag 的并集 = 一个线程；去掉 CLONE_VM|CLONE_THREAD = 一个进程。
    // 为什么必须凑齐：CLONE_THREAD 强制要求同时给出 CLONE_SIGHAND，
    // 否则 clone 直接返回 EINVAL —— 这是硬依赖，不是建议。
    const int flags = CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD;
    char *stack = malloc(1 << 20);   // 线程要自己的栈，由调用者负责分配
    if (stack == NULL) return 1;
    if (clone(child_ret, stack + (1 << 20), flags, NULL) == -1) {
        perror("clone");             // 失败原因常见于 flags 组合非法
        return 1;
    }
    sleep(1);
    printf("parent sees: %s\n", shared_buf);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

  T0  父进程：页表 ~0.002 × N GB，数据页 N GB
   │  fork()  ▼
  T1  父 mm#1 ─┐
      子 mm#2 ─┴→ 共享 N GB 物理页（_mapcount = 2，全只读）；新增 = 第二套
      页表（MB 级、毫秒级）+ 每页一次引用计数递增
   │  子进程 execve()  ▼
  T2  子进程旧 mm 被整体丢弃：flush_old_exec() 卸下旧映射、信号处置回默认、
      清 FPU/线程状态；exec_mmap() → mmput(old_mm) 引用计数减 1，归零则
      __mmput() → exit_mmap() 逐 VMA 解除映射，每页 _mapcount 减 1、
      _refcount 减 1，减到 0 的页归还 buddy 分配器
      ★ 这些页仍被父进程映射着，所以一个也不会真正释放
  T3  子进程建立**全新的** mm：新 ELF 的 PT_LOAD 段、新栈（argv/envp）、新堆、
      新 vdso/vvar、新 mm_struct ⟹ 从"复制 N GB"变成"复制页表 + 整体拆建"

  两个不随 exec 消失的例外：shmat 附加的 System V 共享内存段、部分系统上的
  MAP_SHARED 映射（行为依赖实现，不要依赖它）。fd 默认全部继承，除非带
  FD_CLOEXEC（O_CLOEXEC）⟹ 大 fd 进程（网关、DB）必须在创建时就加 CLOEXEC。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

  用户态（glibc，顺序不可交换）：① 逆序执行 atexit()/on_exit() 注册的函数
    （LIFO，便于与初始化顺序对称释放）；② 刷新并关闭所有 stdio 流（fflush）
    —— 缓冲区内容才真正 write 出去；③ 关闭所有仍打开的流（fclose）→
    相应 fd 被 close；④ 调用 _exit(status) 进入内核
  内核态（do_exit，此后不返回）：⑤ 释放用户态资源：地址空间 mm、fd 表、信号
    处理、定时器、文件锁；⑥ 退出码写进 task_struct，状态置 EXIT_ZOMBIE（`Z`），
    保留 task_struct 与退出状态直到父进程 wait；⑦ 向父进程发送 SIGCHLD；
    ⑧ 把子进程过继给 init 或最近的 subreaper；⑨ schedule() 切走，永不回来
  ⟹ _exit() 跳过 ①②③ 直接进内核。fork 出的子进程必须用 _exit()：否则会把
     父进程 stdio 缓冲区再 flush 一遍 —— 缓冲区在 fork 时被复制了两份，
     于是同一份日志落盘两次。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

// 为什么必须在循环里 waitpid：多个子进程几乎同时退出时，内核可能只投递一次
// SIGCHLD（标准信号不排队，同类信号在未决位图上合并）。若 handler 只 wait 一次，
// 剩下的孩子永远没人回收，会长期显示为 <defunct>，最终耗尽 PID 表。
static void on_sigchld(int sig) {
    (void)sig;
    int saved_errno = errno;            // handler 可能打断任意代码，必须保护 errno
    for (;;) {
        pid_t pid = waitpid(-1, NULL, WNOHANG);
        if (pid > 0) continue;                        // 还有已退出的孩子，继续收
        if (pid == 0) break;                          // 有孩子活着未退出，收工
        if (pid == -1 && errno == EINTR) continue;     // 被别的信号打断，重试
        break;                                        // ECHILD：没有孩子了
    }
    errno = saved_errno;
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = on_sigchld;
    sa.sa_flags = SA_NOCLDSTOP;         // 只在真正退出时通知，停止/继续不通知
    sigemptyset(&sa.sa_mask);
    sigaction(SIGCHLD, &sa, NULL);
    for (;;) pause();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  会话（session, sid） ← 由 setsid() 创建
   ├── 进程组 A（pgid；会话首进程所在组 = 前台组）
   │    ├── 进程 A1（组长：pid == pgid）   └── 进程 A2
   └── 进程组 B：进程 B1
  控制终端：一个会话最多关联一个终端设备
    · 终端把信号发给**前台进程组**：Ctrl+C → SIGINT、Ctrl+Z → SIGTSTP
    · SIGHUP（挂断）发给会话首进程及其控制的作业

  双 fork 每一步为什么必要：
    fork#1  父 → 子 S1，父立即 _exit(0)
       ⟹ S1 被 init 收养；shell 立刻返回（./svc & 不占住终端）
       ⟹ 但 S1 是否进程组组长取决于原进程的组身份，**不能保证**
    fork#2  S1 → 孙 S2，S1 也立即 _exit(0)
       ⟹ S2 的 pid 是新号、pgid 继承自 S1，故**必然不是组长**
       ⟹ 于是 setsid() 必定成功，而不像单次 fork 那样取决于调用环境
    setsid() S2 成为新会话首进程 + 新进程组组长，脱离开原控制终端

  为什么之后不会再获得控制终端：控制终端只能由**会话首进程**通过打开一个
  尚未属于其他会话的 tty 取得。setsid 后 S2 已脱离原终端且不持有任何 tty；
  此后它不再打开 tty（或带 O_NOCTTY），终端事件再也影响不到它。
  之后的标准动作：chdir("/") 免得占住启动目录挂载点；umask(0) 权限规则自己定；
  把 0,1,2 重定向到 /dev/null，避免写日志失败。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

  用户栈：pthread_create 时由 glibc 用 mmap 分配，默认上限 8 MB
    · 8 MB 是**虚拟地址保留**，物理页按需分配 ⟹ "起了 1000 个线程"不等于占用
      8 GB 物理内存；但每线程至少触碰一两页、各占一个 VMA 与自己的页表
      ⟹ 1000 线程大致对应数十 MB 物理 + 数千个 VMA
    · 栈底有 guard page（PROT_NONE 页），越界访问触发 SIGSEGV
    · 主线程的栈**不是** mmap 来的：它来自程序加载时的映像，靠 RLIMIT_STACK
      增长，超限则 SIGSEGV
  内核栈：每任务一份，x86-64 上 16 KB（2 页）或 8 KB，随 fork/clone 一并分配、
    **不可增长** ⟹ 内核代码递归深度受限；系统调用/中断与缺页处理都在这里跑。
    与用户栈独立：用户栈溢出是 SIGSEGV，内核栈溢出是内核 panic。