// arch/x86/include/asm/trap_pf.h:19-28
enum x86_pf_error_code {
    X86_PF_PROT =       BIT(0), /* 0=页不存在 1=权限拒绝 */
    X86_PF_WRITE    =       BIT(1), /* 写访问 */
    X86_PF_USER =       BIT(2), /* 用户态访问 */
    X86_PF_RSVD =       BIT(3), /* 保留位被置 1 (硬件表被改坏!) */
    X86_PF_INSTR    =       BIT(4), /* 取指 */
    X86_PF_PK   =       BIT(5), /* 保护键(pkey)拒绝 */
    X86_PF_SHSTK    =       BIT(6), /* shadow stack 访问 */
    X86_PF_SGX  =       BIT(15),    /* SGX MMU */
    X86_PF_RMP  =       BIT(31),    /* SEV-SNP RMP 违规 */
};

// arch/x86/mm/fault.c:1483-1530（节选）
DEFINE_IDTENTRY_RAW_ERRORCODE(exc_page_fault)
{
    irqentry_state_t state;
    unsigned long address;

    address = cpu_feature_enabled(X86_FEATURE_FRED) ? fred_event_data(regs)
                            : read_cr2();   /* :1487 */

    /*
     * KVM uses #PF vector to deliver 'page not present' events to guests
     * (asynchronous page fault mechanism)...
     */
    if (kvm_handle_async_pf(regs, (u32)address))        /* :1497 */
        return;
    ...
    state = irqentry_enter(regs);

    instrumentation_begin();
    handle_page_fault(regs, error_code, address);       /* :1518 */
    instrumentation_end();

    irqentry_exit(regs, state);
}

// arch/x86/mm/fault.c:1462-1480
static __always_inline void
handle_page_fault(struct pt_regs *regs, unsigned long error_code,
                  unsigned long address)
{
    trace_page_fault_entries(regs, error_code, address);

    if (unlikely(kmmio_fault(regs, address)))
        return;

    /* Was the fault on kernel-controlled part of the address space? */
    if (unlikely(fault_in_kernel_space(address))) {
        do_kern_addr_fault(regs, error_code, address);
    } else {
        do_user_addr_fault(regs, error_code, address);
    }
    /*
     * page fault handling might have reenabled interrupts,
     * make sure to disable them again.
     */
    local_irq_disable();
}

// arch/x86/mm/fault.c:1207（节选, 过滤序列按执行顺序）
void do_user_addr_fault(struct pt_regs *regs,
            unsigned long error_code, unsigned long address)
{
    ...
    /* [1] 内核态执行用户地址: 除 AMD erratum#93 外不可恢复 */
    if (unlikely((error_code & (X86_PF_USER | X86_PF_INSTR)) == X86_PF_INSTR)) {
        if (is_errata93(regs, address))
            return;
        page_fault_oops(regs, error_code, address); /* :1218-1229 */
        return;
    }

    /* [2] 保留位置位: 页表被硬件/注入改坏, 立即 Oops */
    if (unlikely(error_code & X86_PF_RSVD))
        pgtable_bad(regs, error_code, address);     /* :1238-1241 */

    /* [3] SMAP: 内核态(无 AC 标志)摸用户页 → 坏指针, Oops */
    if (unlikely(cpu_feature_enabled(X86_FEATURE_SMAP) &&
             !(error_code & X86_PF_USER) &&
             !(regs->flags & X86_EFLAGS_AC))) {     /* :1244-1256 */
        page_fault_oops(regs, error_code, address);
        return;
    }

    /* [4] 中断/无 mm/显式禁 fault 上下文: 不许发生 */
    if (unlikely(faulthandler_disabled() || !mm)) {
        bad_area_nosemaphore(regs, error_code, address);    /* :1264-1268 */
        return;
    }
    ...
    /* [5] kfence 采样池故障拦截 */                /* :693 附近 */
    ...
    /* [6] per-VMA 锁快路径找 VMA, 失败回退 mmap_lock (22.2.4 节) */
    vma = lock_mm_and_find_vma(mm, address, regs);      /* 后段 */
    ...
    /* [7] 权限预检: access_error(错误码, vma->vm_flags) */
    /* [8] handle_mm_fault → 按 VM_FAULT_* 结果收尾 */
}

