// include/linux/mm_types.h:1142;1149;1256-1257
    unsigned long mmap_base;    /* base of mmap area */
    unsigned long task_size;    /* size of task vm space */
    ...
    unsigned long start_brk, brk, start_stack;
    unsigned long arg_start, arg_end, env_start, env_end;

低地址                                                                       task_size
 0   ┌─────────────┬───────┬──────────────┬──────────────────┬─────────┬──────┐
     │ text+rodata │ data  │ bss          │ brk 堆(向上)      │ (空洞)  │ mmap │
     │  代码/常量   │ 已初始化│ 零页按需      │                  │         │ 区   │
     └─────────────┴───────┴──────────────┴──────────────────┴─────────┴──┬───┘
                                                              mmap_base ^ │ v 向下分配
     ─────────────────────────────────────────────────────────────────────────────
                                        ┌──────────────┬──────────────┐
                                        │ 栈(向下生长)   │  arg/env 块   │ 顶部
                                        └──────────────┴──────────────┘
                                              ^ start_stack     task_size
 mmap_base 之下到 brk 之间的空档: MAP_FIXED 与库加载的战场

// arch/x86/mm/mmap.c:82-133（节选）
static unsigned long mmap_base(unsigned long rnd, unsigned long task_size,
                   const struct rlimit *rlim_stack)
{
    unsigned long gap = rlim_stack->rlim_cur;
    unsigned long pad = stack_maxrandom_size(task_size) + stack_guard_gap;

    /* Values close to RLIM_INFINITY can overflow. */
    if (gap + pad > gap)
        gap += pad;

    /*
     * Top of mmap area (just below the process stack).
     * Leave an at least ~128 MB hole with possible stack randomization.
     */
    gap = clamp(gap, SIZE_128M, (task_size / 6) * 5);

    return PAGE_ALIGN(task_size - gap - rnd);       /* :99 */
}

static unsigned long mmap_legacy_base(unsigned long rnd,
                      unsigned long task_size)
{
    return __TASK_UNMAPPED_BASE(task_size) + rnd;       /* :104 */
}

static void arch_pick_mmap_base(unsigned long *base, unsigned long *legacy_base, ...)
{
    *legacy_base = mmap_legacy_base(random_factor, task_size);
    if (mmap_is_legacy())
        *base = *legacy_base;
    else
        *base = mmap_base(random_factor, task_size, rlim_stack);    /* :119 */
}

void arch_pick_mmap_layout(struct mm_struct *mm, const struct rlimit *rlim_stack)
{
    if (mmap_is_legacy())
        mm_flags_clear(MMF_TOPDOWN, mm);        /* :125-130 */
    else
        mm_flags_set(MMF_TOPDOWN, mm);
    ...
}

// arch/x86/mm/mmap.c:77-79
unsigned long arch_mmap_rnd(void)
{
    return arch_rnd(mmap_is_ia32() ? mmap32_rnd_bits : mmap64_rnd_bits);
}

execve → load_elf_binary() 内:

 [1] 旧地址空间整体拆除 (exec_mmap 换新 mm)
 [2] 逐 PT_LOAD 段 mmap:
       text → MAP_PRIVATE|PROT_EXEC   (文件页, 只读共享)
       data → MAP_PRIVATE|PROT_WRITE  (COW: 原始页来自文件)
       bss  → 匿名零页 (VM_ACCOUNT)
       装配后 mm->start_brk/brk 定位 (heap 起点=end_data 对齐+随机)
 [3] setup_arg_pages() (fs/exec.c:598-722):
       把 argv/envp 从临时页搬到栈顶区
       建立栈 VMA (VM_GROWSDOWN), 记录 arg_start/end, env_start/end
       mm->start_stack 定位
 [4] arch_pick_mmap_layout() 已在更早的 mm 初始化时定下 mmap_base

布局退化实验 (只读观测, 无需改内核):

 setarch -R ./app     关闭 ASLR 运行
 cat /proc/self/maps  两次启动对比:
   ASLR on:  mmap 段基址每次不同 (22.1.3 节 28 位熵)
   ASLR off: 段基址固定 — 库/栈/堆全部可预测
 这一对比直观展示 top-down 布局 + 随机化的叠加关系

// include/linux/mm_types.h:913-980（节选）
struct vm_area_struct {
    /* The first cache line has the info for VMA tree walking. */

