1
文件系统在做什么？—— 把「磁盘上的字节块」抽象为「用户看到的文件」。
2

3
物理层面：
4
  磁盘 = 一长串的扇区 (512B/4KB)
5
  「把第 4,823,001 个扇区开始的 1024 个扇区读出来」
6
  → 用户不关心扇区号
7

8
文件系统层面：
9
  磁盘 = 目录树 + 文件
10
  「打开 /game/textures/player.dds」
11
  → 路径名 → inode → 数据块映射 → 磁盘扇区
12

13
文件系统的三个核心职责：
14
  1. 命名：  路径名 → 文件标识 (inode)
15
  2. 映射：  文件偏移 → 磁盘块号
16
  3. 保护：  权限检查 (rwx)

1
五种 I/O 模型的完整对比（以读取网络数据为例）：
2

3
阶段划分：
4
  阶段1 = 等数据到达（内核缓冲区准备）
5
  阶段2 = 数据从内核拷贝到用户空间
6

7
┌────────────────┬─────────────────┬─────────────────┬──────────────┐
8
│ I/O 模型       │ 阶段1 (等待)     │ 阶段2 (拷贝)     │ CPU 利用率    │
9
├────────────────┼─────────────────┼─────────────────┼──────────────┤
10
│ 阻塞 I/O       │ 进程阻塞         │ 进程阻塞         │ 低            │
11
│ 非阻塞 I/O     │ 轮询(不阻塞)     │ 进程阻塞         │ 高(但浪费)    │
12
│ I/O 多路复用   │ select/epoll阻塞 │ 进程阻塞         │ 高(管理多连接) │
13
│ 信号驱动 I/O   │ 不阻塞(信号通知)  │ 进程阻塞         │ 高            │
14
│ 异步 I/O       │ 不阻塞            │ 不阻塞(内核完成) │ 最高           │
15
│ (io_uring)     │                  │                 │               │
16
└────────────────┴─────────────────┴─────────────────┴──────────────┘
17

18
关键洞察：
19
  前四种在阶段2都是阻塞的（数据必须拷贝到用户空间）
20
  只有真正的异步 I/O 两个阶段都不阻塞——内核完成所有工作才通知你

1
Page Cache：Linux 对文件数据的缓存机制。
2

3
当你 read() 一个文件时：
4
  1. 内核先查 Page Cache
5
  2. 命中 → 直接从内存返回（零磁盘 I/O）
6
  3. 未命中 → 从磁盘读入 Page Cache → 再返回
7

8
当 Page Cache 被修改了（写操作）：
9
  - 页面被标记为 Dirty
10
  - 不会立即写回磁盘（Write-Back 策略）
11
  - 内核线程 pdflush/flush 定期扫描 dirty 页并写回
12
  - 或者当脏页比例超过阈值（dirty_ratio, 默认 20%）时触发写回
13

14
Page Cache 的回收：
15
  - 系统内存不足时 → kswapd 回收干净页（直接丢弃）
16
  - 脏页 → 必须先写回才能回收
17
  - 回收策略：LRU 近似（两个链表：Active + Inactive）
18

19
为什么 Page Cache 对游戏重要？
20
  1. 热资源（UI 纹理、常驻音效）→ 常驻内存，利用 Page Cache
21
  2. 冷资源 → 读一次后 Page Cache 会自动回收
22
  3. 但是 —— 游戏引擎通常自己做缓存管理（Frame/Pool allocator）
23
     → 不希望 OS 的 Page Cache 占用宝贵内存
24
     → 用 O_DIRECT 或 madvise(MADV_DONTNEED) 管理

1
// fsync 与数据持久化
2
#include <fcntl.h>
3
#include <unistd.h>
4

5
void atomic_save() {
6
    int fd = open("save_data.json", O_WRONLY | O_CREAT, 0644);
7

8
    const char* data = R"({"level": 5, "hp": 100})";
9
    write(fd, data, strlen(data));
10

11
    // ⚠️ write() 返回后数据只在 Page Cache 中！还没到磁盘！
12
    // 如果此时断电 → 数据丢失
13

14
    fsync(fd);   // 强制将 Page Cache 中的 dirty 数据刷到磁盘
15
    // fdatasync(fd) 只刷数据不刷元数据（更快，但文件大小可能不更新）
16

17
    close(fd);
18
    // 现在数据才真正安全
19
}