x86 入口的完整分流图:

 exc_page_fault (:1483)
   ├─ 读 CR2 / FRED 数据
   ├─ KVM async pf? → KVM 处理
   └─ handle_page_fault (:1462)
       ├─ kernel 地址 → do_kern_addr_fault
       │    ├─ vmalloc 区: 惰性同步 (跨 CPU 页表复制的补页)
       │    └─ 坏指针 → Oops (EXTABLE 例外: copy_from_user 等)
       └─ user 地址 → do_user_addr_fault (:1207)
            ├─ 过滤序列 [1]-[5] → Oops/SIGSEGV/吞掉
            ├─ lock_mm_and_find_vma → 无 VMA: bad_area → SIGSEGV
            ├─ access_error → SIGSEGV (SEGV_ACCERR / pkey)
            ├─ handle_mm_fault (22.4 节矩阵)
            └─ mm_fault_error: OOM → kill; SIGBUS → IO 错误

// arch/x86/mm/fault.c:959-1030（注释与要点）
 * Handle a spurious fault caused by a stale TLB entry.
 * ... reserved bit (R = 1) faults are never spurious.
static int spurious_kernel_fault(unsigned long error_code, unsigned long address)   /* :980 */

匿名页的三段递进 (以一段 mmap 匿名区为例):

 [1] 首次读触碰:
     映射共享 zero page (全零页帧, 全系统一份)
     pte 只读、无 swap 后备 → 零内存成本、零 TLB 之外的副作用

 [2] 首次写 (该地址):
     zero page 是共享只读 → COW 语义 (25.3 节)
     do_anonymous_page 真分配: vma_alloc_zeroed_movable_folio
     (movable: 可被规整/热插拔迁移, 18.5 节)

 [3] 该页生命周期:
     进 lruvec 匿名链 (24.1 节) → 冷后被换出 swap (24.3 节)
     → 再次触碰走 do_swap_page 换回 (pte 的 swap 槽形态)

// mm/memory.c:5230（要点, 22.4.4 节引文的策略面补充）
static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
{
    ...
    /* NUMA 策略页: mpol_misplaced 判定后改道指定节点
       (内存策略: bind/preferred/interleave, 11.7 节关联) */
    ...
    folio = vma_alloc_zeroed_movable_folio(vmf->vma, vmf->address);
    if (!folio)
        return VM_FAULT_OOM;
    ...
    /* anon_vma 挂链 (22.2.5 节): 为回收/迁移铺 rmap 路 */
    ...
    entry = mk_pte(page, vma->vm_page_prot);
    entry = pte_sw_mkyoung(entry);
    if (write) {
        entry = maybe_mkwrite(pte_mkdirty(entry), vmf->vma);
        ...
    }
    ...
}

零页的三重收益 (为什么所有系统都坚持这一步):

 [1] 内存: 100 个进程各 mmap 10MB 但只读前 1KB
     → 实际消耗 = 1 个 4KB 页 (全部映射同一 zero page)
 [2] 缺页: 读缺页 = 建一条 pte (无分配、无清零)
     → fork 后立即读遍地址空间的探查行为零成本
 [3] COW 友好: 首写 = 25.3 节标准 COW (复制零页 =
     分配清零页, 代码路径与 fork COW 完全复用)

// mm/memory.c:5812-5842（要点）
static vm_fault_t do_read_fault(...)            /* 读故障 */
{   ret = __do_fault(vmf);  /* → vm_ops->fault → filemap_fault */ ... }

static vm_fault_t do_cow_fault(...)         /* 私有写故障 */
{   ...
    ret = __do_fault(vmf);      /* 先取文件页进缓存 */
    ...             /* 再为私有副本分配匿名页 */
    ...             /* copy: 文件页 → 私有页 (COW) */
    ...
}

// __do_fault (:5350, 22.4.5 节) 分发 vm_ops->fault

后备实现            fault 函数               供货内容
──────────────────────────────────────────────────────────
普通文件         filemap_fault             页缓存 folio
tmpfs (shmem)   shmem_fault               tmpfs 页 (MAP_SHARED 匿名的幕后)
设备 DAX        dax_iomap_fault           直接物理映射 (无页缓存)
DMA-buf/IO      自定义 vm_ops             remap 的设备内存
userfaultfd     handle_userfault          挂起等用户态处理器 (27 章关联)

