5 持久化

持久化解决的是:数据在程序结束、机器断电之后仍然存在。

与虚拟化和并发不同,持久化面对的核心难题是崩溃(crash)——写数据的过程中断电,磁盘上会留下一个"半写"的状态。

I/O 设备:标准模型

┌──────────────┐
│     CPU      │
└──────┬───────┘
       │ 总线(PCIe)
┌──────┴────────────────────────┐
│           设备                 │
│  ┌────────────────────────┐   │
│  │  状态寄存器(可读)      │   │  设备当前状态:忙/就绪/出错
│  │  命令寄存器(可写)      │   │  CPU 下发命令
│  │  数据寄存器(读写)      │   │  数据交换
│  │  设备内部缓冲区 / 固件   │   │
│  └────────────────────────┘   │
└───────────────────────────────┘

标准交互协议(轮询版):

1. CPU 反复读状态寄存器,直到设备是 READY(忙等)
2. CPU 把数据写进数据寄存器
3. CPU 把命令写进命令寄存器(启动操作)
4. CPU 反复读状态寄存器,直到设备完成或是 ERROR

轮询的代价:等设备的几毫秒里,CPU 全在空转。所以实际用中断:

1. CPU 下发命令
2. CPU 去干别的(调度其他进程)
3. 设备完成 → 发中断
4. CPU 的 ISR 处理结果、唤醒等待的进程

中断让 CPU 和 I/O 并行工作,这是多道程序设计的原始动机之一。

中断 vs DMA 的分工

  • 中断解决"CPU 不用等"
  • DMA解决"CPU 不用搬"

最优组合(现代设备都用):CPU 设置好 DMA 描述符 → 设备自己把数据搬进内存 → 完成后中断一次。整个过程 CPU 只参与开头和结尾。

磁盘

机械硬盘(HDD)的几何结构

     ┌─── 主轴(7200 RPM 等)
     │
╔════╪════════════════╗
║  ╭─┴─────────────╮  ║  盘片(多个,双面可用)
║  │  ╭─────────╮  │  ║
║  │  │  磁道    │  │  ║  一圈圈同心圆
║  │  │  ┌────┐  │  ║
║  │  │  │扇区 │  │  ║  磁道被切成扇区(512B / 4KB)
║  │  │  └────┘  │  ║
║  │  ╰─────────╯  │  ║
║  ╰───────────────╯  ║
║      ↑ 磁臂          ║
╚══════╪══════════════╝
       └─ 磁头(每个盘面一个)

访问一个扇区的时间:

TI/O=Tseek+Trotation+TtransferT_{I/O} = T_{seek} + T_{rotation} + T_{transfer}

项含义典型值
寻道TseekT_{seek}磁臂移到目标磁道3~10 ms(最慢)
旋转TrotationT_{rotation}等目标扇区转到磁头下平均半圈 ≈ 4 ms(7200 RPM)
传输TtransferT_{transfer}实际读写几十~几百 μs

结论:随机 I/O 的代价几乎全在寻道和旋转上。顺序 I/O 比随机 I/O 快 100 倍以上(HDD 上)。

磁盘调度

目标:最小化寻道时间。

算法做法评价
SSTF(最短寻道优先)每次选离当前磁头最近的请求快,但可能饿死远处请求
SCAN(电梯算法)磁头单向扫到底,再反向公平性好(现代磁盘多用此)
C-SCAN单向扫描,到底后直接跳回起点(不服务回程)更均匀的响应时间
LOOK / C-LOOKSCAN 的优化:不到物理尽头,到最远的请求就折返实际使用的版本

为什么不用 SSTF:虽然有最短平均寻道,但边缘磁道可能被无限期推迟。SCAN 牺牲一点平均性能换取公平性。

现代 OS 把调度交给设备自己(磁盘有更准确的几何信息),OS 层只做合并和排序(I/O scheduler 如 mq-deadline、bfq)。

SSD(固态硬盘)

没有机械部件,随机访问和顺序访问差不多快。

HDDSSD
随机读~10 ms~0.1 ms(快 100 倍)
顺序读~200 MB/s~500 MB/s - 7 GB/s(NVMe)
随机 vs 顺序差 100 倍基本一样
寿命无写入次数限制有(每个块可擦写次数有限)
写入单位扇区 512B/4KB页 4KB 写,块 256KB 擦

