fault-around 的工程意义：默认 fault_around_bytes 约为 64KB（16 页），即每次 4KB 缺页中断会触发一次 64KB 的顺序预读。对于顺序扫描的数据库（ClickHouse Parquet 扫描、InnoDB 全表扫描），这可以将 I/O 次数降低 16 倍。但还有 15/64 的"脏读"开销。因此生产调优中常对这类数据库设置 vm.fault_around_bytes=16（仅 4KB）。

4.2 do_anonymous_page：匿名页与零页

匿名页来源于 malloc()（mmap 匿名映射）、brk 堆扩展、栈扩展等：

c
static vm_fault_t do_anonymous_page(struct vm_area_struct *vma,
                                    unsigned long address, unsigned long flags,
                                    struct pt_regs *regs)
{
    // 快速路径 1：读异常 → 立即映射到全局零页
    if (!(flags & FAULT_FLAG_WRITE) && !vma_is_anonymous_dma(vma)) {
        // 将零页的只读映射写入 PTE
        // zero page 是静态分配的全 0 字节页
        entry = pte_mkspecial(pfn_to_pte(zero_pfn, vma->vm_page_prot));
        return VM_FAULT_DONE;  // 最高性能级别：无分配
    }

    // 快速路径 2：写异常 → 分配匿名页
    page = alloc_pages_vma(gfp_mask, 0, vma, address, false);
    if (!unlikely(page)) {
        return VM_FAULT_OOM;
    }

    // 清除页内容（安全：防止信息泄露）
    clear_highpage(page);

    // 插入页到 VMA 反向映射（rmap）
    __page_set_anon_rmap(page, vma, address, false);

    // 设置 PTE 为 present + writable + accessed
    entry = mk_pte(page, vma->vm_page_prot);
    set_pte_at(mm, address, ptep, entry);

    return VM_FAULT_WRITE;
}

零页为何特殊？ Linux 内核在物理内存中静态保留一个 4KB 的全 0 字节页（零页）。进程初始化一个匿名区域（如 BSS 段）时，若读异常，并不分配新页 —— 而是直接将 PTE 映射到这个共享零页并标记为只读。仅在第一次写访问时，才触发真正分配新页的 CoW 流程。此设计实现了：

• 减少内存分配压力：零值 BSS 段不消耗实际物理页
• 减少 TLB 未命中：零页在多次进程切换中保持在 TLB 中
• 减少 RSS：进程 RSS 只计算实际物理页，不会将"零值内存"计入

五、\_\_handle\_mm\_fault：深入页表遍历

真正的页表操作在 __handle_mm_fault 中完成，它使用递归宏遍历 4-5 级页表：

c
// mm/memory.c
static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
                                    unsigned long address, unsigned long flags,
                                    struct pt_regs *regs)
{
    pgd_t *pgd;
    p4d_t *p4d;
    vm_fault_t ret;

    // Level 1: PGD (Page Global Directory)
    pgd = pgd_offset(mm, address);
    // x86-5level：pgd 可以是大页映射
    if (unlikely(pgd_none(*pgd))) {
        // PGD 为空，分配 P4D
        p4d = p4d_alloc(mm, pgd, address);
        if (unlikely(!p4d))
            return VM_FAULT_OOM;
    } else if (unlikely(pgd_trans_huge(*pgd))) {
        // PGD 级 1GB 大页（x86 PGD_PAGE_SIZE >= 1GB）
        return pgd_huge_gfn_update(vma, address, pgd, flags);
    } else {
        p4d = p4d_offset(pgd, address);
    }

    // Level 2: P4D (4th level Page Directory)
    if (p4d_none(*p4d)) {
        // 分配 PUD
        pud = pud_alloc(mm, p4d, address);
        ...
    } else if (unlikely(pud_trans_huge(*pud))) {
        // PUD 级 2MB 或 1GB 大页
        return pud_huge ...
    } else {
        pmd = pmd_offset(pud, address);
    }

    // Level 3: PMD (Page Middle Directory)
    if (pmd_none(*pmd)) {
        // 分配 PTE 页表（4KB 页持有 512 个 PTE）
        pte = pte_alloc_map(mm, pmd, address);
        if (unlikely(!pte))
            return VM_FAULT_OOM;
    } else if (unlikely(trans_huge)) {
        // PMD 级 2MB 或 1GB 大页
        return create_huge_pmd ...
    } else {
        pte = pte_offset_map(pmd, address);
    }

    // Level 4: PTE (Page Table Entry) —— 叶子节点
    return handle_pte_fault(vma, address, pte, pmd, flags, regs);
}

工程优化亮点