记账分野 (12.4 节 cgroup / 18 章 totalram 的中间层):

                 匿名页                 文件页
 可换出           swap/zswap             丢弃+重读 (有后备)
 overcommit       VM_ACCOUNT 计入         不计 (有后备=天然可回收)
 memcg 记账       memory.current 匿名桶   文件桶 (与页缓存共享)
 kswapd 压力下    依赖 swappiness 配比     优先丢弃 (零 IO 或一次回写)

 NUMA 策略点:
  do_anonymous_page 内 mpol 判定 → 页落在策略节点
  文件页落在首次读的节点 (自然聚集)
  NUMA balancing (11.7 节) 可在缺页路径把
   "页在远端 + 进程倾向本端" 转为迁移触发

do_swap_page 的流程:

 1. 从 pte 解出 swap 槽号 (swp_entry_t)
 2. swap 缓存查页: 他人已换回? → 直接共享映射 (免 IO)
 3. 未命中: 分配页, 发起 swap-in IO (可读回预读邻槽 —
    swap 顺序性通常好于文件随机 IO, 预读收益更高)
 4. IO 完成: pte 重建 (从 swap 槽值还原权限位)
    exclusive 位决定是否恢复 PageAnonExclusive (25.3.3 节)
 5. 槽释放: 引用归零后 swap 槽归还 (24 章 swap 计数)

 zswap 路径: 换出时先压缩进内存池, 槽标记 zswap 后备;
 do_swap_page 先查 zswap 池, 命中则解压 — 零磁盘 IO
 (以 CPU 换 IO 的典型取舍, 内存尚有余压但 IO 已是瓶颈)

预埋的三处只读 (谁在等 COW):

 [1] fork: 父子全部可写 pte 同时降为只读 (复制的页表改 pte)
     18.4.2 节: 复制时 _mapcount++ — 计数先行是安全前提
 [2] MAP_PRIVATE 文件映射: 建立即只读 (25.2.2 节)
 [3] 零页/共享 zero page: 天然只读 (25.2.1 节)

 硬件的角色: pte RW=0 时写触发 #PF (X86_PF_WRITE|X86_PF_PROT,
 19.2.2 节位语义) — "写只读页"不是错误而是信号

 fork 的页表复制全景 (为什么启动零拷贝):

 父进程页表                子进程页表 (fork 后)
 pte A: RW=1, 页帧 X  ──→  pte A: RW=0, 页帧 X   (同一物理页!)
 pte B: RW=1, 页帧 Y  ──→  pte B: RW=0, 页帧 Y
 pte C: RW=0(本来只读) ──→ pte C: RW=0            (无需改)
 ...
 复制 N 页表项的成本 ≈ memcpy 页表页
 数据页: 零拷贝 — 全部"欠着", 等写时再算账
 (1GB 进程 fork: 复制 ~2MB 页表 vs 拷 1GB 数据)

// mm/memory.c:4162（签名与分支结构）
static vm_fault_t do_wp_page(struct vm_fault *vmf)
    /* 经过 handle_pte_fault (:5095) 的判定前提:
       pte 存在、无写权限、FAULT_FLAG_WRITE */

分支结构 (自上而下, 每层都是"能不复制就不复制"):

 [A] vm_ops->page_mkwrite 存在? (文件/设备后备)
     → 交后备自查: 页还在吗、可以写了吗 (网络文件协商)
     后备放行 → pte 提权即可, 零复制

 [B] 页是匿名 + 独占 (PageAnonExclusive)?
     → 无共享者! 直接 pte 提权 (wp_page_reuse, :5024 区)
     覆盖场景: fork 后子进程退出, 父进程又独占了

 [C] 需要复制的路径 → wp_page_copy:
     1. 分配新匿名 movable 页 (25.2.1 节同款)
     2. cow_user_page: copy_from_user_page 拷贝旧内容
        (用户页可被并发改 → 拷贝失败则 VM_FAULT_RETRY)
     3. 原页若是 zero page / 文件页:
        零页不用拷 (目标页本就清零)
        文件页: 这是 MAP_PRIVATE 首写, 拷文件内容
     4. pte 切换: 新页可写、_mapcount 处理、TLB (19.5 节)
     5. 旧页 put: _mapcount-- 后仍 >0 → 父/子还有一份

