Linux kernel engineers at Konsulko have submitted a new patch series introducing **RBRD**, a RAM-backed block driver written in Rust that re-implements the functionality of Linux's traditional C-based `brd` virtual RAM disk. Published to the `rust-for-linux` mailing list on November 17, 2026 by Vitaly Wool, the submission puts one of Rust-for-Linux's central trade-offs under a microscope: how much raw throughput kernel maintainers are willing to trade for compile-time memory safety and strict data-race prevention in core storage drivers.
Unlike physical NVMe or eMMC drivers where hardware latency dwarfs CPU synchronization overhead, a RAM-backed block device strips storage down to pure memory copies and locking primitives. That makes RBRD an unusually revealing stress test for Rust's Linux block-layer bindings—and early benchmarks show a measurable cost. Single-threaded writes in RBRD trail the legacy C `brd` driver by roughly 19 percent, widening to about 22 percent under eight-thread concurrency, while reads carry a smaller 2 to 10 percent penalty.
### Why Safe Rust Refuses C's Loose Page Copies
The performance gap stems directly from Rust's aliasing and concurrency rules. In C, the veteran `brd` driver permits concurrent read and write copies touching the same backing memory page without the compiler forbidding simultaneous access. While fast in synthetic microbenchmarks, that looseness risks subtle race conditions or returning torn, partially initialized data under contention. In Rust, allowing unsynchronized concurrent read and write access to the same memory page constitutes undefined behavior that the borrow checker is designed to reject.
To uphold Rust's safety invariants cleanly, RBRD enforces locking guarantees that prevent a read copy and a write copy from hitting a page at the exact same moment. Granularity matters enormously here: when the developers initially tested a coarse, single lock spanning the entire virtual block device, eight-thread read throughput dropped 20 to 28 percent behind `brd`. Switching to per-page locking cut that read deficit down to the current 2 to 10 percent window. Notably, the authors acknowledge that the remaining gap has not yet been fully profiled, meaning part of the roughly 19 to 22 percent write overhead could stem from unoptimized code paths rather than locking physics alone.
### Is a 20 Percent RAM-Disk Tax Acceptable?
At a time when DRAM pricing and capacity constraints limit how often production servers deploy full RAM disks, critics might question why a virtual block driver matters. In practice, RAM-backed block devices remain workhorses for kernel storage regressions, deterministic filesystem testing, and high-speed ephemeral scratch spaces. More importantly, RBRD's developers argue that a 20 percent synthetic overhead inside system memory misses the bigger picture: RAM still operates orders of magnitude faster than any physical SSD, and correctness is non-negotiable. As the patch notes emphasize, "a block device should never return data that was never written," making strict page integrity a modest price when virtual RAM throughput remains vastly ahead of real-world storage hardware.
That framing reflects a broader philosophical shift inside the [Rust for Linux](https://rust-for-linux.com/) effort documented under the kernel's official [Rust subsystem documentation](https://docs.kernel.org/rust/index.html). Earlier Rust block-layer milestones focused on stateless or minimal test drivers such as `rnull` (the Rust null-block driver) to prove out `blk-mq` bindings. RBRD takes the next logical step by managing actual backing pages, concurrent I/O copies, and locking contention in a realistic block device.
### What It Signals for Linux Gaming and Handheld Storage Stacks
Even though end users running [SteamOS](https://www.mushimu.com/post/8729), [Bazzite](https://www.mushimu.com/post/8728), or [CachyOS Handheld Edition](https://www.mushimu.com/post/8730) won't mount `/dev/rbrd` to store their Steam libraries, every mature Rust block driver hardens the kernel interfaces that future storage, swap, and compressed-RAM (`zram`) subsystems depend on. Handheld PCs with tight 16 GB unified memory pools lean heavily on fast swap, page cache management, and reliable block I/O during shader compilation and background updates.
By putting real multi-threaded numbers next to C's `brd` driver on the mailing list, Vitaly Wool and the Rust-for-Linux contributors are giving subsystem maintainers transparent data rather than ideology. Whether profiling narrows that 19 to 22 percent write gap before RBRD lands upstream—or whether maintainers endorse the safety margin as-is—the patch marks a concrete milestone in moving Rust deeper into Linux's stateful storage core.
### Sources & Further Reading
- [Phoronix — RBRD: RAM-Backed Linux Block Driver Written In Rust For Better Safety But Slower Performance](https://www.phoronix.com/news/RBRD-Rust-Linux-RAM-Driver)
- [Linux Kernel Mailing List (`rust-for-linux`) — Vitaly Wool (Konsulko) RBRD Patch Series](https://lore.kernel.org/rust-for-linux/[email protected]/)
- [Linux Kernel Official Documentation — Rust Subsystem Index](https://docs.kernel.org/rust/index.html)
- [Rust for Linux — Official Project Portal](https://rust-for-linux.com/)
~Linux ~Rust ~Kernel ~HandheldPC ~OpenSource