1
传统 read + write（如文件服务器发送文件到网络）：
2

3
  read(fd, buf, len)
4
    → 磁盘 → DMA 拷贝 → 内核缓冲区 → CPU 拷贝 → 用户缓冲区 (buf)
5
  write(sock, buf, len)
6
    → 用户缓冲区 → CPU 拷贝 → Socket 缓冲区 → DMA 拷贝 → 网卡
7

8
  总计：4 次拷贝 + 4 次上下文切换 + 2 次系统调用
9

10
sendfile()：
11
  sendfile(sock, fd, nullptr, len)
12
    → 磁盘 → DMA 拷贝 → 内核缓冲区 → CPU 拷贝 → Socket 缓冲区 → DMA 拷贝 → 网卡
13

14
  总计：3 次拷�� (省了一次用户缓冲区拷贝)
15
        2 次上下文切换 + 1 次系统调用
16

17
sendfile() + DMA Gather (网卡支持 scatter-gather)：
18
  sendfile(sock, fd, nullptr, len)
19
    → 磁盘 → DMA 拷贝 → 内核缓冲区
20
    → 网卡 DMA 直接从内核缓冲区 + Socket 缓冲区拉取
21
    → 内核只传了文件描述符和长度信息给 Socket
22

23
  总计：2 次 DMA 拷贝！真正零 CPU 拷贝！
24
        2 次上下文切换 + 1 次系统调用
25

26
mmap + write：
27
  addr = mmap(nullptr, len, PROT_READ, MAP_PRIVATE, fd, 0)
28
    → 文件映射到用户空间（但数据仍在内核 Page Cache 中）
29
  write(sock, addr, len)
30
    → 直接从 Page Cache → Socket 缓冲区
31

32
  总计：3 次拷贝（仍有一次 CPU 拷贝）
33
        但可以省略用户缓冲区 → 省下了用户态内存

1
// 简化版游戏异步加载系统（基于 io_uring）
2
#include <liburing.h>
3
#include <functional>
4
#include <unordered_map>
5
#include <vector>
6

7
class AsyncAssetLoader {
8
    io_uring _ring;
9
    std::vector<char> _read_buffers;       // 预分配的读取缓冲区池
10
    std::unordered_map<uint64_t, std::function<void(std::vector<char>&)>> _callbacks;
11
    int _pending = 0;
12

13
public:
14
    AsyncAssetLoader(int queue_depth, size_t buffer_size) {
15
        io_uring_queue_init(queue_depth, &_ring, 0);
16

17
        // 预注册读取缓冲区（io_uring 5.5+ 的 fixed buffers）
18
        _read_buffers.resize(queue_depth * buffer_size);
19
    }
20

21
    // 异步加载资源
22
    void loadAsync(const std::string& path,
23
                   std::function<void(std::vector<char>&)> on_complete) {
24
        int fd = open(path.c_str(), O_RDONLY);
25

26
        auto* sqe = io_uring_get_sqe(&_ring);
27
        char* buf = &_read_buffers[_pending * BUFFER_SIZE];
28

29
        io_uring_prep_read(sqe, fd, buf, BUFFER_SIZE, 0);
30
        io_uring_sqe_set_data64(sqe, _pending);  // 把请求 ID 存进去
31

32
        _callbacks[_pending] = std::move(on_complete);
33
        _pending++;
34

35
        close(fd);  // 读请求提交后就可以关了
36
    }
37

38
    // 主循环中调用：收割完成的 I/O
39
    void pollCompletions() {
40
        io_uring_cqe* cqe;
41

42
        while (io_uring_peek_cqe(&_ring, &cqe) == 0) {
43
            uint64_t id = cqe->user_data;
44
            ssize_t bytes = cqe->res;
45

46
            if (bytes > 0) {
47
                std::vector<char> data(
48
                    &_read_buffers[id * BUFFER_SIZE],
49
                    &_read_buffers[id * BUFFER_SIZE] + bytes
50
                );
51
                _callbacks[id](data);  // 回调：主线程处理
52
            }
53

54
            _callbacks.erase(id);
55
            _pending--;
56
            io_uring_cqe_seen(&_ring, cqe);
57
        }
58
    }
59

60
    // 等待全部加载完
61
    void waitAll() {
62
        while (_pending > 0) {
63
            io_uring_cqe* cqe;
64
            io_uring_wait_cqe(&_ring, &cqe);
65
            // ... 同样的处理逻辑
66
        }
67
    }
68
};