do_wp_page 三分支的判定流程图:

 写缺页 (#PF: WRITE|PROT)
   │
   ├─ 文件后备? ──是──> page_mkwrite 钩子 ──放行──> pte 提权
   │                                        └─拒绝→ SIGBUS
   ├─ PageAnonExclusive? ──是──> wp_page_reuse
   │                              (pte RW=1, 零复制!)
   └─ 否 (真共享) ──> wp_page_copy
        分配新页 → 拷贝旧内容 → pte 切新页(可写)
        → 旧页 put (mapcount--)
        → TLB flush → 完成

 成本阶梯: 提权(0.2μs) << 复制(3μs+) —
 判定链的排序就是"最便宜的先查"

标志的转移矩阵:

 事件                      对 PageAnonExclusive 的操作
───────────────────────────────────────────────────────
 匿名页缺页分配 (写)         置位 (新页天然独占)
 fork 复制 pte              父页清位 (共享开始), 子页新页或清位
 进程退出 unmap 最后一个映射    置位 (回归独占)
 页被 GUP 长期 pin           必须先清位/迁移 (18.5 节 pin 阻迁移同源)
 swap 换出再换回             从 pte 软位恢复 (swap 编码携带)
 页迁移/规整                 目标页继承判定重做

 误清位的代价: 多一次无谓复制 (性能)
 误置位的代价: 两进程看到彼此的写 (安全漏洞!) — 所以
 清位的路径宁多勿漏, 置位必须可证明独占

一个 fork-exec 生命的标志轨迹 (shell 启动 ls):

 bash fork ──> 子 exec ──> 子退出 ──> bash 后续写
 页 X(代码/数据) 的 PageAnonExclusive:
   置位(bash 分配时) ──> fork: 父清位, 子页清位
                       ──> exec: 子全部映射拆掉
                       ──> 子退出: 页的映射只剩父
                       ──> 父再写: [B] 分支命中! 零复制提权
 (旧内核此处要走计数检查+可能复制 —
  fork+exec 型负载的写延迟在 7.x 显著改善)

KSM (同页合并) 写缺页:
  合并页写保护 → 写触发 COW → 新私有页 (被合并副本继续共享)
  wp_page_copy 复制的是"合并组内容"

THP 大页的 COW:
  2MB 块项写保护 → 先分裂 (23.3.4 节) → 再按 4KB COW
  一次写 = 分裂 512 项 + 复制 1 页 (fork 大内存进程首写尖刺的来源)
  PageAnonExclusive 的 PMD 级对应 (PM_D_anon_exclusive 语义)
  让 fork 后未真正共享的 THP 免于分裂

GUP pin 的死结:
  长期 pin 的页不可迁移 (18.5 节) 也必须先解 pin 才能 COW
  wp_page_copy 前 try_to_unmap 失败 → VM_FAULT_RETRY

时序正确性论证:

 t0: fork 完成态: 父 pte(RW=0) + 子 pte(RW=0), 页帧 X
     — 任何一方写都会缺页, "共享期"实际是冻结期

 t1: 父写 → do_wp_page:
     (子 pte 还指着 X, 但子此刻不可能在写 X —
      它写 X 也会缺页阻塞!)

 t2: 父拿新页 Y, 拷贝 X→Y (此刻 X 确定无人写)
     → 父 pte = RW=1@Y; 子 pte 不变 (RW=0@X)

 t3: 子写 → 子自己触发 COW → 子拿 Z...

 "先全员只读、后择一复制"的全局时序
 就是 COW 的正确性论证: 复制发生时旧页
 已处于"事实冻结"态

观测面:

 /proc/vmstat:  page_fork (fork 复制的页数), cow 相关计数
 perf trace -e page_fault_*    缺页事件流
 perf record -e exceptions:page_fault  按地址聚合
 bpftrace: tracepoint exceptions:page_fault_user
   按 error code 过滤 PF_PROT|PF_WRITE 即 COW 流量

 fork 尖刺的调试套路:
 1. 延迟尖刺出现时查 smaps_rollout 的共享/私有页分布变化
 2. thp_split_page 计数与尖刺对刻 (25.3.4 节机制)
 3. PageAnonExclusive 回归验证: fork+exec 型负载
    升级 7.x 内核后私有写缺页应显著下降

             x86_64              ARM64                 RISC-V
 故障地址     CR2 (锁定寄存器)      FAR_EL1 (far)         stval (regs->badaddr)
 异常性质     #PF 错误码 (32 位)    ESR_ELx (32 位,       scause (64 位码)
             位掩码 X86_PF_*       EC+FSC 组合编码)       regs->cause
 访问类型     WRITE/INSTR 位        WnR/Inst 位 + abort    W/X 位编码进 scause
 特权态      USER 位               EL0/EL1 判定           user_mode(regs)