    union {
        struct {
            /* VMA covers [vm_start; vm_end) addresses within mm */
            unsigned long vm_start;     /* :919 */
            unsigned long vm_end;       /* :920 */
        };
        freeptr_t vm_freeptr; /* SLUB_TYPESAFE_BY_RCU 的释放指针 */
    };

    /*
     * The address space we belong to.
     * Unstable RCU readers are allowed to read this.
     */
    struct mm_struct *vm_mm;            /* :929 */
    pgprot_t vm_page_prot;          /* 本 VMA 的访问权限(PTE 模板) :930 */

    /*
     * Flags, see mm.h.
     * To modify use vm_flags_{init|reset|set|clear|mod} functions.
     */
    union {
        const vm_flags_t vm_flags;      /* :939 */
        vma_flags_t flags;
    };
    ...
    unsigned int vm_lock_seq;           /* :958 per-VMA 锁序号 */
    ...
    struct list_head anon_vma_chain; /* Serialized by mmap_lock & :966
                      * page_table_lock */
    struct anon_vma *anon_vma;  /* Serialized by page_table_lock :968 */

    /* Function pointers to deal with this struct. */
    const struct vm_operations_struct *vm_ops;  /* :971 */

    /* Information about our backing store: */
    unsigned long vm_pgoff;     /* 文件内偏移(页单位)  :974 */
    struct file * vm_file;      /* 映射的文件(可 NULL) :976 */
    void * vm_private_data;     /* 私有数据(共享内存用) :980 */
    ...
};

// include/linux/mm_types.h:1123-1260（节选）
struct mm_struct {
    ...
    atomic_t mm_count;      /* :1137 mm 本体引用(含 mm_users 折算 1) */
    struct maple_tree mm_mt;    /* :1140 VMA 索引: 按 vm_end 排的 maple tree */
    unsigned long mmap_base;    /* :1142 mmap 区边界 (22.1 节) */
    unsigned long task_size;    /* :1149 */
    pgd_t * pgd;            /* :1150 顶级页表 (19.2.3 节) */
    ...
    atomic_t mm_users;      /* :1171 使用者计数(线程/借 mm 者) */
    ...
    struct rw_semaphore mmap_lock;  /* :1196 全局地址空间写锁 */
    ...
    seqcount_t mm_lock_seq;     /* :1222 写锁代序号(per-VMA 锁协作) */
    unsigned long hiwater_rss;  /* :1235 RSS 高水位 */
    unsigned long total_vm;     /* :1238 已映射总页数 */
    ...
    vm_flags_t def_flags;       /* :1244 新 VMA 默认标志(如 VM_LOCKED) */
    unsigned long start_brk, brk, start_stack;      /* :1256 */
    unsigned long arg_start, arg_end, env_start, env_end;   /* :1257 */
    struct rlimit rlim_stack;   /* 栈上限 */
    ...
};

// mm/mmap.c:902-907
struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
{
    unsigned long index = addr;

    mmap_assert_locked(mm);
    return mt_find(&mm->mm_mt, &index, ULONG_MAX);
}
EXPORT_SYMBOL(find_vma);

maple tree vs 红黑树 (VMA 场景):

                红黑树 (旧)                maple tree (7.0)
 索引方式        按 vm_end 单点              按 [start, end) 区间
                find_vma(addr)=首个 end>addr
                再手查 start<=addr
 遍历            树游标, 每步 O(log n)        VMA_ITERATOR: 批量 walk,
                                           节点内多个槽位缓存友好
 fork            逐 VMA 复制+rebalance       树快照复制(maple 原生)
 RCU 读          支持                        原生支持 (mt_find 无锁路径)
 vma_iter       vma_iter_init/load/next     (mm/mmap.c:926-940 的
                 find_vma_prev 即用例)        find_vma_prev 用例)

// include/linux/mm_types.h:946-958（注释要点）
#ifdef CONFIG_PER_VMA_LOCK
    /*
     * vm_lock_seq: 可在 mmap_lock 写锁 + 特定位组合下用 WRITE_ONCE 修改;
     * 读者持 vm_lock.refcnt 或比对 vm_lock_seq 与 mm->mm_lock_seq 判断
     * "我这轮读到的 VMA 是否仍与写者视角一致"。
     * 序号显式允许回绕: 回绕最多导致偶发回退慢路径。
     */
    unsigned int vm_lock_seq;
