[LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Xiao Ni]

Hi all

I'm doing some work on user-space RAID recently. I'd like to propose a
topic for LSF/MM 2026 regarding the implementation of RAID5 in user
space using ublk and io_uring bpf[1], particularly focusing on the
challenges encountered and potential kernel improvements needed.

Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
with the goal of leveraging io_uring's zero-copy capabilities and
BPF[1] for performance optimization. The implementation includes:
* RAID5 stripe handling with configurable chunk sizes
* Multi-queue support via io_uring
* Degraded mode for single disk failure tolerance
* Integration with io_uring BPF struct_ops framework

During the implementation, I encountered several technical challenges.
The primary challenge is performing XOR parity calculations in a true
zero-copy manner:

1. Bpf program support
Raid5 needs to calculate parity with data. Now io_uring already
supports zero copy. For targets such as raid0/raid1, it's enough. But
for targets such as raid5, it still needs to copy data to userspace
and calculate the parity. Bpf program is a nice solution[1] to resolve
this issue. Besides the patch set[1], it still needs another bpf kfunc
uring_bpf_xor() support.

2. Register buffer per io
Raid5 needs to calculate parity with data. So it still needs to
pre-alloc buffer and register it for each io. The total memory is
controlled by queue number and queue depth. With the pre-alloc memory
and bpf program support, target such as raid5 can support true
zero-copy manner.

Question for discussion:
* Should the kernel provide XOR operation kfuncs for io_uring BPF?
* What would be the appropriate API design?
* Are there security or verification concerns with BPF performing XOR
on registered buffers?

Current Status:
* Basic RAID5 functionality: implemented
* BPF struct_ops framework: successfully integrated
* Performance testing: in progress
* Main blocker: zero-copy XOR implementation waiting for kernel
support I've written a patch for testing based on [1]

Why this matters
User-space block devices (ublk) offer several advantages:
* Faster development and iteration
* Easier debugging
*  Ability to leverage user-space libraries
* No kernel panic risks during development
* Easy to evaluate/compare performance between kernel raid and ublk
based userspace raid.

Desired Outcome
* If proposal in [1] would be acceptable
* Get feedback on whether `uring_bpf_xor()` kfunc would be acceptable
* Discuss API design for BPF-based computation on io_uring buffers
* Understand the roadmap for io_uring + BPF capabilities
* Learn best practices from the community for similar implementations

I'll finish the ublk raid5(tools/testing/selftests/ublk/) and submit
patches later. Also, I'll try to prepare a patch for uring_bpf_xor.
Next, I'll try to impement it based on rublk[2].

[1] https://lore.kernel.org/io-uring/20260106101126.4064990-1-ming.lei@redhat.com/
[2] https://github.com/ublk-org/libublk-rs

Best Regards
Xiao

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Ming Lei]

Hi Xiao,

On Thu, Feb 19, 2026 at 01:38:46PM +0800, Xiao Ni wrote:
> Hi all
> 
> I'm doing some work on user-space RAID recently. I'd like to propose a
> topic for LSF/MM 2026 regarding the implementation of RAID5 in user
> space using ublk and io_uring bpf[1], particularly focusing on the
> challenges encountered and potential kernel improvements needed.
> 
> Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
> with the goal of leveraging io_uring's zero-copy capabilities and
> BPF[1] for performance optimization. The implementation includes:
> * RAID5 stripe handling with configurable chunk sizes
> * Multi-queue support via io_uring
> * Degraded mode for single disk failure tolerance
> * Integration with io_uring BPF struct_ops framework
> 
> During the implementation, I encountered several technical challenges.
> The primary challenge is performing XOR parity calculations in a true
> zero-copy manner:
> 
> 1. Bpf program support
> Raid5 needs to calculate parity with data. Now io_uring already
> supports zero copy. For targets such as raid0/raid1, it's enough. But
> for targets such as raid5, it still needs to copy data to userspace
> and calculate the parity. Bpf program is a nice solution[1] to resolve
> this issue. Besides the patch set[1], it still needs another bpf kfunc
> uring_bpf_xor() support.
> 
> 2. Register buffer per io
> Raid5 needs to calculate parity with data. So it still needs to
> pre-alloc buffer and register it for each io. The total memory is
> controlled by queue number and queue depth. With the pre-alloc memory
> and bpf program support, target such as raid5 can support true
> zero-copy manner.
> 
> Question for discussion:
> * Should the kernel provide XOR operation kfuncs for io_uring BPF?
> * What would be the appropriate API design?
> * Are there security or verification concerns with BPF performing XOR
> on registered buffers?
> 
> Current Status:
> * Basic RAID5 functionality: implemented
> * BPF struct_ops framework: successfully integrated
> * Performance testing: in progress
> * Main blocker: zero-copy XOR implementation waiting for kernel
> support I've written a patch for testing based on [1]
> 
> Why this matters
> User-space block devices (ublk) offer several advantages:
> * Faster development and iteration
> * Easier debugging
> *  Ability to leverage user-space libraries
> * No kernel panic risks during development
> * Easy to evaluate/compare performance between kernel raid and ublk
> based userspace raid.
> 
> Desired Outcome
> * If proposal in [1] would be acceptable
> * Get feedback on whether `uring_bpf_xor()` kfunc would be acceptable
> * Discuss API design for BPF-based computation on io_uring buffers
> * Understand the roadmap for io_uring + BPF capabilities
> * Learn best practices from the community for similar implementations