1
为什么游戏不直接读散文件？
2

3
以一个 3A 游戏为例：
4
  散文件数量：~200,000+ 个
5
  每个文件打开需要：
6
    1. 路径解析 → 目录 dentry 查找（可能多次磁盘 I/O）
7
    2. inode 查找（磁盘 I/O）
8
    3. 权限检查
9

10
  200,000 次 open() → 大量磁盘寻道
11
  HDD 寻道 ~10ms × 200,000 = 2000 秒 ≈ 33 分钟！
12
  即使 SSD (~0.1ms 随机读) 也要 20 秒
13

14
打包方案（PAK / AssetBundle / Addressable）：
15
  → 所有资源打包进一个大文件
16
  → 打开一次 → 以后都在这个 fd 上 pread()
17
  → 资源定位 = 在包内的偏移 + 大小
18
  → 零额外寻道！

1
主流打包方案对比：
2

3
PAK 文件 (Unreal Engine)：
4
  ┌──────────────────────────────────────┐
5
  │ Header: 魔数 + 版本 + 索引偏移       │
6
  ├──────────────────────────────────────┤
7
  │ 文件数据块 1: /Game/Heroes/Knight.uasset  │
8
  │ 文件数据块 2: /Game/Heroes/Knight.uexp    │
9
  │ ...                                  │
10
  ├──────────────────────────────────────┤
11
  │ Index: 路径 → (偏移, 压缩大小, 原始大小)  │
12
  │  (在文件末尾，可选择性 mmap)          │
13
  └──────────────────────────────────────┘
14

15
  特点：可选压缩（zlib/lz4/oodle）、可选加密
16
       运行时索引常驻内存
17

18
AssetBundle (Unity)：
19
  每个 Bundle 是独立的文件
20
  优点：更灵活的加载和卸载（按场景/功能划分）
21
  缺点：多个 Bundle 间有重复资源时需要处理依赖
22

23
Addressable (Unity 新版)：
24
  更高级的抽象——不关心资源在哪个 Bundle
25
  按 Address 引用：LoadAssetAsync("Hero_Knight")
26
  系统自动处理依赖和下载

1
// 简化版虚拟文件系统
2
class VirtualFileSystem {
3
    struct FileEntry {
4
        uint64_t offset;      // 在 PAK 文件中的偏移
5
        uint64_t size_comp;   // 压缩后大小
6
        uint64_t size_orig;   // 原始大小
7
        uint32_t flags;       // 压缩算法 / 加密标志
8
    };
9

10
    int _pak_fd;  // PAK 文件的 fd（整个游戏只有一个！）
11
    std::unordered_map<std::string, FileEntry> _index;
12

13
public:
14
    bool mount(const std::string& pak_path) {
15
        _pak_fd = open(pak_path.c_str(), O_RDONLY);
16

17
        // 读取索引（通常在文件末尾）
18
        // ... 解析并填充 _index
19

20
        return true;
21
    }
22

23
    std::vector<char> readFile(const std::string& path) {
24
        auto& entry = _index.at(path);
25

26
        // 一次 pread（不改变 fd 的 offset，线程安全！）
27
        std::vector<char> compressed(entry.size_comp);
28
        pread(_pak_fd, compressed.data(), entry.size_comp, entry.offset);
29

30
        // 解压
31
        if (entry.flags & FLAG_ZLIB) {
32
            return zlibDecompress(compressed, entry.size_orig);
33
        }
34
        return compressed;
35
    }
36

37
    // mmap 大文件（如纹理）避免拷贝
38
    void* mapFile(const std::string& path, size_t& size) {
39
        auto& entry = _index.at(path);
40
        size = entry.size_comp;
41

42
        // 直接 mmap PAK 文件的对应区域
43
        // 利用 OS 的 Page Cache 和按需分页
44
        return mmap(nullptr, entry.size_comp,
45
                    PROT_READ, MAP_PRIVATE,
46
                    _pak_fd, entry.offset);
47
    }
48
};

1
存档的原子性保证 —— 三步法：
2

3
1. 写临时文件
4
   fd = open("save.sav.tmp", O_WRONLY | O_CREAT)