SSD 的特殊性

先擦后写:不能直接覆盖,必须先擦除(块级,比写大得多)。

写放大(Write Amplification):逻辑上写 4KB,实际可能擦除并重写 256KB → 放大 64 倍。

FTL(Flash Translation Layer):固件里的"磁盘→闪存"映射层,负责:

  • 逻辑块地址 → 物理页的映射
  • 磨损均衡(Wear Leveling):把写入分散到不同块,避免某块先坏
  • 垃圾回收(GC):回收含无效页的块

TRIM:OS 告诉 SSD"这些块我不要了",让 SSD 提前回收,避免写时才擦(大幅降低写放大)。

# 查看 TRIM 支持
lsblk --discard
# 手动触发
fstrim -av
# 启用定期 TRIM
systemctl enable fstrim.timer

后果:SSD 上"删除文件不立即释放空间",且填满会显著变慢(GC 压力大)。建议留 10~20% 空闲(over-provisioning)。

RAID

用多块盘换取容量、性能、可靠性的不同组合。

级别方式容量冗余性能
RAID 0条带化(数据分块分存)N×无读写都快
RAID 1镜像1×可坏 1 块读快,写慢(要写两份)
RAID 5条带 + 分布式奇偶校验(N-1)×可坏 1 块读快,小写慢(要读改写校验)
RAID 6双奇偶校验(N-2)×可坏 2 块写更慢
RAID 10RAID 1 + RAID 0N/2×每组可坏 1 块读写都好

选择建议:

  • 性能优先、数据可重建 → RAID 0(缓存、临时数据)
  • 可靠性优先、盘不多 → RAID 1 / RAID 10
  • 容量与冗余平衡 → RAID 5(但大容量盘重建时间很长,重建期间再坏一块就全完,现代大容量盘推荐 RAID 6)

RAID 不是备份:它防硬盘故障,不防误删除、勒索软件、机房火灾。

文件系统

两个核心抽象

抽象作用
文件(File)一个命名的字节数组,有元数据(大小、权限、时间戳)
目录(Directory)一个特殊的"文件",内容是 (名字, inode 号) 的列表

目录树从根目录 / 开始,层层指向,形成树。

inode

**inode(index node)**是文件的元数据容器,不含文件名。

struct inode {
    mode_t   mode;        // 类型(文件/目录/设备/符号链接)+ 权限
    uid_t    uid, gid;    // 所有者
    off_t    size;        // 大小(字节)
    time_t   atime, mtime, ctime;   // 访问/修改/状态变更时间
    nlink_t  nlink;       // 硬链接数
    blkcnt_t blocks;      // 占用的块数
    // 数据块指针 ← 关键
};

文件名存在目录项里,不在 inode 里。这就是为什么:

  • 硬链接:两个目录项指向同一个 inode,完全等价,删一个不影响另一个(nlink 减 1,到 0 才真正删除)
  • 符号链接:一个特殊文件,内容是另一个路径。原文件删了它就成"悬空链接"
ls -i            # 看 inode 号
stat file        # 看完整 inode 信息
ln a b           # 硬链接(同一 inode)
ln -s a c        # 符号链接(新 inode,内容是 "a")

多级索引:inode 怎么指向数据块

文件可能从几字节到几 TB,inode 大小固定,怎么存指针?

经典(ext2/ext3)方案——多级索引:

inode 里有 15 个指针(4 字节/个,4KB 块):

[0..11]   直接指针        12 × 4KB = 48 KB
[12]      一级间接        指向一个块,块里全是数据块指针
                          → 1024 个指针 × 4KB = 4 MB
[13]      二级间接        → 1024 × 1024 × 4KB = 4 GB
[14]      三级间接        → 1024 × 1024 × 1024 × 4KB = 4 TB

权衡:小文件(绝大多数)用直接指针,一次访问就能定位;大文件用间接,多几次磁盘访问但能覆盖很大范围。

ext4 的改进——extent:不用逐个块记指针,而是记录连续区间 (起始块, 长度)。

ext2: 一个 1GB 文件需要 256K 个块指针
ext4: 一个 1GB 连续文件只需要几个 extent