惰性分配（Lazy Allocation）：内核不会预分配所有层级的页表。例如进程 mmaps 100GB 匿名内存但只访问 10MB，则内核只分配 10MB / 4KB × 8B = 20KB 的 PTE 页 —— 而不是 100GB / 4KB × 8B = 200MB。

PTE 页池化：内核预分配的 PTE 页保存在 per-CPU 缓存中。缺页中断时直接从缓存分配，避免伙伴分配器的加锁和页清零开销。

透明大页（THP）合成：在 THP defer+madvise 模式下，__handle_mm_fault 会优先检查周围 PTE 是否已分配。若是，则合成 PMD 级 2MB THP 映射；否则回退常规 4KB。

六、handle_pte_fault：叶子级分支决策

handle_pte_fault 是缺页中断类型的决策核心：

c
static vm_fault_t handle_pte_fault(struct vm_area_struct *vma,
                                   unsigned long address, pte_t *pte,
                                   pmd_t *pmd, unsigned long flags,
                                   struct pt_regs *regs)
{
    // 情况 1：PTE 完全为空
    if (!pte_present(*pte)) {
        // A. 页未被映射 —— 处理文件映射的按需分页
        if (!vma->vm_file) {
            if (vma->vm_ops && vma->vm_ops->fault)
                return do_linear_fault(vma, address, flags, regs);  // 文件映射
            else
                return do_anonymous_fault(vma, address, flags, regs); // 匿名映射
        }

        // B. 页已在交换空间 —— 需要加载
        if (!pte_present(*pte) && pte_swp_soft_dirty(*pte))
            return do_swap_page(vma, address, flags, regs);  // 软脏页
        if (!pte_present(*pte) && is_swap_pte(*pte))
            return do_swap_page(vma, address, flags, regs);  // swap 区页
    }

    // 情况 2：PTE 存在但写保护（CoW fork）
    entry = *pte;
    if (flags & FAULT_FLAG_WRITE) {
        if (!pte_write(entry)) {
            // CoW：写只读 PTE → 复制页
            return do_wp_page(vma, address, pte, pmd, flags, regs);
        } else {
            // 硬件脏：设置脏位和访问位
            entry = pte_mkwrite(entry);
            entry = pte_mkyoung(entry);
        }
        // 原子更新 PTE 以避免竞态
        set_pte_at_notify(mm, address, pte, entry);
        flush_tlb_page(vma, address);
        return VM_FAULT_WRITE;
    }

    // 情况 3：PTE 存在且权限 OK —— 仅设置硬件访问位
    pte_mkyoung(*pte);   // 设置 Accessed 位
    if (!pte_dirty(*pte) && (vm_flags & VM_WRITE))
        pte_mkdirty(*pte); // 设置 Dirty 位

    return VM_FAULT_MINOR;
}

6.1 do_wp_page：写时复制的性能关键

do_wp_page 处理 fork() 后对只读共享页的写缺页中断：

c
static vm_fault_t do_wp_page(struct vm_area_struct *vma,
                             unsigned long address, pte_t *pte,
                             pmd_t *pmd, unsigned long flags,
                             struct pt_regs *regs)
{
    page = vm_normal_page(vma, address, *pte);

    // 快速路径 1：引用计数为 1，无其他进程共享
    //   直接归还原始页 —— 无需复制（90% 场景）
    if (page_count(page) == 1) {
        set_pte_at(mm, address, pte, pte_mkwrite(*pte));
        return VM_FAULT_WRITE;
    }

    // 快速路径 2：KSM（Kernel Samepage Merging）合并页
    //   顺带检查 —— 可能 refcount > 1 但内容相同
    if (PageKsm(page)) {
        // 触发与不同内容的并发合并 → 等待合并完成
        ...
    }

    // 慢路径：真正复制
    //   分配新页 + 从旧页复制页内容 + 设置新 PTE
    new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, address);
    copy_user_highpage(new_page, page, address, vma);
    __SetPageUptodate(new_page);

    // 临界区：持有 PTL 锁 + 验证旧 PTE 未变化
    *ptpte = pte_offset_map_lock(mm, pmd, address, &ptl);
    if (likely(pte_same(*ptpte, *pte))) {
        // 对接 rmap 映射集 → 逐一更新
        page_add_new_anon_rmap(new_page, vma, address, false);
        // 递减旧页引用计数
        page_remove_rmap(page, false);
        put_page(page);
        set_pte_at_notify(mm, address, ptpte,
            mk_pte(new_page, vma->vm_page_prot));
    }
    pte_unmap_unlock(ptpte, ptl);

    return VM_FAULT_WRITE;
}