5
   write(fd, data, len)
6
   fsync(fd)           ← 关键！确保数据真正落到磁盘
7
   close(fd)
8

9
2. 写入校验信息
10
   fd = open("save.sav.sig", O_WRONLY | O_CREAT)
11
   write(fd, &checksum, sizeof(checksum))
12
   fsync(fd)
13
   close(fd)
14

15
3. 原子替换
16
   rename("save.sav.tmp", "save.sav")  ← rename 是原子的！
17
   rename("save.sav.sig", "save.sav.sig")
18

19
为什么 rename 是原子的？
20
  → POSIX 保证： rename() 要么成功（新旧 inode 交换），要么无变化
21
  → 不会出现「旧文件被删了新文件还没就位」的中间状态
22
  → 文件系统用 journal 保证 rename 的原子性
23

24
关键细节：
25
  ✅ 写临时文件 → fsync → rename（标准做法）
26
  ✅ 校验码独立存储（防止数据损坏被当作有效存档）
27
  ❌ 不要直接覆盖原文件（一旦崩溃 → 只写了一半）
28
  ❌ 不要省略 fsync（数据可能还在 Page Cache 中）
29
  ❌ 不要用 write + close + rename 但跳过 fsync

1
#include <crc32.h>  // 简化的 CRC32
2

3
class SaveSystem {
4
    static constexpr int MAX_BACKUPS = 3;
5

6
public:
7
    bool save(const std::string& slot_name, const std::vector<uint8_t>& data) {
8
        // 1. 计算校验码
9
        uint32_t checksum = crc32(data.data(), data.size());
10

11
        // 2. 写数据到临时文件
12
        std::string tmp_path = slot_name + ".tmp";
13
        if (!writeAndSync(tmp_path, data))
14
            return false;
15

16
        // 3. 写校验文件
17
        std::string sig_tmp = slot_name + ".sig.tmp";
18
        std::vector<uint8_t> sig_data(sizeof(checksum));
19
        memcpy(sig_data.data(), &checksum, sizeof(checksum));
20
        if (!writeAndSync(sig_tmp, sig_data))
21
            return false;
22

23
        // 4. 轮转备份（保留最近 3 个存档）
24
        for (int i = MAX_BACKUPS - 1; i >= 0; i--) {
25
            std::string old = slot_name + (i > 0 ? ".bak" + std::to_string(i) : "");
26
            std::string newer = slot_name + ".bak" + std::to_string(i + 1);
27
            if (access(old.c_str(), F_OK) == 0) {
28
                rename(old.c_str(), newer.c_str());
29
            }
30
        }
31
        rename(slot_name.c_str(), (slot_name + ".bak1").c_str());
32

33
        // 5. 原子替换（顺序重要！先数据后校验）
34
        rename(tmp_path.c_str(), slot_name.c_str());
35
        rename(sig_tmp.c_str(), (slot_name + ".sig").c_str());
36

37
        return true;
38
    }
39

40
    std::vector<uint8_t> load(const std::string& slot_name) {
41
        // 1. 读取数据
42
        auto data = readFile(slot_name);
43

44
        // 2. 验证校验码
45
        auto sig = readFile(slot_name + ".sig");
46
        if (sig.size() != sizeof(uint32_t))
47
            return {};  // 存档损坏
48

49
        uint32_t stored_checksum;
50
        memcpy(&stored_checksum, sig.data(), sizeof(uint32_t));
51

52
        uint32_t actual_checksum = crc32(data.data(), data.size());
53

54
        if (stored_checksum != actual_checksum)
55
            return {};  // 校验失败 → 尝试加载备份
56

57
        return data;
58
    }
59

60
private:
61
    bool writeAndSync(const std::string& path,
62
                      const std::vector<uint8_t>& data) {
63
        int fd = open(path.c_str(),
64
                      O_WRONLY | O_CREAT | O_TRUNC, 0644);
65
        if (fd < 0) return false;
66

67
        size_t written = 0;
68
        while (written < data.size()) {
69
            ssize_t n = write(fd,
70
                data.data() + written,
71
                data.size() - written);
72
            if (n < 0) { close(fd); return false; }
73
            written += n;
74
        }
75

76
        if (fsync(fd) < 0) { close(fd); return false; }
77
        close(fd);
78
        return true;
79
    }
80
};