Linux 内存映射与文件缓存机制：从 mmap 到 Page Cache 的底层剖析

原创于 2026-06-15 11:16:32 发布 · 503 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#linux #系统内核 #嵌入式

Linux 内存映射与文件缓存机制：从 mmap 到 Page Cache 的底层剖析

一、文件 I/O 的性能瓶颈：为什么 read/write 不是最优解

Linux 系统中，传统的文件读写通过 read() 和 write() 系统调用完成。每次调用都需要将数据从内核缓冲区拷贝到用户空间（read）或从用户空间拷贝到内核缓冲区（write）。对于大文件或高频 I/O 场景，这种"两次拷贝"的开销不可忽视。

一个典型的性能瓶颈场景：Web 服务器处理静态文件请求。每个请求调用 read() 将文件数据从 Page Cache 拷贝到用户空间，再通过 write() 将数据从用户空间拷贝到 Socket 缓冲区。两次拷贝 + 两次上下文切换，对于一个 1MB 的文件，开销约 0.5ms。当 QPS 达到 10000 时，仅文件 I/O 的拷贝开销就占用了 5 秒 CPU 时间。

mmap()（内存映射）提供了一种绕过用户空间拷贝的方案：将文件直接映射到进程的虚拟地址空间，进程通过指针访问文件内容，无需 read()/write() 系统调用。数据从磁盘到 Page Cache 的加载由内核自动完成，进程只看到一块普通的内存区域。

但 mmap 不是万能的。它引入了新的复杂性：页面错误（Page Fault）的开销、信号处理（SIGBUS/SIGSEGV）、以及与 Page Cache 的交互机制。理解这些底层机制，才能正确使用 mmap。

二、mmap 与 Page Cache 的协作机制

mmap 的核心是将文件的磁盘块映射到进程的虚拟地址空间，而 Page Cache 是内核管理文件缓存的核心数据结构。两者的协作机制决定了 mmap 的性能特征。

flowchart TD
    A[进程虚拟地址空间] -->|访问 mmap 区域| B{Page Table 查找}
    B -->|命中| C[物理内存 Page Cache]
    B -->|未命中| D[Page Fault]
    D --> E[内核从磁盘读取数据]
    E --> F[写入 Page Cache]
    F --> G[更新 Page Table 映射]
    G --> C

    C --> H[进程直接读写物理内存]
    H -->|脏页标记| I[pdflush/kworker 异步回写]
    I --> J[写入磁盘]

    subgraph 内核空间
        C
        D
        E
        F
        G
        I
    end

    subgraph 用户空间
        A
        H
    end

    subgraph 磁盘
        K[文件数据块]
    end

    E --> K
    J --> K

Page Cache：Linux 内核将磁盘文件的内容缓存在物理内存中，以 Page（通常 4KB）为单位管理。每个 Page 对应文件的一个逻辑块。当进程通过 read() 或 mmap 访问文件时，内核先检查 Page Cache 中是否已有对应的数据。如果有，直接返回（缓存命中）；如果没有，从磁盘读取并写入 Page Cache（缓存未命中）。

mmap 映射过程：调用 mmap() 时，内核在进程的虚拟地址空间中分配一段区域，建立 VMA（Virtual Memory Area）结构体，但并不立即加载数据。Page Table 中对应的页表项标记为"不存在"。当进程首次访问这片区域时，触发 Page Fault，内核从 Page Cache 或磁盘加载数据，更新页表项，然后恢复进程执行。

脏页回写：通过 mmap 修改文件内容后，对应的 Page 被标记为"脏页"。内核的 pdflush/kworker 线程定期将脏页异步回写到磁盘。也可以通过 msync() 强制同步回写。

三、mmap 的生产级使用模式

3.1 文件映射读写

// mmap_file.c
// 使用 mmap 进行文件读写

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char *argv[]) {
    int fd;
    struct stat sb;
    char *mapped;

    // 第一步：打开文件
    fd = open("data.bin", O_RDWR);
    if (fd == -1) {
        perror("打开文件失败");
        exit(1);
    }

    // 第二步：获取文件大小
    if (fstat(fd, &sb) == -1) {
        perror("获取文件信息失败");
        close(fd);
        exit(1);
    }

    // 第三步：建立映射
    // MAP_SHARED: 修改会写回文件
    // MAP_PRIVATE: 修改不写回文件（写时复制）
    mapped = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE,
                  MAP_SHARED, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap 失败");
        close(fd);
        exit(1);
    }

    // 第四步：关闭文件描述符
    // mmap 建立后，fd 可以关闭，映射仍然有效
    // 因为内核通过 Page Cache 管理映射，不依赖 fd
    close(fd);

    // 第五步：通过指针直接读写文件内容
    // 读取前 16 字节
    printf("前 16 字节: %.16s\n", mapped);

    // 修改文件内容（直接写入映射区域）
    // 修改会被标记为脏页，由内核异步回写
    memcpy(mapped, "MODIFIED", 8);

    // 第六步：强制同步回写（可选）
    // MS_SYNC: 同步等待回写完成
    // MS_ASYNC: 异步回写，立即返回
    if (msync(mapped, sb.st_size, MS_SYNC) == -1) {
        perror("msync 失败");
    }

    // 第七步：解除映射
    if (munmap(mapped, sb.st_size) == -1) {
        perror("munmap 失败");
    }

    return 0;
}