extent 对大文件 + 顺序访问是巨大优化,也减少了元数据大小。

目录组织

目录本身是一个文件,内容是目录项列表:

目录 /home:
  ┌──────────┬────────┐
  │ name     │ ino    │
  ├──────────┼────────┤
  │ alice    │ 12345  │
  │ bob      │ 12399  │
  │ .        │ 100    │   ← 自己
  │ ..       │ 2      │   ← 父目录
  └──────────┴────────┘

. 和 .. 就是普通目录项,所以 cd .. 不需要特殊逻辑。

大目录的线性查找很慢。ext4 用 HTree(B 树变种)给目录项建索引,NTFS 用 B 树。这就是为什么"一个目录里放 10 万个文件"在某些文件系统上会极慢。

空闲空间管理

要分配新块,得知道哪些块空闲。

方法结构特点
位图(Bitmap)每块 1 bit省空间,容易找连续空闲块。ext/NTFS 都用它
空闲链表链表串起空闲块简单,但找连续块困难
B 树按块号索引的树大文件系统上高效(XFS、btrfs)

路径查找

open("/home/alice/a.txt") 的过程:

1. 从根目录的 inode(通常是 inode 2)开始
2. 读根目录的数据块,找到 "home" → 得到 inode 号
3. 读 home 的 inode,检查权限,读它的数据块,找到 "alice" → inode 号
4. 读 alice 的 inode,检查权限,读数据块,找到 "a.txt" → inode 号
5. 读 a.txt 的 inode,检查权限,创建 fd 返回

每级目录至少一次磁盘 I/O。这就是"路径越深越慢",也是**目录项缓存(dcache)**存在的原因——Linux 缓存路径→inode 的映射,命中时完全不用读盘。

符号链接会引入额外查找,且成环的符号链接会导致 ELOOP。

崩溃一致性

核心问题:一次文件操作要修改多个磁盘块(inode、数据块、位图、目录项)。写到一半断电,磁盘就处于不一致状态。

例:创建文件要写 4 处

  1. inode 位图(标记已用)
  2. inode 本身(填元数据)
  3. 目录项(把名字加进目录)
  4. 目录 inode(更新大小/时间)

只写了 1 和 2 就断电 → 出现一个"分配了但从没被引用"的 inode(空间泄漏)。 先写 3 后写 2 → 目录项指向一个未初始化的 inode(严重,可能读别人的数据)。

方案一:fsck(文件系统检查)

崩溃后,重启时扫描整个文件系统修复。

  • 检查:inode 引用数对不对、块有没有被重复引用、目录结构是否成环…
  • 问题:太慢(TB 级磁盘要几十分钟到几小时),而且无法保证修复正确(有些情况只能靠猜)

现代系统基本只把它当最后的兜底。

方案二:日志(Journaling / WAL)

先写日志,再改数据。ext3/ext4、NTFS、XFS 都用这个(源自数据库)。

1. 把要做的修改写成"日志项",写进磁盘的日志区(顺序写,快)
2. 写一个"提交记录"(Tx Begin / Tx End)
3. 真正的写回:把修改应用到文件系统的实际位置(**可以延后,可以乱序**)
4. 确认完成后,标记日志项可复用(checkpoint)

崩溃恢复:
  - 日志里有提交记录 → 重放(redo)这些修改
  - 没有提交记录 → 丢弃,当作没发生过

关键:日志文件只能追加,且顺序写——比随机写快得多。

模式记录什么安全性性能
Journal(全日志 / data journaling)数据 + 元数据最高最慢(数据写两遍)
Ordered(默认)只记元数据,保证数据先于元数据落盘高好
Writeback只记元数据,不保证顺序中(可能出现垃圾数据)最好

ext4 默认 ordered:元数据记日志,但通过写屏障保证数据块在元数据提交前落盘。这样既避免了"元数据指向未初始化的数据",又不用把数据写两遍。

fsync 的作用:强制把该文件的所有修改(含日志)刷到磁盘。数据库必须正确调用 fsync,否则断电会丢事务。

int fd = open("data.db", O_RDWR);
write(fd, buf, n);
fsync(fd);          // 关键!没有这个,数据可能还在页缓存里

