M5: 存储层次抽象与内存治理

48-bit 规范地址:
┌───────────────────────────────────────────────────────────────┐
│  0x0000000000000000 ~ 0x00007FFFFFFFFFFF  用户空间 (低 128TB)  │
├───────────────────────────────────────────────────────────────┤
│  0x0000800000000000 ~ 0xFFFF7FFFFFFFFFFF  非规范区域 (禁止)     │
├───────────────────────────────────────────────────────────────┤
│  0xFFFF800000000000 ~ 0xFFFFFFFFFFFFFFFF  内核空间 (高 128TB)  │
└───────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                     操作系统 (低地址)                            │
├─────────────────────────────────────────────────────────────────┤
│  进程 A: 100KB                                                  │
├─────────────────────────────────────────────────────────────────┤
│  空闲: 50KB                                                     │
├─────────────────────────────────────────────────────────────────┤
│  进程 B: 200KB                                                  │
├─────────────────────────────────────────────────────────────────┤
│  空闲: 150KB                                                    │
├─────────────────────────────────────────────────────────────────┤
│  进程 C: 80KB                                                   │
├─────────────────────────────────────────────────────────────────┤
│  空闲: 大量                                                      │
└─────────────────────────────────────────────────────────────────┘

// Slab API 示例
struct kmem_cache *my_cache = kmem_cache_create("my_struct", sizeof(struct my_struct), ...);
struct my_struct *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);
kmem_cache_free(my_cache, obj);
kmem_cache_destroy(my_cache);

64-bit PTE:
┌─────────────────────────────────────────────────────────────────────┐
│ 63  │ 62-52  │ 51-12           │ 11-8 │ 7 │ 6 │ 5 │ 4 │ 3 │ 2 │ 1 │ 0 │
│ NX  │ 可用    │ 物理页帧号 (PFN) │ AVL  │ PS│ D │ A │PCD│PWT│U/S│R/W│ P │
└─────────────────────────────────────────────────────────────────────┘

标志位:
P (Present)      : 页是否在内存中
R/W (Read/Write) : 0=只读, 1=可读写
U/S (User/Supervisor) : 0=仅内核, 1=用户可访问
PWT (Page Write-Through) : 写穿透缓存
PCD (Page Cache Disable) : 禁用缓存
A (Accessed)     : 已被访问 (用于页面置换)
D (Dirty)        : 已被写入 (用于写回)
PS (Page Size)   : 在 PD 中表示 2MB 大页
NX (No Execute)  : 禁止执行 (需 CPU 支持)

// arch/x86/include/asm/pgtable_types.h

typedef struct { unsigned long pte; } pte_t;    // Page Table Entry
typedef struct { unsigned long pmd; } pmd_t;    // Page Middle Directory
typedef struct { unsigned long pud; } pud_t;    // Page Upper Directory
typedef struct { unsigned long p4d; } p4d_t;    // Page 4-level Directory
typedef struct { unsigned long pgd; } pgd_t;    // Page Global Directory

// 页表遍历宏
pgd = pgd_offset(mm, addr);
p4d = p4d_offset(pgd, addr);
pud = pud_offset(p4d, addr);
pmd = pmd_offset(pud, addr);
pte = pte_offset_map(pmd, addr);

启用条件:
- CPU 支持 (CPUID.7.0:ECX.LA57 = 1)
- 内核配置 CONFIG_X86_5LEVEL=y
- 引导参数 (默认启用)

层级: PML5 → PML4 → PDPT → PD → PT
每级 9-bit 索引, Offset 12-bit

// 单页失效
invlpg(addr);

// 全局刷新
// x86: 重新加载 CR3

// 跨 CPU 失效 (IPI)
flush_tlb_mm(mm);
flush_tlb_range(vma, start, end);
flush_tlb_page(vma, addr);

TLB 条目包含 PCID 标签
切换进程时更换 PCID 而非刷新 TLB
不同 PCID 的条目可共存

// arch/x86/mm/fault.c
dotraplinkage void do_page_fault(struct pt_regs *regs, 
                                  unsigned long error_code,
                                  unsigned long address)
{
    struct vm_area_struct *vma;
    struct mm_struct *mm = current->mm;
    
    // 1. 检查是否在内核态发生
    if (unlikely(fault_in_kernel_space(address)))
        return do_kern_addr_fault(regs, error_code, address);
    
    // 2. 查找 VMA
    vma = find_vma(mm, address);
    if (unlikely(!vma)) {
        // 非法访问
        return bad_area_nosemaphore(regs, error_code, address);
    }
    
    // 3. 处理缺页
    fault = handle_mm_fault(vma, address, flags, regs);
    
    // 4. 根据结果处理
    if (fault & VM_FAULT_OOM)
        pagefault_out_of_memory();
}