#endif

读侧 (缺页) 快路径                    写侧 (mmap/munmap)

 拿 per-VMA 读锁(refcnt++)            拿 mmap_lock 写锁
  ├─ 若 VMA 正被写锁: 回退慢路径        mm->mm_lock_seq++ (奇偶翻转)
  ├─ 读 VMA 字段做缺页处理              改 VMA / 拆分 / 删除
  └─ 释放 refcnt                       遍历解锁所有读者(refcnt 清零)
                                       释放写锁
 一致性保证: 读者比对 vm_lock_seq != mm->mm_lock_seq
 说明写者动过 → 弃用本次结果回退慢路径 (mmap_lock 读锁重做)

// mm/mmap.c:335-470（节选）
unsigned long do_mmap(struct file *file, unsigned long addr,
            unsigned long len, unsigned long prot,
            unsigned long flags, vm_flags_t vm_flags,
            unsigned long pgoff, unsigned long *populate,
            struct list_head *uf)
{
    struct mm_struct *mm = current->mm;
    int pkey = 0;

    *populate = 0;
    mmap_assert_write_locked(mm);       /* 调用者已持写锁 */

    if (!len)
        return -EINVAL;

    /*
     * PROT_READ 是否隐含 PROT_EXEC?
     * (noexec 挂载的文件系统除外)
     */
    if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
        if (!(file && path_noexec(&file->f_path)))
            prot |= PROT_EXEC;
    ...
    /* Careful about overflows.. */
    len = PAGE_ALIGN(len);
    if (!len)
        return -ENOMEM;

    /* offset overflow? */
    if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
        return -EOVERFLOW;

    /* Too many mappings? */
    if (mm->map_count > sysctl_max_map_count)   /* 默认 65530 */
        return -ENOMEM;
    ...
    vm_flags |= calc_vm_prot_bits(prot, pkey) | calc_vm_flag_bits(file, flags) |
            mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;  /* :404 */

    /* 选址: 验证或挑选地址 */
    addr = __get_unmapped_area(file, addr, len, pgoff, flags, vm_flags);    /* :410 */
    if (IS_ERR_VALUE(addr))
        return addr;

    if (flags & MAP_FIXED_NOREPLACE) {
        if (find_vma_intersection(mm, addr, addr + len))
            return -EEXIST;
    }
    ...
}

// mm/vma.c:2729-2800（节选, __mmap_region 主体）
static unsigned long __mmap_region(struct file *file, unsigned long addr,
        unsigned long len, vm_flags_t vm_flags, unsigned long pgoff,
        struct list_head *uf)
{
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *vma = NULL;
    bool have_mmap_prepare = file && file->f_op->mmap_prepare;
    VMA_ITERATOR(vmi, mm, addr);
    ...
    error = __mmap_setup(&map, &desc, uf);
    if (!error && have_mmap_prepare)
        error = call_mmap_prepare(&map, &desc);
    if (error)
        goto abort_munmap;
    ...
    /* Attempt to merge with adjacent VMAs... */
    if (map.prev || map.next) {
        VMG_MMAP_STATE(vmg, &map, /* vma = */ NULL);
        vma = vma_merge_new_range(&vmg);        /* :2756 */
    }

    /* ...but if we can't, allocate a new VMA. */
    if (!vma) {
        error = __mmap_new_vma(&map, &vma);     /* :2761 */
        if (error)
            goto unacct_error;
        allocated_new = true;
    }
    ...
    __mmap_complete(&map, vma);
    return addr;
    ...
}

