一个配置文件写入服务,逻辑很简单:读旧内容、改一个字段、写回原文件。上线后偶尔出现配置文件变成 0 字节,服务重启直接起不来。日志里没有任何异常,write 也返回了成功。开发坚持说代码没问题,运维坚持说磁盘没问题,最后发现是机器在一次写入过程中掉电了。

“写文件”这三个字,藏着好几层缓冲。程序调用写入,数据先进入应用自己的缓冲区,再进入操作系统的页缓存,最后由文件系统和磁盘决定什么时候真正落到介质上。任何一层没走完,掉电都可能丢数据。这篇就把这条链路走一遍,顺便解释 fsync、close、rename 各自到底保证了什么。

现象:write 成功了,文件却是空的

很多人以为 write 返回成功,数据就已经在磁盘上。不是。大多数情况下,write 只是把数据交给了操作系统的页缓存,并登记为“脏页”。页缓存是内存,掉电就没了。操作系统会在后台找机会把脏页刷回磁盘,但那是异步的,时间不确定。

更隐蔽的是应用层缓冲。很多语言的标准库写入函数会先在进程内攒一批数据,够了一定数量才调用系统写入。你看到的一次“写成功”,可能连页缓存都还没进。

所以“文件变空”不一定是写入逻辑没执行,也可能是执行了、但数据还停在某一层缓冲里。要判断,得知道每一层的边界和刷新方式。

场景走查:一次写入经过的几层

把一次文件写入拆成五步。不同系统、不同库的细节有差异,但顺序基本一致。

从一次写入到数据落盘
应用缓冲语言运行时先在内存里攒数据,够一批才往下交
系统调用调用写入接口,把数据交给内核
页缓存数据进入内核缓存,标记为脏页,等待回写
块设备层文件系统把页转成块,排队发给磁盘控制器
介质磁盘或闪存真正写入,完成持久化

第一步完全在进程内,掉电必丢,进程崩溃也丢。第二步跨过用户态和内核态,数据所有权转移到内核。第三步之后,数据至少在内存里,进程崩溃通常不会丢,但机器掉电会丢。第四步和第五步才涉及真正的持久化。

这也解释了为什么“写完立刻读”通常能读到:读路径会先查页缓存,数据还在内存里。它解释不了“换一台机器读不到”或者“断电后文件为空”,因为那两层根本没有数据。

顺序写入的性能之所以好,是因为页缓存把很多小写入合并成大块,再一次性发给磁盘。代价是写入返回得太快,让人误以为已经安全。数据库和日志系统之所以反复调用同步接口,就是不愿意接受这份“太快”。

文件系统怎么组织:名字、inode 和数据块

文件系统要回答三个问题:文件叫什么、元数据在哪、内容存在哪些块。以常见的 Unix 系结构为例,名字和内容是分开的。

目录项把文件名映射到一个 inode 编号。目录本身也是一份特殊文件,里面存着一张名字表。
inode记录文件的元数据:类型、权限、大小、时间戳、数据块的位置。它不记录文件名。
数据块真正存内容的地方。大文件用多级指针或 extent 描述,不一定连续。
超级块与位图记录整个文件系统的布局、哪些块和 inode 已用、哪些空闲。

这种设计的直接后果是:同一个 inode 可以挂多个文件名,这就是硬链接;文件名改了,inode 不变;删除一个文件名,只是删掉目录项并把 inode 的引用计数减一,只有引用计数归零,数据块才真正释放。

Windows 的 NTFS 也用类似的分层,只是术语不同:文件记录、属性、数据流。它支持多个数据流,所以一个文件可以有主内容之外的附加数据。跨平台迁移文件时,这些差异会造成元数据丢失,不能假设“复制过去就完全一样”。

数据块的记录方式也在演进。早期文件系统用指针数组,一个文件要维护很多块地址,大文件光索引就占不少空间;现代文件系统多用 extent,用“起始块加长度”描述一段连续区域,一个文件只需要少量记录。extent 减少了元数据开销,也让连续读写更容易合并。代价是空间分配更复杂,碎片整理和快照实现都要多考虑一层。

路径解析:从 /a/b/c 到真正的数据

打开一个文件时,系统要逐段解析路径。先找到根目录的 inode,读根目录的内容,找到 a 对应的 inode,再读 a 的内容,找 b,一直到最后一段。每一段都可能触发磁盘读取,所以深层路径的第一次打开并不便宜。系统会缓存最近用过的目录项和 inode,后续打开就快很多。