方案三:写时复制(Copy-on-Write)

不修改旧数据,写新位置,然后原子地切换根指针。

ZFS / btrfs / APFS:

1. 复制要修改的块到新位置
2. 修改副本
3. 更新父节点的指针(递归向上,直到根)
4. **原子地**切换超级块里的根指针(一次写)

优点:

  • 崩溃后要么全是旧的、要么全是新的,天然一致
  • 顺便实现了快照(保留旧根就行,几乎免费)

缺点:

  • 递归向上更新父指针,写放大
  • 会加重碎片(数据不断搬到新位置)

页缓存与缓冲

磁盘比内存慢 5~6 个数量级,所以 OS 用大量内存做缓存。

read(fd, buf, n):
  1. 查页缓存:命中 → 直接拷贝给用户,不用碰磁盘
  2. 未命中 → 发 I/O 请求,读盘,填进缓存,再拷贝

write(fd, buf, n):
  1. 写进页缓存,标记"脏"(dirty)
  2. **立即返回**(不等落盘!)
  3. 后台线程(writeback)在合适时机刷盘

这就是"write-back 缓存":写操作看起来极快,因为只写了内存。

需要显式刷盘的场景

fsync(fd);                    // 刷该文件的数据 + 元数据
fdatasync(fd);                // 只刷数据(不刷时间戳等元数据,更快)
sync();                       // 刷所有
msync(addr, len, MS_SYNC);    // 刷 mmap 区域
open(..., O_SYNC);            // 每次 write 都同步落盘(慢很多)

缓存的代价

  • 掉电丢数据:页缓存里还没刷的会丢。数据库的 WAL + fsync 就是为此
  • dirty_ratio:脏页占比过高时会触发同步回写,导致写入延迟尖刺。可调 vm.dirty_background_ratio(后台开始刷的阈值)和 vm.dirty_ratio(强制同步的阈值)
sysctl -a | grep dirty
# vm.dirty_background_ratio = 10   ← 脏页超 10% 后台开始刷
# vm.dirty_ratio = 20              ← 超 20% 阻塞写入进程强制刷

调小可以减少延迟尖刺(但增加总体 I/O 次数),这是数据库调优的常见手段。

mmap:绕过 read/write

void *p = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
p[0] = 'x';        // 直接改内存,OS 负责回写
msync(p, len, MS_SYNC);
munmap(p, len);

优点:省去用户态↔内核态的数据拷贝(read 要拷两次:磁盘→内核缓冲→用户缓冲)。 缺点:缺页开销、难以控制刷盘时机、出错时是 SIGBUS 而不是返回错误码。

数据库(如 LMDB、RocksDB 的部分场景)常用 mmap 提升性能。

现代文件系统

文件系统特点
ext4Linux 默认,稳定成熟,extent + journal
XFS大文件/高并发好,B 树组织,RHEL 默认
btrfsCoW、快照、校验和、RAID 内建,但稳定性争议
ZFSCoW、快照、端到端校验、压缩,功能最全(许可证问题使其未进 Linux 主线)
NTFSWindows,journal、ACL、压缩、加密
APFSApple,CoW、快照、克隆,为 SSD 优化
F2FS为闪存设计的日志结构文件系统(Android 用)

常见坑

  • 忘记 fsync:程序正常退出但断电丢数据。数据库、日志、配置都必须 fsync
  • 在容器/虚拟机里断电语义更复杂:guest 的 "落盘" 可能只是落到 host 的页缓存
  • 以为 write 返回成功就安全了:只是进了页缓存
  • SSD 填满变慢:需要 TRIM 和预留空间
  • O_DIRECT 不保证元数据落盘:只绕过数据缓存,元数据仍走日志。要配合 O_SYNC 或 fsync
  • 大量小文件:每个文件至少 1 个 inode + 1 个块,且目录查找慢。打包成一个大文件通常更快
  • 符号链接成环:ln -s a b; ln -s b a → ELOOP
  • RAID 5 在大容量盘上的重建风险:8TB 盘重建要十几小时,期间再坏一块数据全丢。大容量盘用 RAID 6 或 RAID 10
  • 删除大文件时以为立刻释放:如果有进程还打开着这个文件,空间不会释放(lsof | grep deleted 可以看到)