为什么 page_count == 1 能走快速路径：fork() 后该进程持有引用。如果没有其他进程（如 ptrace/gdb/strace）附加共享，引用计数恰好为 1 —— 此时该进程是此页面的唯一所有者，可直接将只读 PTE 升级为可写。这是 95% 的 fork+exec 进程的主要优化点，也是 Linux CoW 复制并不昂贵的原因。

6.2 do_swap_page：Swap-In 路径

当 PTE 内容为空但有有效的 swap 项时，需从交换区加载页：

c
static vm_fault_t do_swap_page(struct vm_area_struct *vma,
                               unsigned long address, pte_t *pte,
                               pmd_t *pmd, unsigned long flags,
                               struct pt_regs *regs)
{
    // 1. 解码 swap entry → 获取 swap 类型与 swap 偏移
    entry = pte_to_swp_entry(*pte);

    // 2. 检查 swap 缓存：页是否已加载且在 pagecache 中？
    page = lookup_swap_cache(entry, vma, address);
    if (page) {
        swap cache 命中：直接从 pagecache 使用
        ...
        goto out;
    }

    // 3. 检查并发 swap-in 以减少锁竞争
    //  （多线程对同一 entry 的并发 swap-in）
    if (swapcache_prepare(entry) != 1)
        goto out_noswap;

    // 4. 分配页并启动 I/O
    page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, address);
    // 构建 bio → submit_bio → 从 swap 设备读页
    ret = swap_readpage(page, true, &plug);

    // 5. 在此处睡眠等待 I/O 完成
    //    注意：swap-in 期间持有 PTL 锁
    //    但是：进程状态被设为 TASK_KILLABLE
    wait_on_page_locked(page);

    // 6. 验证 I/O 等待期间 swap entry 没有变化
    if (!same_swap_pte(*pte, entry))
        goto unlock;

    // 7. 设置新 PTE
    set_pte_at(mm, address, pte,
        mk_pte(page, vma->vm_page_prot));
out:
    swap_free(&entry);
    return ret;
}

七、Userfaultfd：用户态缺页处理的协同机制

userfaultfd 是 Linux 内核最独特的缺页中断扩展 —— 它允许用户程序在用户空间自定义缺页中断处理逻辑。这是 firecracker microVM 快照恢复、PostgreSQL 备份工具、CRIU 热迁移的核心机制。

工作原理

当 userfaultfd 注册一段地址范围后，内核在缺页时跳过常规处理路径，转而向用户进程发送事件：

c
// mm/userfaultfd.c
vm_fault_t handle_userfault(struct vm_fault *vmf, unsigned long reason)
{
    // 1. 若注册了 UFFD 的 Missing 事件 → 发送事件到用户空间
    // 2. 若注册了 UFFD 的 WP（写保护）事件 → 发送事件
    // 3. 内核将当前 task 设置为 TASK_KILLABLE 状态直到处理完成
    // 4. 线程在 ctx->fd_wqh 等待队列中睡眠

    // Userfaultfd 事件结构
    struct uffd_msg msg = {
        .event = UFFD_EVENT_PAGEFAULT,
        .arg.pagefault.address = address,
        .arg.pagefault.flags = 0,
    };

    // 将事件发送到用户空间
    __deliver_uffd_message(ctx, &msg);

    // 不处理事件的线程接收 SIGBUS 退出
    userfaultfd_wait_queue_remove(vmf);
    return VM_FAULT_RETRY;
}

用户进程随后调用 ioctl(UFFDIO_COPY) 或 ioctl(UFFDIO_ZEROPAGE) 向缺页页注入内容：

c
// 用户空间伪代码
struct uffdio_copy copy = {
    .dst = fault_address,           // 出错的虚拟地址
    .src = source_page,             // 源数据地址（如从网络接收或快照文件）
    .len = PAGE_SIZE,
    .mode = 0,
};
ioctl(uffd_fd, UFFDIO_COPY, ©); // 触发：内核填充页表并唤醒 faulting 线程

工程价值：UFFD 在关键生产场景中的独特优势

八、缺页中断生产调优实战

8.1 识别缺页中断瓶颈

bash
# 1. 实时监控缺页中断率
vmstat 1
--------memory-- -----swap-- -----
  free  buff  cache   si   so
 ...

# 2. 每进程缺页中断统计
grep -E 'pswpin|pswpout|majflt|minflt' /proc/vmstat

# 3. Perf 工具精确计数
perf stat -e page-faults -e major-faults -e minor-faults -a sleep 10

