MooseFS and io_uring: Getting Ahead of the Curve on FUSE Performance
io_uring is one of the most significant I/O performance mechanisms to land in the Linux kernel in recent years, and the MooseFS Client already knows how to use it — though getting it fully working today takes a bit of extra work that has nothing to do with MooseFS itself.
What Is io_uring?
io_uring is a Linux kernel interface designed to speed up read and write operations. Instead of copying data back and forth between kernel space and user space on every I/O call, io_uring sets up shared buffers that both the kernel and the application can access directly. This significantly reduces the amount of memory copying involved in I/O, which translates into lower latency and less CPU overhead — particularly valuable for high-throughput or high-IOPS workloads.
io_uring Support in the MooseFS Client
The MooseFS Client already supports io_uring out of the box. When the client detects that the FUSE implementation it is linked against advertises io_uring capability, the -o io_uring mount option automatically appears in the client’s context help.
To actually use it, a few things need to line up:
- A sufficiently new kernel. io_uring support in FUSE requires Linux kernel 6.14 or newer, with the relevant kernel configuration options enabled. Not every Linux distribution ships a kernel with these options turned on by default — some may require a custom kernel build.
- The feature enabled at the kernel level:
echo 1 | sudo tee /sys/module/fuse/parameters/enable_uring - The
-o io_uringoption passed at mount time.
We tested this on Ubuntu 26, which ships kernel 7.0 with everything required enabled by default, so no kernel recompilation was needed there.
The Catch: FUSE Itself Isn’t Ready Yet
In practice, none of the above is enough to get io_uring actually working today — and that is not a MooseFS limitation. io_uring support was introduced in FUSE 3.18.2, but that release shipped with bugs that effectively prevent it from working correctly. The fix requires a newer version of FUSE, which at the time of writing is only available by compiling FUSE from source — it has not yet been packaged by distributions.
So for now, running the MooseFS Client with a genuinely working io_uring path requires:
- Compiling FUSE manually from source, past the buggy 3.18.2 release
- Linking the MooseFS Client against this custom-built FUSE library instead of the distribution-provided one
Why We Looked Into This
Several members of the MooseFS Community have expressed interest in io_uring support, so we decided to get ahead of it: confirm exactly where the gap was, and produce a setup that genuinely works on top of the current release rather than only in theory. Tracking down the fact that FUSE 3.18.2 itself was the blocker — rather than anything in the kernel configuration or the MooseFS Client — was the bulk of the investigation. Once that was identified, putting together a working setup was straightforward.
A Word on the Documentation
We have put together step-by-step instructions for building a working MooseFS and io_uring setup on Ubuntu 26. Worth noting: this documentation has a short shelf life by design. Once FUSE 3.19 is released — currently in release candidate stage — the fix should land in a proper release, and io_uring support should work out of the box again using the distribution’s own FUSE package, with no manual compilation required.
What is harder to predict is how quickly various Linux distributions will pick up FUSE 3.19 and ship it in their canonical packages. Until that happens, this guide should be useful for anyone who wants working io_uring support with MooseFS today, rather than waiting for it to arrive through normal channels.
Summary
io_uring support is already built into the MooseFS Client. The remaining gap is entirely on the FUSE side, and it is temporary. To try it now, it takes a self-compiled FUSE library; once FUSE 3.19 reaches your distribution, it should be as simple as setting the kernel parameter and adding -o io_uring at mount time.