// mm/memory.c
static vm_fault_t do_wp_page(struct vm_fault *vmf)
{
    struct page *old_page = vmf->page;
    
    // 检查是否是唯一引用
    if (reuse_swap_page(old_page, ...)) {
        // 可以直接复用
        wp_page_reuse(vmf);
        return VM_FAULT_WRITE;
    }
    
    // 需要复制
    new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, ...);
    cow_user_page(new_page, old_page, vmf->address, vma);
    
    // 更新页表指向新页
    set_pte_at_notify(mm, vmf->address, vmf->pte, entry);
    
    return VM_FAULT_WRITE;
}

// mm/vmscan.c
static unsigned long shrink_page_list(struct list_head *page_list, ...)
{
    while (!list_empty(page_list)) {
        page = lru_to_page(page_list);
        
        // 检查页面是否可回收
        if (PageWriteback(page))
            continue;  // 正在写回
        
        if (PageDirty(page)) {
            // 脏页需要先写回
            pageout(page, mapping);
            continue;
        }
        
        // 尝试解除映射
        if (page_mapped(page)) {
            if (!try_to_unmap(page, ttu_flags))
                continue;  // 仍有引用
        }
        
        // 回收页面
        __remove_mapping(mapping, page);
        free_page(page);
    }
}

如果分配的内存 < 工作集大小:
  → 频繁缺页 (Page Fault)
  → 大量 I/O (swap)
  → CPU 利用率下降
  → 这就是抖动 (Thrashing)

Order: 页数
0:     1 页   (4KB)
1:     2 页   (8KB)
2:     4 页   (16KB)
...
10:    1024 页 (4MB)

分配 5 页:
1. 没有 order-2 (4页) 可用的
2. 分裂 order-3 (8页) 为两个 order-2
3. 返回一个 order-3 (8页) [有内部碎片]

释放时:
1. 检查伙伴块是否空闲
2. 是则合并为更大的块

cat /proc/buddyinfo
# Node 0, zone   Normal   1289  790  568  371  200  143   51   12    8    2   38
#                          ^    ^    ^    ^    ^    ^    ^    ^    ^    ^    ^
# Order:                  0    1    2    3    4    5    6    7    8    9   10

                    物理页
                       │
        ┌──────────────┼──────────────┐
        │              │              │
  进程 A 的 PTE   进程 B 的 PTE   进程 C 的 PTE
  (地址 0x1000)  (地址 0x5000)  (地址 0x9000)

如何从物理页找到这些 PTE?

// include/linux/rmap.h

// 匿名页: anon_vma 链表
struct anon_vma {
    struct rb_root rb_root;  // 红黑树存储 VMA
};

// 文件页: address_space 的优先搜索树
struct address_space {
    struct radix_tree_root page_tree;
    struct rb_root i_mmap;  // VMA 树
};

// 遍历所有映射
int try_to_unmap(struct page *page, ...) {
    if (PageAnon(page))
        rmap_walk_anon(page, rwc);    // 匿名页
    else
        rmap_walk_file(page, rwc);    // 文件页
}

# 查看 NUMA 拓扑
numactl --hardware

# 绑定进程到指定节点
numactl --membind=0 --cpunodebind=0 ./myprogram

# 查看内存分布
numastat

// 内存分配标志
GFP_KERNEL      // 可能从任意节点分配
__GFP_THISNODE  // 仅从当前节点分配
GFP_KERNEL | __GFP_THISNODE // 本地优先

// per-CPU 变量自动本地分配
DEFINE_PER_CPU(struct data, mydata);

// mm/oom_kill.c
unsigned long oom_badness(struct task_struct *p, ...) {
    // 基础分数 = 进程内存使用量 (RSS + swap)
    points = mm->rss + mm->swap_usage;
    
    // 根据 oom_score_adj 调整
    // oom_score_adj: -1000 ~ 1000
    // -1000: 禁止杀死
    // 0: 默认
    // 1000: 优先杀死
    
    adj = (long)p->signal->oom_score_adj;
    if (adj == OOM_SCORE_ADJ_MIN)  // -1000
        return 0;  // 不杀
    
    points += points * adj / 1000;
    
    return points;
}

# 查看进程的 oom_score
cat /proc/$PID/oom_score

# 设置 oom_score_adj (-1000 到 1000)
echo -500 > /proc/$PID/oom_score_adj

# 禁止被杀死 (谨慎使用)
echo -1000 > /proc/$PID/oom_score_adj

传统 swap:
内存页 → 写入磁盘 (慢)