# 4. FTrace 事件探针
echo 1 > /sys/kernel/debug/tracing/events/exceptions/page_fault_user/enable
echo 1 > /sys/kernel/debug/tracing/events/exceptions/page_fault_kernel/enable

8.2 关键调优参数

bash
# 1. fault-around 内核参数（预读页数量）
#    适用：顺序扫描（DuckDB Parquet 文件），增大会提升吞吐量
echo 256 > /sys/kernel/mm/fault_around_bytes

# 2. THP 透明大页
echo "madvise" > /sys/kernel/mm/transparent_hugepage/enabled
echo "defer" > /sys/kernel/mm/transparent_hugepage/defrag

# 3. 应用层调优（大型 OLAP 分析、pg_prewarm）
pg_prewarm('my_table');  // 手动将表页预加载到内存

# 4. Swap 调优（防止大规模 swap thrashing）
echo 10 > /proc/sys/vm/swappiness        // 降低 swappiness = 内存压力下减少 swap
echo 1 > /proc/sys/vm/compact_memory     // 触发内存碎片整理

# 5. NUMA 按节点内存调优
sysctl -w vm.zone_reclaim_mode=1         // NUMA 优化：强制本地节点回收

8.3 案例：ClickHouse 缺页中断调优

ClickHouse MergeTree 引擎在 OLAP 查询时会对合并数据文件执行大量随机读取，典型瓶颈栈：

查询 → 内存映射合并数据文件 → 随机 4KB 缺页中断 → 内核预读脏页 → 90% I/O 浪费

经过以下调整后：

bash
# 1. 最小化 fault-around（消除预读污染）
sysctl vm.fault_around_bytes=4096

# 2. 应用层使用 madvise 配合 hugepages（减少 TLB 未命中 512 倍）
madvise(addr, length, MADV_HUGEPAGE);

# 3. 使用 madvise 手动预取查询影响的所有区域
madvise(addr, length, MADV_WILLNEED);  // 内核异步预读

# 4. 使用 userfaultfd 协调快照加载
// 进程启动时不再 mmap+mlockall 1TB → 改用 UFFD 按需加载

效果：
- 查询 P99 延迟：850ms → 120ms（7.1 倍提升）
- 存储 I/O 浪费：88% → 3.2%
- 内存 RSS：1.2TB → 340GB

九、NUMA 平衡：缺页中断驱动的自动内存迁移

Linux 3.13 引入内核 NUMA 平衡，利用缺页中断方式检测并迁移需要移到本地 NUMA 节点的热页，核心机制：

c
// mm/memory.c
void task_numa_fault(unsigned long address, int node, int pages, int flags)
{
    // 1. 内核将 PTE 标记为 "NUMA hinting fault" → 设置隐藏的 "young" 位
    // 2. mprotect() 周期性批量扫描会清除 PTE 来跟踪访问模式
    // 3. 若发现页被本地进程访问但位于远端节点 → 触发迁移
    if (numa_migrate_prep(page, vma, address)) {
        migrate_misplaced_page(page, vma, address, node);
    }
}

与缺页中断的协同：在 do_anonymous_page 中，内核分配页时主动使用本地 NUMA 节点内存。已有页的热热度通过 task_numa_scan 周期性扫描 PTE 的硬件访问位来判断 —— 缺页中断产生的页面获得扫描优先级。这种"缺页中断 + 页表遍历 + 内存迁移"的多维协同设计，体现了 Linux 内核内存管理工程的综合实力。

十、总结：缺页中断工程的统一视角

缺页中断是连接虚拟内存理论与真实硬件执行的"最后一条关键路径"。深入这条路径，可得到四条工程启示：

1. 快速路径优先，慢速路径守卫：fixup_exception → find_vma → handle_mm_fault 三层快速决策树，为 90% 的场景守住快速执行

2. 零页复用，按需分配 + CoW：零页映射、PTE 级 CoW 等惰性策略通过结构性共享节约内存

3. 架构一致，快速路径专精：x86 CR2 快速读取 与 arm64 ESR 多比特解码，但在 __handle_mm_fault 层面统一 —— 架构抽象层应放在正确的位置

4. 硬软件协同设计：fault-around、THP 合成、NUMA 平衡均与硬件页表遍历器和 TLB 阴影深度耦合

在生产环境中，理解缺页中断路径能让内存密集型负载（数据库、AI 推理、大数据分析）的调优从"随机摸索"变为"有据可依" —— 多一次缓存未命中或不必要的同步原语都会被放大成 P99 延迟爆炸。从 entry_64.S:page_fault 到 memory.c:handle_pte_fault 的内核代码，值得每一个内存应用开发者反复研读和基准测试。