// arch/arm64/mm/fault.c:556-640（节选）
static int __kprobes do_page_fault(unsigned long far, unsigned long esr,
                   struct pt_regs *regs)
{
    ...
    unsigned long addr = untagged_addr(far);    /* :566 MTE TBI 剥标签 */

    ...
    if (user_mode(regs))
        mm_flags |= FAULT_FLAG_USER;

    /*
     * vm_flags tells us what bits we must have in vma->vm_flags
     * for the fault to be benign...
     */
    if (is_el0_instruction_abort(esr)) {            /* :583 */
        /* It was exec fault */
        vm_flags = VM_EXEC;
        mm_flags |= FAULT_FLAG_INSTRUCTION;
    } else if (is_gcs_fault(esr)) {             /* :588 */
        /*
         * The GCS permission on a page implies both read and
         * write so always handle any GCS fault as a write fault,
         * we need to trigger CoW even for GCS reads.
         */
        vm_flags = VM_WRITE;
        mm_flags |= FAULT_FLAG_WRITE;
    } else if (is_write_abort(esr)) {           /* :598 */
        vm_flags = VM_WRITE;
        mm_flags |= FAULT_FLAG_WRITE;
    } else {
        /* It was read fault */
        vm_flags = VM_READ;
        /* Write implies read */
        vm_flags |= VM_WRITE;
        /* If EPAN is absent then exec implies read */
        if (!alternative_has_cap_unlikely(ARM64_HAS_EPAN))
            vm_flags |= VM_EXEC;
    }

    if (is_ttbr0_addr(addr) && is_el1_permission_fault(addr, esr, regs)) {  /* :608 */
    ...
}

// arch/riscv/mm/fault.c:278-320（节选）
void handle_page_fault(struct pt_regs *regs)
{
    ...
    cause = regs->cause;        /* scause */
    addr = regs->badaddr;       /* stval */
    ...
    if ((!IS_ENABLED(CONFIG_MMU) || !IS_ENABLED(CONFIG_64BIT)) &&
        unlikely(addr >= VMALLOC_START && addr < VMALLOC_END)) {
        vmalloc_fault(regs, code, addr);    /* :312-317 */
        return;
    }

    /* Enable interrupts if they were enabled in the parent context. */
    if (!regs_irqs_disabled(regs))
        local_irq_enable();
    ...
}

// arch/riscv/mm/fault.c:380-402（主干, 与 22.4/25.1 的同构点）
retry:
    vma = lock_mm_and_find_vma(mm, addr, regs);     /* :380 */
    if (unlikely(!vma)) {
        tsk->thread.bad_cause = cause;
        bad_area_nosemaphore(regs, code, addr);     /* :144-152 */
        return;
    }
    ...
    if (unlikely(access_error(cause, vma))) {       /* :396 */
        tsk->thread.bad_cause = cause;
        bad_area(regs, mm, SEGV_ACCERR, addr);
        return;
    }

    fault = handle_mm_fault(vma, addr, flags, regs);    /* :404 */
    ...

入口实现清单 (按 do_page_fault 的结构序):

 [1] 故障地址/原因寄存器读入 pt_regs (stval/CR2/FAR 对应物)
 [2] 用户/内核态判别 (spsr/CS/sscs)
 [3] 内核区 fault 的按需同步 (共享 PGD 架构可豁免)
 [4] 原子上下文拒绝 (faulthandler_disabled)
 [5] 地址清洗 (MTE/TBI/LAM 标签剥离; 分页模式位)
 [6] 访问类型翻译 → VM_READ/WRITE/EXEC + FAULT_FLAG_*
 [7] lock_mm_and_find_vma (通用, 直接复用)
 [8] access_error: 架构权限位 → VMA 权限判定
 [9] handle_mm_fault (通用) + RETRY 语义
 [10] mm_fault_error → SIGBUS/SIGSEGV/OOM 挂钩
 [11] thread 结构的 cause 备存 (信号路径需要)
 [12] 特殊故障旁路: 外部错误(SEA/总线)/影子栈/KVM 异步PF