I am interested in this topic, and looks Caleb Sander Mateos has similar
requirement too.


Thanks,
Ming

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Xiao Ni]

On Fri, Feb 20, 2026 at 10:14 PM Ming Lei <ming.lei@redhat.com> wrote:
>
> Hi Xiao,
>
> On Thu, Feb 19, 2026 at 01:38:46PM +0800, Xiao Ni wrote:
> > Hi all
> >
> > I'm doing some work on user-space RAID recently. I'd like to propose a
> > topic for LSF/MM 2026 regarding the implementation of RAID5 in user
> > space using ublk and io_uring bpf[1], particularly focusing on the
> > challenges encountered and potential kernel improvements needed.
> >
> > Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
> > with the goal of leveraging io_uring's zero-copy capabilities and
> > BPF[1] for performance optimization. The implementation includes:
> > * RAID5 stripe handling with configurable chunk sizes
> > * Multi-queue support via io_uring
> > * Degraded mode for single disk failure tolerance
> > * Integration with io_uring BPF struct_ops framework
> >
> > During the implementation, I encountered several technical challenges.
> > The primary challenge is performing XOR parity calculations in a true
> > zero-copy manner:
> >
> > 1. Bpf program support
> > Raid5 needs to calculate parity with data. Now io_uring already
> > supports zero copy. For targets such as raid0/raid1, it's enough. But
> > for targets such as raid5, it still needs to copy data to userspace
> > and calculate the parity. Bpf program is a nice solution[1] to resolve
> > this issue. Besides the patch set[1], it still needs another bpf kfunc
> > uring_bpf_xor() support.
> >
> > 2. Register buffer per io
> > Raid5 needs to calculate parity with data. So it still needs to
> > pre-alloc buffer and register it for each io. The total memory is
> > controlled by queue number and queue depth. With the pre-alloc memory
> > and bpf program support, target such as raid5 can support true
> > zero-copy manner.
> >
> > Question for discussion:
> > * Should the kernel provide XOR operation kfuncs for io_uring BPF?
> > * What would be the appropriate API design?
> > * Are there security or verification concerns with BPF performing XOR
> > on registered buffers?
> >
> > Current Status:
> > * Basic RAID5 functionality: implemented
> > * BPF struct_ops framework: successfully integrated
> > * Performance testing: in progress
> > * Main blocker: zero-copy XOR implementation waiting for kernel
> > support I've written a patch for testing based on [1]
> >
> > Why this matters
> > User-space block devices (ublk) offer several advantages:
> > * Faster development and iteration
> > * Easier debugging
> > *  Ability to leverage user-space libraries
> > * No kernel panic risks during development
> > * Easy to evaluate/compare performance between kernel raid and ublk
> > based userspace raid.
> >
> > Desired Outcome
> > * If proposal in [1] would be acceptable
> > * Get feedback on whether `uring_bpf_xor()` kfunc would be acceptable
> > * Discuss API design for BPF-based computation on io_uring buffers
> > * Understand the roadmap for io_uring + BPF capabilities
> > * Learn best practices from the community for similar implementations
>
> I am interested in this topic, and looks Caleb Sander Mateos has similar
> requirement too.

Hi Ming

Thanks and any suggestion is welcome :)

Best Regards
Xiao
>
>
> Thanks,
> Ming
>

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Pavel Begunkov]

On 2/19/26 05:38, Xiao Ni wrote:
> Hi all
> 
> I'm doing some work on user-space RAID recently. I'd like to propose a
> topic for LSF/MM 2026 regarding the implementation of RAID5 in user
> space using ublk and io_uring bpf[1], particularly focusing on the
> challenges encountered and potential kernel improvements needed.
> 
> Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
> with the goal of leveraging io_uring's zero-copy capabilities and
> BPF[1] for performance optimization. The implementation includes:
> * RAID5 stripe handling with configurable chunk sizes
> * Multi-queue support via io_uring
> * Degraded mode for single disk failure tolerance
> * Integration with io_uring BPF struct_ops framework
> 
> During the implementation, I encountered several technical challenges.
> The primary challenge is performing XOR parity calculations in a true
> zero-copy manner:

I aim at similar use cases, i.e. interacting with registered buffers
from BPF, but based on a different BPF-io_uring implementation. I'd be
interesting to discuss how the kfunc API should look like.

-- 
Pavel Begunkov

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Hannes Reinecke]

On 2/23/26 16:54, Pavel Begunkov wrote:
> On 2/19/26 05:38, Xiao Ni wrote:
>> Hi all
>>
>> I'm doing some work on user-space RAID recently. I'd like to propose a
>> topic for LSF/MM 2026 regarding the implementation of RAID5 in user
>> space using ublk and io_uring bpf[1], particularly focusing on the
>> challenges encountered and potential kernel improvements needed.
>>
>> Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
>> with the goal of leveraging io_uring's zero-copy capabilities and
>> BPF[1] for performance optimization. The implementation includes:
>> * RAID5 stripe handling with configurable chunk sizes
>> * Multi-queue support via io_uring
>> * Degraded mode for single disk failure tolerance
>> * Integration with io_uring BPF struct_ops framework
>>
>> During the implementation, I encountered several technical challenges.
>> The primary challenge is performing XOR parity calculations in a true
>> zero-copy manner:
> 
> I aim at similar use cases, i.e. interacting with registered buffers
> from BPF, but based on a different BPF-io_uring implementation. I'd be
> interesting to discuss how the kfunc API should look like.
> 
I'd be interested in that, too.
I'm working on BPF support for nvme / nvmet, so some ideas how others
handle it won't go amiss.

Cheers,

Hannes
-- 
Dr. Hannes Reinecke                  Kernel Storage Architect
hare@suse.de                                +49 911 74053 688
SUSE Software Solutions GmbH, Frankenstr. 146, 90461 Nürnberg
HRB 36809 (AG Nürnberg), GF: I. Totev, A. McDonald, W. Knoblich

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Keith Busch]

On Thu, Feb 19, 2026 at 01:38:46PM +0800, Xiao Ni wrote:
> Hi all
> 
> I'm doing some work on user-space RAID recently. I'd like to propose a
> topic for LSF/MM 2026 regarding the implementation of RAID5 in user
> space using ublk and io_uring bpf[1], particularly focusing on the
> challenges encountered and potential kernel improvements needed.
> 
> Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
> with the goal of leveraging io_uring's zero-copy capabilities and
> BPF[1] for performance optimization. The implementation includes:
> * RAID5 stripe handling with configurable chunk sizes
> * Multi-queue support via io_uring
> * Degraded mode for single disk failure tolerance
> * Integration with io_uring BPF struct_ops framework
> 
> During the implementation, I encountered several technical challenges.
> The primary challenge is performing XOR parity calculations in a true
> zero-copy manner:

Great use case. The indirect reference to memory from user space is a
bit of a blocker for various zero-copy plans, so being able to leverage
the kernel to perform parity and crypto transforms would be awesome. I
think there's potential for fuse as well as ublk.

Anyway, I'm interested in the topic.

Re: [LSF/MM/BPF TOPIC] User space RAID5 with ublk and io_uring BPF

[Cong Wang]

On Thu, Feb 19, 2026 at 01:38:46PM +0800, Xiao Ni wrote:
> Hi all
> 
> I'm doing some work on user-space RAID recently. I'd like to propose a
> topic for LSF/MM 2026 regarding the implementation of RAID5 in user
> space using ublk and io_uring bpf[1], particularly focusing on the
> challenges encountered and potential kernel improvements needed.
> 
> Ublk raid5 uses the ublk framework (tools/testing/selftests/ublk/),
> with the goal of leveraging io_uring's zero-copy capabilities and
> BPF[1] for performance optimization. The implementation includes:
> * RAID5 stripe handling with configurable chunk sizes
> * Multi-queue support via io_uring
> * Degraded mode for single disk failure tolerance
> * Integration with io_uring BPF struct_ops framework


This is very interesting.

Although technically different with RAID, how about user-space LVM?

I need it for the multikernel use case:
https://lpc.events/event/19/contributions/2074/attachments/1776/3957/Multikernel-LPC2025.pdf
(slide #19)

Relying on the in-kernel LVM is not ideal for provisioning since ublk is
already there.

Also, it does not need to be a complete replacement of existing LVM,
a simple ublk-defined storage isolation is sufficient.

Regards,
Cong Wang