6 Key Takeaways from the Linux Storage Summit on Atomic Buffered Writes
The 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit dedicated two back-to-back sessions (and a third overflow slot) to the evolving topic of atomic buffered writes. These sessions spotlighted a critical challenge in filesystem design: ensuring that write operations to the page cache maintain atomicity without sacrificing performance. With database systems like PostgreSQL as a primary use case, developers explored potential solutions, most notably a writethrough approach that bypasses traditional writeback delays. The discussions brought together filesystem experts, storage architects, and kernel maintainers, generating both consensus and debate. Below are six essential insights from these sessions.
1. The Core Problem: Atomicity Gaps in Buffered Writes
Buffered writes in Linux rely on the page cache to temporarily hold data before it is flushed to disk. While this improves performance, it introduces a risk: if a crash occurs between writes, the data on disk may be partially updated. Databases require atomicity—either all writes from a transaction are applied, or none are. The current page cache mechanism cannot guarantee this without additional journaling or fsync calls, which incur performance costs. The sessions started by framing this atomicity gap, emphasizing that many applications, especially databases, suffer from data corruption or recovery complexity when write operations are interrupted. The community agreed that a kernel-level solution could reduce application overhead and improve overall reliability.
2. PostgreSQL: The Driving Use Case
Andres Freund and Pankaj Raghav presented the case of PostgreSQL, which frequently issues small, atomic writes to its write-ahead log (WAL). Ensuring these writes are durable is essential for transaction integrity. Currently, PostgreSQL must call fsync() after each write to force the data to disk, a costly operation that limits throughput. With atomic buffered writes, the kernel could guarantee that the write is complete before returning, eliminating the need for an explicit sync. Freund demonstrated benchmarks showing significant performance gains when atomicity is provided at the filesystem level, especially on NVMe devices where write latencies are low but fsync overhead remains high. This use case anchored the entire discussion, providing a concrete motivation for the feature.
3. The Writethrough Approach as a Potential Solution
Ojaswin Mujoo introduced a writethrough mechanism to address atomicity. In this approach, the kernel immediately writes data to disk when a buffered write is issued, rather than delaying it until writeback. This ensures that the data is on stable storage before the write syscall returns, providing atomicity without requiring the application to call fsync(). However, writethrough introduces its own challenges: it can increase the number of small I/O operations, potentially harming performance for write-heavy workloads. Mujoo proposed a hybrid model where writethrough is only used for specifically flagged writes (e.g., via a new flag like RWF_ATOMIC), leaving normal buffered writes unchanged. This targeted approach balances atomicity guarantees with performance needs.
4. Challenges with Existing Writeback Mechanisms
The traditional writeback mechanism flushes dirty pages from the page cache to disk in batches, optimized for throughput. But for atomicity, batching introduces a window where partial updates could be written. The sessions explored the tension between writeback efficiency and data integrity. Developers noted that even with journaling filesystems like ext4 and XFS, atomic buffered writes are not natively supported because the journal only ensures metadata consistency, not data. Extending writeback to support atomicity would require significant changes to the I/O pipeline, including modifications to the block layer and filesystem write paths. The discussion underscored that simply speeding up writeback is not enough; a new mechanism is needed to convey atomicity semantics from application to storage.
5. Community Debates: Performance vs. Complexity
During the combined storage and filesystem tracks, lively debate emerged around the trade-offs of implementing atomic buffered writes. Some developers argued that the writethrough approach could degrade performance for non-database workloads, while others countered that the feature would be opt-in via new syscall flags. Concerns were raised about the impact on existing filesystem code—many participants feared that adding atomic buffered writes would complicate the page cache and block layer without providing universal benefits. Proponents pointed to PostgreSQL benchmarks showing up to 40% throughput improvement in write-heavy scenarios. The discussion concluded that a prototype should be developed to gather real-world data, helping the community decide whether the complexity is justified.
6. The Path Forward: Prototyping and Collaboration
While no final decision was reached, the sessions set a clear direction: create a prototype of the writethrough-based atomic buffered write mechanism for further evaluation. This prototype would likely involve new flags for the pwritev2() system call and modifications to the page cache to support immediate write initiation. Collaboration between the PostgreSQL community and Linux kernel filesystem developers was emphasized, as real-world testing is crucial. If successful, this feature could become a standard part of the Linux I/O stack, enabling databases and other critical applications to achieve both high performance and strong atomicity guarantees without relying on application-level workarounds.
The 2026 summit demonstrated that atomic buffered writes remain a high-priority challenge. With a solid use case, a proposed mechanism, and a community willing to experiment, the next steps will likely bring this feature closer to mainline integration. Whether through writethrough or another approach, the goal remains: allowing buffered writes to be atomic without sacrificing the speed that makes Linux a dominant platform for data-intensive workloads.