路径里的符号链接是另一层间接。系统读到链接标记后,会替换成目标路径继续解析,最多允许若干层,防止循环。硬链接没有这层间接,它直接指向同一个 inode,所以删除原文件名不会影响另一个名字。

这也解释了“文件明明删了,空间还在”:如果有进程还打开着这个文件,inode 的引用计数没有归零,数据块就不会释放。Unix 上可以删除一个正在被写入的日志文件,进程继续写,空间继续占,直到进程关闭。用 lsof 能看到标记为 deleted 的打开文件。这个行为在清理日志时经常被忽略。

打开文件这件事本身也有成本。系统要为每个打开的文件维护一张表项,记录当前读写位置、访问模式和引用计数;进程再通过文件描述符指向这张表。多个进程打开同一个文件,表项可能不同,但底下的 inode 是同一份。文件描述符是有限的,长期不关会泄漏;更麻烦的是,泄漏的描述符还占着 inode,让删除后的空间迟迟回不来。

实测:flush 和 fsync 到底谁在起作用

用 Python 做一个最小实验:写 1000 字节,先不刷新,观察文件大小;再刷新,观察变化;然后写第二批,只调用同步接口但不刷新应用缓冲,最后关闭文件再看。

import os
path = os.path.join(os.environ["TEMP"], "flush-test.bin")
f = open(path, "wb")
f.write(b"x" * 1000)
print("after 1000, before flush:", os.path.getsize(path))
f.flush()
f.write(b"y" * 1000)
os.fsync(f.fileno())
print("after fsync without flush:", os.path.getsize(path))
f.close()
print("after close:", os.path.getsize(path))

本机 Python 3.15 实际输出:

after 1000, before flush: 0
after fsync without flush: 1000
after close: 2000

第一行说明,写入 1000 字节后,文件对外仍然是 0,因为数据还在 Python 自己的缓冲区里。第二行说明,只调用 fsync 而不先 flush,同步的是已经交给内核的那部分,应用缓冲里新写的 1000 字节并没有下去。第三行说明,关闭文件会触发刷新,两批数据才都到位。

这个实验把两层缓冲分得很清楚:flush 负责把应用缓冲交给内核,fsync 负责把内核里的脏数据刷到介质。顺序错了,或者只做其中一个,都不能保证持久化。fsync 在 Python 里作用于文件描述符,不会替你清空 Python 的缓冲区,这是很多人踩过的坑。

fsync、close、rename 各自保证什么

fsync 的语义是:把这个文件的数据和必要的元数据刷到持久介质,返回成功表示已经落盘。它通常很慢,因为要等磁盘确认。fdatasync 只保证数据,不保证不影响读取的元数据,适合日志类写入。close 只是释放文件描述符,不保证落盘,很多系统在关闭时也不会自动同步。

原子替换是另一个常见需求:写配置文件时,不能直接覆盖原文件,否则写到一半崩溃就留下半个文件。标准做法是写一个临时文件,刷新并同步,然后用 rename 替换目标。同一文件系统内的 rename 通常是原子的,外部看到的要么是旧文件,要么是新文件,不会看到中间态。

但 rename 本身也要考虑持久化。某些系统上,rename 的目录项变更也需要同步,否则掉电后可能回到旧名字。严格的实现会在 rename 之后再同步一次父目录。不同文件系统和挂载选项的行为不完全一样,涉及关键数据时要查清楚,拿不准就按“多同步一次”处理。

Windows 上的对应接口是刷新文件缓冲,语义和 fsync 接近,但同样不负责清空语言运行时自己的缓冲区。关闭句柄也不保证数据已经落盘。跨平台代码如果直接照搬 Unix 的“写完 close 就算完”,在两边都可能遇到掉电丢数据,只是触发条件不同。

崩溃一致性:日志、写时复制和检查

文件系统最怕的是写到一半掉电:数据块写了一半,元数据也写了一半,谁也不知道哪些是有效的。日志式文件系统(journaling)先把即将修改的元数据写进日志区,确认日志完整后再应用到正式位置。崩溃恢复时重放日志,把没做完的操作补完或丢弃。

写时复制文件系统走另一条路:不覆盖旧块,而是把新内容写到新块,最后原子地切换指针。旧数据在切换前一直有效,所以崩溃后总能回到某个一致状态。代价是写入会放大,空间回收也更复杂。

无论哪种方案,都只能保证文件系统结构一致,不保证你的业务数据一定完整。数据库会在文件系统之上再做自己的日志和校验,原因就在这里。应用层如果只依赖文件系统的原子性,而不设计自己的提交顺序,仍然可能在崩溃后读到“结构没坏但内容不对”的文件。