mmap_region 的执行序列:

 __mmap_setup()          冲突区拆除(munmap 语义) + 记账(VM_ACCOUNT)
      │
      ├─ f_op->mmap_prepare?   新式驱动钩子: 先描述后建 VMA
      │      (7.0 的 desc 化重构: 驱动不再直接摸 VMA 内部)
      v
 vma_merge_new_range()   能合并? prev/next 与新区间同权限同后备
      │                  且中间无洞 → 扩展旧 VMA, 免分配
      ├─ 合并成功 ────────────> 完成 (maple tree 原地改区间)
      v  不能
 __mmap_new_vma()        vm_area_alloc 分配 VMA (21 章 slab!)
      │                  f_op->mmap() 驱动初始化
      │                  vma_store 挂入 mm->mm_mt
      v
 __mmap_complete()       填充 populate(POPULATE_MAP 预触) / 统计

                MAP_PRIVATE                    MAP_SHARED
        ┌───────────────────────────┬────────────────────────────┐
 匿名   │ 普通 malloc/malloc'ed 大块  │ 共享匿名: fork 前建          │
 (无文件)│ vm_file=NULL, anon_vma 挂链 │ (MAP_SHARED|MAP_ANONYMOUS   │
        │ 写时复制到 swap(24 章)       │  + tmpfs 驱动 shmem)        │
        │                           │ 进程间真正共享页帧            │
        ├───────────────────────────┼────────────────────────────┤
 文件   │ 库/程序加载: 读走页缓存       │ 共享内存映射: 写回文件        │
 (有文件)│ 写触发 COW → 私有匿名副本    │ 脏页经回写落盘(36 章)        │
        │ 原文件页永远只读共享          │ msync/msync 语义            │
        └───────────────────────────┴────────────────────────────┘

 vm_file / anon_vma 的组合判别 (mm_types.h:959-963 注释):
   匿名 PRIVATE: anon_vma only          文件 PRIVATE+COW 后: 两者都挂
   文件 SHARED: i_mmap 树 only          brk/栈: anon_vma only (file=NULL)

munmap(start, len):
  mmap_write_lock
  do_vmi_align_munmap():
    ├─ 找覆盖区间的全部 VMA
    ├─ 端点切割: 区间部分重叠时把首尾 VMA 一分为二
    ├─ 从 maple tree 摘除命中 VMA (批量 detach)
    ├─ zap_page_range: 清 pte + 刷 TLB (19.5 节 mmu_gather)
    │    匿名页引用减、文件页减映射
    └─ RCU/引用时序释放 VMA 结构

fork + exec 的时间账:

 立即完成 (微秒级):
   fork:   复制 mm_struct + maple tree 快照 + 页表页 (复制 pte 而非页!)
           全部 pte 标只读 (COW 预埋)
   exec:   拆旧分区表, 建 3-5 个 VMA, 搬参数页
 延迟完成 (按访问):
   第 1 条指令  → text 文件页缺页 → 页缓存供货
   第 1 次写栈  → 栈匿名页缺页   → 伙伴系统供货
   第 1 次写 data → COW 缺页     → 复制新页
   malloc 大块   → brk/mmap 只建 VMA
   逐页触碰      → 逐页缺页供货  (mmap POPULATE 可选择提前全付)

// arch/x86/mm/fault.c:1207（签名与主流程要点）
void do_user_addr_fault(struct pt_regs *regs,
            unsigned long error_code,
            unsigned long address)
{
    ...
    /* 1. 快速过滤: SMAP/SMEP、NX、内核地址误入等 → SIGSEGV 直达 */
    ...
    /* 2. 找 VMA (per-VMA 锁快路径) */
    vma = lock_vma_under_rcu(mm, address);
    if (likely(vma)) {
        /* VMA 就位且未被并发改动: 直接进入 handle_mm_fault */
        ...
        goto handle;
    }
    /* 3. 回退: mmap_lock 读锁 + find_vma 重来 (22.2.4 节协议) */
    ...
handle:
    fault = handle_mm_fault(vma, address, flags, regs);
    ...
}

// mm/memory.c:6286 与 4484-4490（节选）
static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
{   /* :6286 */
    ...
    if (!vmf->pte)
        return do_pte_missing(vmf); /* pte 为空: 缺页 */
    ...
    if (vmf->flags & FAULT_FLAG_WRITE) {
        if (!pte_write(entry))
            return do_wp_page(vmf); /* 写只读 pte: COW 判定 */
        entry = pte_mkdirty(entry);
    }
    ...
}

// mm/memory.c:4484-4490
static vm_fault_t do_pte_missing(struct vm_fault *vmf)
{
    if (vma_is_anonymous(vmf->vma))
        return do_anonymous_page(vmf);  /* 匿名: 分配零页 */
    else
        return do_fault(vmf);       /* 文件/设备: vm_ops->fault */
}