zram:
内存页 → 压缩 → 存储在内存 (快)

# 创建 zram 设备
modprobe zram num_devices=1
echo lz4 > /sys/block/zram0/comp_algorithm
echo 4G > /sys/block/zram0/disksize
mkswap /dev/zram0
swapon /dev/zram0

# 启用
echo 1 > /sys/module/zswap/parameters/enabled
echo lz4 > /sys/module/zswap/parameters/compressor
echo z3fold > /sys/module/zswap/parameters/zpool

# 查看进程的 smaps (详细)
cat /proc/$(pidof myapp)/smaps | grep -E "^(Rss|Pss|Private)"

# 使用 smem 工具
smem -p
#  PID User     Command        Swap      USS      PSS      RSS
# 1234 root     nginx           0    12288    15360    32768

$ free -h
              total        used        free      shared  buff/cache   available
Mem:          7.7G        1.5G        3.2G        120M        3.0G        5.9G

┌─────────────────────────────────────────────────────────────────────────┐
│                     kswapd 异步回收流程                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  内存分配请求                                                            │
│       ↓                                                                 │
│  检查 Zone 水位                                                          │
│       ↓                                                                 │
│  ┌─────────────────────────────────────────────────────────────────┐   │
│  │                                                                  │   │
│  │  high ──────────────────────────────────────────────────────     │   │
│  │           (安全区域)                                             │   │
│  │  low  ─────────────────────────────── ← kswapd 开始工作          │   │
│  │           (kswapd 工作区)                                        │   │
│  │  min  ─────────────────────────────── ← Direct Reclaim 触发      │   │
│  │           (紧急区域)                                             │   │
│  │  0    ──────────────────────────────────────────────────────     │   │
│  │                                                                  │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                                                                         │
│  kswapd 特点:                                                          │
│  - 后台内核线程                                                          │
│  - 异步执行, 不阻塞用户进程                                               │
│  - 每个 NUMA node 一个 kswapd                                            │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

内存分配 (alloc_pages)
       ↓
检查可用内存
       ↓ (不足)
┌──────────────────────────────────────────────────────────────────┐
│  Direct Reclaim (同步阻塞)                                        │
│                                                                   │
│  1. 当前进程被迫参与回收                                           │
│  2. 扫描 LRU 链表寻找可回收页                                       │
│  3. 写回脏页 / 交换匿名页                                          │
│  4. 直到分配成功或触发 OOM                                         │
│                                                                   │
│  ★ 这是应用延迟抖动的主要原因!                                     │
└──────────────────────────────────────────────────────────────────┘
       ↓
分配成功 或 OOM Kill

# 查看水位
cat /proc/zoneinfo | grep -E "Node|zone|min|low|high"

# 调整 min_free_kbytes (增加 min 水位)
sysctl vm.min_free_kbytes=262144  # 256MB

# 调整脏页触发阈值
sysctl vm.dirty_background_ratio=5   # kswapd 开始刷脏页
sysctl vm.dirty_ratio=10             # 进程阻塞刷脏页

# 脏页相关参数
vm.dirty_background_ratio=5   # 脏页占比超 5% 时后台刷盘
vm.dirty_ratio=10             # 脏页占比超 10% 时阻塞写入
vm.dirty_expire_centisecs=3000  # 脏页存活 30 秒后必须刷盘
vm.dirty_writeback_centisecs=500  # 每 5 秒唤醒一次刷盘线程

逻辑地址 (段选择子:偏移)
       ↓ 段基地址 = 0 (平坦模型)
线性地址 = 偏移
       ↓ 分页机制
物理地址

48-bit 虚拟地址 → 2^36 个 4KB 页
每个 PTE 8 字节 → 512GB 页表空间 (理论上限)

即使多级页表, 大地址空间仍然浪费