还有一种兜底手段是离线检查。日志能处理大多数突然掉电,但如果日志本身损坏、硬件出现坏块、元数据被外部工具改坏,就需要完整扫描文件系统,核对空闲位图、目录树和块引用。这个过程很慢,通常只在挂载失败或定期维护时做。它不是日常方案,不能拿来替代日志和备份。

现象对照表

现象真实原因第一步查什么
write 返回成功,掉电后文件是空的数据还在页缓存,没有同步到介质检查写入后是否调用了同步接口,顺序是否正确
写了内容,另一个进程立刻读不到数据还在应用缓冲区,没交给内核检查是否 flush,读方是否打开了同一路径
fsync 之后文件大小仍不变只同步了已交给内核的部分,应用缓冲没刷新先 flush 再 fsync,或换用无缓冲写入
配置文件偶尔变成 0 字节直接覆盖写,崩溃时留下半成品改成临时文件加同步加原子 rename
删除了大文件,磁盘空间没回来还有进程打开着该文件,inode 引用未归零用 lsof 或资源监视器找打开该文件的进程
目录里文件不多,但空间占用很大小文件太多,块和元数据开销占比高看 inode 使用率和平均文件大小,不只看总容量
rename 之后掉电,文件回到旧名字目录项变更没有同步到介质rename 后同步父目录,确认文件系统语义
写入很慢,磁盘利用率却不高每次写都同步,等待磁盘确认,批量优势没了看同步调用频率,合并写入或降低同步次数

边界与代价

同步写入安全,但慢。每次同步都要等介质确认,机械盘是毫秒级,闪存也远慢于内存。高频日志如果每条都同步,吞吐会被拖垮。现实做法通常是批量提交:攒一批记录,一次同步,用业务上可接受的少量丢失换吞吐。丢多少、能不能接受,是业务决策,不是技术默认值。

不同文件系统的保证程度不一样。本地 ext4、XFS、NTFS 各有自己的日志策略和挂载选项;网络文件系统还要多一层协议和缓存,语义更弱。把这些当成“都一样”,跨环境迁移时就会出问题。关键写入要按最弱的那一层设计。

另一个代价是空间管理的复杂性。薄 provision、快照、压缩、去重都会让“剩余空间”这个数字变得不直观。删除文件没释放,可能不是文件系统坏了,而是快照还引用着旧块,或者存储层在做垃圾回收。排查要先确认存储类型,再看文件层。

闪存介质还有自己的账。闪存不能原地覆盖,必须先擦除整块再写,所以文件系统会做磨损均衡和垃圾回收。频繁的小写入会触发写放大:你只写了几 KB,底层可能搬动了几 MB。删除文件后,还要靠修剪指令告诉闪存哪些块真的没用了,否则垃圾回收会一直背着旧数据跑。这些都不是文件系统能单独解决的,需要介质、驱动和文件系统配合。

把这几层想清楚,再遇到“文件写不进去”或“空间对不上”,就不会一上来就怀疑磁盘坏了。先确认数据在哪一层、哪一层的规则没有满足,排查范围会小很多。

当天能自己验证的练习

  1. 运行上面的 Python 实验,把 1000 字节改成 100 字节和 10 MB,观察 flush 前后的文件大小差异。
  2. 写一个“直接覆盖配置文件”的小脚本,在写入过程中强制结束进程,观察文件是否损坏;再用临时文件加 rename 的方式对比。
  3. 在 Linux 上删除一个正在被写入的日志文件,用 lsof 找 deleted 标记,观察空间是否释放。本机没有 Linux 环境,这一条未在本机实测。
  4. 用 os.stat 查看一个文件的 inode 编号,改名后再看,确认编号不变;创建硬链接后再看,确认两个名字指向同一个编号。本机是 Windows,inode 相关行为未在本机实测。
  5. 对同一个文件分别做“每次写都 fsync”和“攒 100 条再 fsync”,比较总耗时,算一下用多少吞吐换多少安全性。

小结与下一篇

写文件不是一步到位,而是应用缓冲、内核页缓存、块设备和介质四层。write 成功只代表交给了内核,flush 才把应用缓冲交出去,fsync 才把内核脏数据刷到介质,close 不保证持久化。文件名和 inode 是分开的,删除名字不等于释放数据;崩溃一致性靠日志或写时复制,但业务层仍要设计自己的提交顺序。

下一篇讲printf 是怎么把字打到屏幕上的:中断与系统调用。文件写入要跨过用户态和内核态,输出到屏幕也一样。那一次跨越到底发生了什么,为什么它比普通函数调用贵,以及中断在其中扮演什么角色,是下一篇要拆开的内容。