handle_pte_fault 的判别矩阵:

 pte 状态  ×  访问           匿名 VMA                 文件 VMA
 ─────────────────────────────────────────────────────────────────
 pte 空      读              do_anonymous_page         do_fault →
             写              (零页/COW 预埋)            vm_ops->fault
                                                     (文件页入缓存)
 pte 在但只读  写            do_wp_page:                同左, 但
             (COW 预埋/换出/  单映射直接改写;            先重取文件页
              mprotect 效果)  多映射复制新页              再判定
 pte 在且可写  写            只需置 dirty/accessed 位 (软缺页, 零分配)
 pte 是 swap 槽  任意          do_swap_page: 从交换区换回 (24 章)
 pte 是 marker  任意          userfaultfd/PTE marker 专用路径

// mm/memory.c:5230（要点）
static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
{
    ...
    /* 首次读且页可整体零页化: 映射共享 zero page, 零成本 */
    if (pte_alloc(vmf->vma->vm_mm, vmf->pmd))
        ...
    /* 分配物理页 */
    folio = vma_alloc_zeroed_movable_folio(vmf->vma, vmf->address); /* 18.3 节 */
    if (!folio)
        return VM_FAULT_OOM;
    /* anon_vma 记账 + 页表映射 */
    ...
    entry = mk_pte(page, vma->vm_page_prot);
    entry = pte_sw_mkyoung(entry);
    if (write) {
        entry = maybe_mkwrite(pte_mkdirty(entry), vmf->vma);    /* 只读预埋 */
        ...
    }
    ...
}

// mm/memory.c:5350（__do_fault 要点）
static vm_fault_t __do_fault(struct vm_fault *vmf)
{
    ...
    ret = vma->vm_ops->fault(vmf);      /* 分发到后备实现 */
    ...
}

路径                        量级 (现代 x86, 粗略)
───────────────────────────────────────────────────────
软缺页 (补 accessed/dirty)   ~0.2-0.5μs
硬缺页-匿名 (分配+映射)       ~1-3μs
硬缺页-文件 (页缓存命中)      ~1-2μs
硬缺页-文件 (需读盘)          ~100μs-数 ms  (SSD/HDD)
swap-in (zswap 命中)         ~10-50μs (解压)
swap-in (真读盘)             ~100μs-数 ms
MGLRU look_around 摊派        接近零 (邻居批量分代)

设计含义:
 - 异常本身 (进入/退出/查 VMA) 是固定税 → 热路径优化
   都在压这段 (per-VMA 锁 22.2.4、CR2 读取 25.1.2)
 - 命中页缓存的文件缺页已接近"免费" → mmap I/O 的
   优势区间 (36 章对照)
 - 磁盘 IO 的 100 倍落差是回收策略 (24 章) 的一切
   — 把 IO 型缺页挡在稳态之外

// mm/vma.c:3184-3240（节选）
int expand_downwards(struct vm_area_struct *vma, unsigned long address)
{
    struct mm_struct *mm = vma->vm_mm;
    ...
    if (!(vma->vm_flags & VM_GROWSUP))
        return -EFAULT;     /* 只对栈类 VMA 放行 */
    ...
    mmap_assert_write_locked(mm);

    /* Guard against exceeding limits of the address space. */
    address &= PAGE_MASK;
    if (address >= (TASK_SIZE & PAGE_MASK))
        return -ENOMEM;
    address += PAGE_SIZE;

    /* Enforce stack_guard_gap */
    gap_addr = address + stack_guard_gap;

    /* Guard against overflow */
    if (gap_addr < address || gap_addr > TASK_SIZE)
        gap_addr = TASK_SIZE;

    next = find_vma_intersection(mm, vma->vm_end, gap_addr);
    if (next && vma_is_accessible(next)) {
        ...
        /* 不能撞进别的可访问映射 */
    }
    ...
    if (unlikely(anon_vma_prepare(vma)))
        return -ENOMEM;
    ...
    error = acct_stack_growth(vma, size, grow); /* 五道检查 */
    ...
    /* 通过后: vm_start 下移, 补建 pte */
}