┌─────────────────────────────────────────────────────────────────────────┐
│                     反置页表 (Inverted Page Table)                       │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  传统页表: 每个进程一个, 按虚拟页号索引                                    │
│  ┌───────────────────────────────────────────────────────────┐          │
│  │  VPN 0 → PFN 5                                            │          │
│  │  VPN 1 → PFN 8                                            │          │
│  │  ...                                                      │          │
│  │  VPN 2^36 → ???  (大多数无效)                              │          │
│  └───────────────────────────────────────────────────────────┘          │
│                                                                         │
│  反置页表: 全局一个, 按物理页帧号索引                                      │
│  ┌───────────────────────────────────────────────────────────┐          │
│  │  PFN 0 → (PID, VPN)                                       │          │
│  │  PFN 1 → (PID, VPN)                                       │          │
│  │  ...                                                      │          │
│  │  PFN N → (PID, VPN)    N = 物理内存页数                    │          │
│  └───────────────────────────────────────────────────────────┘          │
│                                                                         │
│  优势: 表项数 = 物理页数 (远小于虚拟页数)                                  │
│  缺点: 需要哈希查找, TLB Miss 开销大                                      │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                      LRU 二阶段判断机制                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│                    新页进入                                              │
│                       ↓                                                 │
│              ┌───────────────┐                                          │
│              │  Inactive     │                                          │
│              │  List         │                                          │
│              └───────┬───────┘                                          │
│                      │ 第二次访问                                        │
│                      ↓ (PG_referenced)                                  │
│              ┌───────────────┐                                          │
│              │  Active       │ ←──── 晋升 (Promotion)                   │
│              │  List         │                                          │
│              └───────┬───────┘                                          │
│                      │ 内存压力                                          │
│                      ↓ (引用位清零)                                       │
│              ┌───────────────┐                                          │
│              │  Inactive     │ ←──── 降级 (Demotion)                    │
│              │  List 尾部    │                                          │
│              └───────┬───────┘                                          │
│                      │                                                  │
│                      ↓                                                  │
│                   回收                                                   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

# 预留 1024 个 2MB 大页
echo 1024 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

# 内核参数
hugepages=1024

# 查看状态
cat /sys/kernel/mm/transparent_hugepage/enabled
# [always] madvise never

# 对某些工作负载可能引发延迟抖动
echo madvise > /sys/kernel/mm/transparent_hugepage/enabled

┌─────────────────────────────────────────────────────────────────────────┐
│                         KSM 工作原理                                     │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  虚拟机 A        虚拟机 B        虚拟机 C                                 │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐                             │
│  │ 内核页面 │    │ 内核页面 │    │ 内核页面 │                             │
│  │ (相同)  │    │ (相同)  │    │ (相同)  │                             │
│  └────┬────┘    └────┬────┘    └────┬────┘                             │
│       │              │              │                                   │
│       └──────────────┴──────────────┘                                   │
│                      │                                                  │
│                      ↓ KSM 合并                                         │
│              ┌───────────────┐                                          │
│              │  单一物理页   │                                          │
│              │  (COW 保护)   │                                          │
│              └───────────────┘                                          │
│                                                                         │
│  优势: 虚拟化场景下显著节省内存                                           │
│  代价: CPU 开销 (扫描和比较)                                             │
└─────────────────────────────────────────────────────────────────────────┘

传统 read() + send():
┌──────┐    ①    ┌──────┐    ②    ┌──────┐    ③    ┌──────┐    ④    ┌──────┐
│ 磁盘  │ ───→  │Page  │ ───→  │用户  │ ───→  │Socket│ ───→  │ 网卡  │
│      │ DMA   │Cache │ CPU   │Buffer│ CPU   │Buffer│ DMA   │      │
└──────┘        └──────┘        └──────┘        └──────┘        └──────┘

问题: 4 次拷贝, 4 次上下文切换

// sendfile 示例
sendfile(socket_fd, file_fd, NULL, file_size);
// 数据直接从 Page Cache 到网卡缓冲区

# 查看 CXL 设备
cxl list

# 使用 daxctl 管理 CXL 内存
daxctl list

# 将 CXL 内存配置为系统 RAM (memory tiering)
daxctl reconfigure-device --mode=system-ram dax0.0

# 查看 NUMA 节点 (CXL 会作为独立节点)
numactl -H

# 配置内存分层策略
echo 1 > /sys/kernel/mm/numa/demotion_enabled

# 查看分层统计
cat /sys/devices/system/node/node*/vmstat | grep -E "pgpromote|pgdemote"

#define _GNU_SOURCE
#include <sys/mman.h>
#include <sys/syscall.h>
#include <unistd.h>

int main() {
    // 创建 secret memory fd
    int fd = syscall(SYS_memfd_secret, 0);
    if (fd < 0) {
        perror("memfd_secret not supported");
        return 1;
    }
    
    // 设置大小
    ftruncate(fd, 4096);
    
    // 映射到进程地址空间
    void *secret = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                        MAP_SHARED, fd, 0);
    
    // 存储敏感数据 (如加密密钥)
    memcpy(secret, "SECRET_KEY_DATA", 16);
    
    // 使用后清理
    memset(secret, 0, 4096);
    munmap(secret, 4096);
    close(fd);
    return 0;
}

# 检查内核支持
grep CONFIG_SECRETMEM /boot/config-$(uname -r)

# 运行时检查
dmesg | grep -i secretmem

# 需要内核 5.14+ 且启用 CONFIG_SECRETMEM=y