3.2 大文件分片映射

// mmap_large_file.c
// 大文件分片映射，避免一次性占用过多虚拟地址空间

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define CHUNK_SIZE (100 * 1024 * 1024)  // 每次映射 100MB

int main(int argc, char *argv[]) {
    int fd = open("large_data.bin", O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        exit(1);
    }

    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("fstat 失败");
        close(fd);
        exit(1);
    }

    off_t file_size = sb.st_size;
    off_t offset = 0;

    // 分片映射处理大文件
    while (offset < file_size) {
        // 计算本次映射的大小
        size_t map_size = CHUNK_SIZE;
        if (offset + map_size > file_size) {
            map_size = file_size - offset;
        }

        // 映射当前分片
        // offset 必须是页面大小的整数倍
        char *chunk = mmap(NULL, map_size, PROT_READ,
                          MAP_PRIVATE, fd, offset);
        if (chunk == MAP_FAILED) {
            perror("mmap 分片失败");
            close(fd);
            exit(1);
        }

        // 处理当前分片的数据
        // 例如：计算校验和、搜索关键词等
        printf("处理分片: offset=%ld, size=%zu\n", offset, map_size);

        // 建议内核预读后续数据
        // MADV_SEQUENTIAL: 顺序访问模式，内核会激进预读
        // MADV_RANDOM: 随机访问模式，内核减少预读
        madvise(chunk, map_size, MADV_SEQUENTIAL);

        // 解除当前分片的映射
        munmap(chunk, map_size);

        offset += map_size;
    }

    close(fd);
    return 0;
}

3.3 Page Cache 监控与调优

# 查看 Page Cache 使用情况
cat /proc/meminfo | grep -E "Cached|Buffers|Dirty|Writeback"

# 查看指定文件的缓存命中情况
# 需要安装 linux-ftools
hpcache data.bin

# 手动释放 Page Cache（生产环境慎用）
# 1: 释放 Page Cache
# 2: 释放 dentries 和 inodes
# 3: 释放所有
echo 1 > /proc/sys/vm/drop_caches

# 调整脏页回写参数
# 脏页占比达到 10% 时开始异步回写
echo 10 > /proc/sys/vm/dirty_background_ratio
# 脏页占比达到 20% 时阻塞写入（强制回写）
echo 20 > /proc/sys/vm/dirty_ratio
# 脏页最大存活时间（30 秒后必须回写）
echo 3000 > /proc/sys/vm/dirty_writeback_centisecs

四、架构权衡与适用边界

mmap vs read/write 的选择。mmap 适用于随机访问大文件（如数据库、索引文件），避免了 read 的拷贝开销。但对于顺序读写小文件，mmap 的 Page Fault 开销可能超过 read 的拷贝开销。建议文件超过 1MB 且需要随机访问时使用 mmap。

MAP_SHARED vs MAP_PRIVATE。MAP_SHARED 的修改会写回文件，适用于多进程共享数据。MAP_PRIVATE 使用写时复制（COW），修改不影响原文件，适用于只读场景或需要独立修改的场景。

Page Cache 的竞争问题。mmap 和 read/write 共享同一个 Page Cache。当系统内存紧张时，Page Cache 中的数据可能被回收，导致后续访问触发 Page Fault。对于性能敏感的应用，可以通过 mlock() 锁定关键页面，防止被回收。

适用边界：mmap 适用于大文件随机访问、多进程共享内存、以及需要零拷贝传输的场景（如 Nginx 的 sendfile）。对于小文件顺序读写，传统的 read/write 更简单可靠。对于需要原子写入的场景（如数据库 WAL），mmap 的异步回写机制可能导致数据丢失，应使用 O_DIRECT + fsync。

五、总结

Linux 内存映射（mmap）通过将文件映射到进程虚拟地址空间，消除了 read/write 的用户空间拷贝开销。底层机制依赖 Page Cache 管理文件缓存，首次访问触发 Page Fault 加载数据，修改后通过脏页回写机制持久化。工程落地时，大文件应分片映射避免虚拟地址空间耗尽，使用 madvise 提示访问模式优化预读策略，通过 /proc/meminfo 监控 Page Cache 使用情况。mmap 适用于大文件随机访问和多进程共享，小文件顺序读写和原子写入场景应使用传统 I/O。