// mm/vma.c:3059-3086（节选, 五道检查）
static int acct_stack_growth(struct vm_area_struct *vma,
                 unsigned long size, unsigned long grow)
{
    struct mm_struct *mm = vma->vm_mm;
    unsigned long new_start;

    /* 1. address space limit tests */
    if (!may_expand_vm(mm, vma->vm_flags, grow))
        return -ENOMEM;

    /* 2. Stack limit test */
    if (size > rlimit(RLIMIT_STACK))
        return -ENOMEM;

    /* 3. mlock limit tests */
    if (!mlock_future_ok(mm, vma->vm_flags & VM_LOCKED, grow << PAGE_SHIFT))
        return -ENOMEM;

    /* 4. 不得长进 hugetlb 专属区 */
    new_start = (vma->vm_flags & VM_GROWSUP) ? vma->vm_start :
            vma->vm_end - size;
    if (is_hugepage_only_range(vma->vm_mm, new_start, size))
        return -EFAULT;

    /*
     * 5. Overcommit.. 最后测, 因为它要更新安全统计
     */
    if (security_vm_enough_memory_mm(mm, grow))
        return -ENOMEM;

    return 0;
}

// mm/mmap.c:116-200（节选）
SYSCALL_DEFINE1(brk, unsigned long, brk)
{
    unsigned long newbrk, oldbrk, origbrk;
    struct mm_struct *mm = current->mm;
    struct vm_area_struct *brkvma, *next = NULL;
    unsigned long min_brk;
    ...
    min_brk = mm->start_brk;
#ifdef CONFIG_COMPAT_BRK
    /*
     * CONFIG_COMPAT_BRK can still be overridden by setting
     * randomize_va_space to 2, which will still cause mm->start_brk
     * to be arbitrarily shifted
     */
    if (!current->brk_randomized)
        min_brk = mm->end_data;
#endif
    if (brk < min_brk)
        goto out;

    /*
     * Check against rlimit here...
     */
    if (check_data_rlimit(rlimit(RLIMIT_DATA), brk, mm->start_brk,
                  mm->end_data, mm->start_data))
        goto out;

    newbrk = PAGE_ALIGN(brk);
    oldbrk = PAGE_ALIGN(mm->brk);
    if (oldbrk == newbrk) {
        mm->brk = brk;
        goto success;
    }

    /* Always allow shrinking brk. */
    if (brk <= mm->brk) {
        /* Search one past newbrk */
        vma_iter_init(&vmi, mm, newbrk);
        brkvma = vma_find(&vmi, oldbrk);
        if (!brkvma || brkvma->vm_start >= oldbrk)
            goto out; /* mapping intersects with an existing non-brk vma. */
        ...
        mm->brk = brk;
        if (do_vmi_align_munmap(&vmi, brkvma, mm, newbrk, oldbrk, &uf,
                    /* unlock = */ true))
            ...
    }
    ...
    ret = do_brk_flags(&vmi, vma, addr, len, vm_flags); /* :1236 扩张 */

brk 的两种流向:

 增长:  mm->brk ──页对齐──> do_brk_flags()                  vma.c:2874
        ├─ 堆 VMA 已存在且可扩: 直接推进 vm_end (等价一次 merge)
        ├─ 否则新建 brk VMA (匿名, VM_ACCOUNT)
        └─ 只改分区表, 不供货 (页后到, 22.4 节)

 收缩:  mm->brk ──> do_vmi_align_munmap() 拆掉 [newbrk, oldbrk)
        ├─ 释放对应页帧 (清 pte + mmu_gather 刷 TLB)
        └─ brk VMA 相应回缩或消失

 两条越界防线:
   brk < start_brk            不许低于堆底
   RLIMIT_DATA (check_data_rlimit)  数据总量配额

小分配 (glibc 默认 < MMAP_THRESHOLD, 动态 128KB):
  brk 堆内切分 (ptmalloc arena)
  → 内核视角: 一次 brk 扩张, 之后零系统调用
  → free 不还内核 (arena 保留), RSS 稳态高

大分配 (≥ MMAP_THRESHOLD):
  每次 mmap 一个匿名段, free 即 munmap
  → 内核视角: 大量 VMA 创建/销毁 (map_count 压力)
  → 释放立即可见 (RSS 回落), 但每块多两次系统调用 + TLB 刷新
  → 阈值动态调节: 频繁 munmap 的大块会抬高阈值 (避免抖动)

 内核侧的对应观测:
   /proc/pid/smaps 的匿名段分布
   mm->map_count / sysctl_max_map_count 配额 (22.3.1 节)
   brk VMA 与匿名 mmap VMA 在 smaps 中可用地址区分