From: sashiko-bot@kernel.org
To: "Vitaly Wool" <vitaly.wool@konsulko.se>,
"Andreas Hindborg" <a.hindborg@kernel.org>,
"Jens Axboe" <axboe@kernel.dk>, "Miguel Ojeda" <ojeda@kernel.org>,
"Alice Ryhl" <aliceryhl@google.com>
Cc: "Boqun Feng" <boqun@kernel.org>, "Gary Guo" <gary@garyguo.net>,
"Björn Roy Baron" <bjorn3_gh@protonmail.com>,
"Benno Lossin" <lossin@kernel.org>,
"Trevor Gross" <tmgross@umich.edu>,
"Danilo Krummrich" <dakr@kernel.org>,
"Daniel Almeida" <daniel.almeida@collabora.com>,
"Tamir Duberstein" <tamird@kernel.org>,
"Alexandre Courbot" <acourbot@nvidia.com>,
"Onur Özkan" <work@onurozkan.dev>,
"Lorenzo Stoakes" <ljs@kernel.org>,
"Liam R . Howlett" <liam@infradead.org>,
linux-mm@kvack.org, "Igor B" <igor.b@beldev.am>
Subject: Re: [PATCH 1/3] rust: block: add bio segment iteration and request accessors
Date: Wed, 18 Nov 2026 23:36:22 +0000 [thread overview]
Message-ID: <sashiko-outbox-222196@kernel.org> (raw)
In-Reply-To: <20261117233211.3137168-2-vitaly.wool@konsulko.se>
Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [Medium] rust: block: NULL bi_io_vec dereference in
SegmentIter::next()
- [Medium] rust: block: unsound safe Segment::zero() and copy_*_page()
safety docs
- [Low] rust: block: wrong default block size in discard_granularity()
docs
- [Low] rust: block: missing #[inline] and Bio::from_raw() INVARIANT
comment
--
commit f73d6ca145fdbea749b64ff55a7ec48747dee38e
Author: Igor B <igor.b@beldev.am>
rust: block: add bio segment iteration and request accessors
This commit adds a Rust bio wrapper and segment iterator, request
accessors for command, sector, byte length, and bios, and GenDiskBuilder
helpers for configuring discard limits.
> diff --git a/rust/kernel/block/bio.rs b/rust/kernel/block/bio.rs
> new file mode 100644
> index 0000000000000..183f9ae6d48d9
> --- /dev/null
> +++ b/rust/kernel/block/bio.rs
> @@ -0,0 +1,253 @@
[ ... ]
> +/// A wrapper around a C [`struct bio`].
> +///
> +/// # Invariants
> +///
> +/// `self.0` is a valid `struct bio` that is part of a request owned by the
> +/// driver. Neither the bio nor its data pages are released while a `&Bio` is
> +/// alive.
> +///
> +/// [`struct bio`]: srctree/include/linux/blk_types.h
> +#[repr(transparent)]
> +pub struct Bio(Opaque<bindings::bio>);
> +
> +impl Bio {
> + /// Create a reference to a [`Bio`] from a raw pointer.
> + ///
> + /// # Safety
> + ///
> + /// `ptr` must point to a valid `struct bio` that stays valid, and is not
> + /// modified by anyone but the holder of the returned reference, for the
> + /// duration of `'a`.
> + pub(crate) unsafe fn from_raw<'a>(ptr: *mut bindings::bio) -> &'a Self {
> + // SAFETY: `Bio` is `repr(transparent)` over `bindings::bio`, and the
> + // safety requirements of this function make the reference valid.
> + unsafe { &*ptr.cast::<Self>() }
> + }
[Severity: Low]
Since struct Bio has an # Invariants section, Bio::from_raw() should have
an // INVARIANT: comment explaining how the caller's safety guarantees
satisfy those invariants.
Also, in the kernel crate abstractions, small functions and functions that
forward to C bindings should be marked #[inline]; none of the new methods in
rust/kernel/block/bio.rs, rust/kernel/block/mq/gen_disk.rs, or
rust/kernel/block/mq/request.rs have #[inline].
[ ... ]
> + /// Return an iterator over the single-page segments of this bio.
> + ///
> + /// This is the equivalent of the C `bio_for_each_segment()` macro.
> + pub fn segment_iter(&self) -> SegmentIter<'_> {
> + SegmentIter {
> + bio: self,
> + // SAFETY: By the type invariant `self.raw()` is valid.
> + iter: unsafe { (*self.raw()).bi_iter },
> + }
> + }
[ ... ]
> +impl<'a> Iterator for SegmentIter<'a> {
> + type Item = Segment<'a>;
> +
> + fn next(&mut self) -> Option<Segment<'a>> {
> + if self.iter.bi_size == 0 {
> + return None;
> + }
> +
> + let sector = self.iter.bi_sector;
> +
> + // SAFETY: By the type invariant of `Bio`, `self.bio.raw()` is valid,
> + // and `self.iter` is a copy of its `bi_iter` that was only advanced
> + // through `bio_advance_iter_single`, so it is within bounds.
> + let bvec = unsafe { bindings::bio_iter_iovec(self.bio.raw(), &self.iter) };
[Severity: Medium]
Can calling Bio::segment_iter() in safe Rust cause a NULL pointer
dereference in SegmentIter::next() on a discard or write-zeroes request?
In block/blk-lib.c, bios for REQ_OP_DISCARD, REQ_OP_WRITE_ZEROES, and
REQ_OP_SECURE_ERASE are allocated with nr_vecs = 0, which sets
bio->bi_io_vec = NULL while setting bio->bi_iter.bi_size to the non-zero
byte length of the operation (and REQ_DMABUF bios store bi_dmabuf_map in
the union with bi_io_vec). Because Request::bio_iter() and
Bio::segment_iter() are safe functions and neither checks bio_has_data()
or !bio_no_advance_iter(), iterating segments of such a bio calls
bio_iter_iovec() with bi_size > 0 and dereferences a NULL (or non-bvec)
bi_io_vec pointer.
[ ... ]
> + /// Copy `len` bytes starting at byte `off` of this segment into `dst`
> + /// starting at `dst_off`.
> + ///
> + /// Returns [`EINVAL`] if either range is out of bounds.
> + ///
> + /// # Safety
> + ///
> + /// The caller must ensure that this call does not race with a read or
> + /// write of the same range of `dst`.
> + pub unsafe fn copy_to_page(
> + &self,
> + off: usize,
> + dst: &Page,
> + dst_off: usize,
> + len: usize,
> + ) -> Result {
> + self.with_mapped(off, len, |src| {
> + // SAFETY: `src` is valid for reading `len` bytes, and the caller
> + // guarantees there is no racing access to `dst`.
> + unsafe { dst.write_raw(src, dst_off, len) }
> + })
> + }
> +
> + /// Copy `len` bytes from `src` starting at `src_off` into this segment
> + /// starting at byte `off`.
> + ///
> + /// Returns [`EINVAL`] if either range is out of bounds.
> + ///
> + /// # Safety
> + ///
> + /// The caller must ensure that this call does not race with a write to the
> + /// same range of `src`.
> + pub unsafe fn copy_from_page(
> + &self,
> + off: usize,
> + src: &Page,
> + src_off: usize,
> + len: usize,
> + ) -> Result {
> + self.with_mapped(off, len, |dst| {
> + // SAFETY: `dst` is valid for writing `len` bytes. The data buffer
> + // of the bio is owned by the driver while the request is in
> + // flight. The caller guarantees there is no racing write to `src`.
> + unsafe { src.read_raw(dst, src_off, len) }
> + })
> + }
> +
> + /// Fill `len` bytes starting at byte `off` of this segment with zeroes.
> + ///
> + /// Returns [`EINVAL`] if the range is out of bounds.
> + pub fn zero(&self, off: usize, len: usize) -> Result {
> + self.with_mapped(off, len, |dst| {
> + // SAFETY: `dst` is valid for writing `len` bytes. The data buffer
> + // of the bio is owned by the driver while the request is in
> + // flight.
> + unsafe { ptr::write_bytes(dst, 0, len) };
> + Ok(())
> + })
> + }
> +}
[Severity: Medium]
Is Segment::zero(&self, ...) sound as a safe method, and are the safety
contracts on copy_to_page() and copy_from_page() complete?
Request<T> implements Send, Sync, and AlwaysRefCounted, and
Request::bio_iter(), Bio::segment_iter(), and Segment::zero() all take
&self. Two threads holding shared &Request<T> references (or a bio with
multiple bvecs referencing the same page) can call Segment::zero()
concurrently from safe Rust, causing a data race. Moreover, on
REQ_OP_WRITE bios the segment pages are read-only source buffers that can
point to shared kernel pages such as largest_zero_folio() in
__blkdev_issue_zero_pages(), so writing to them via Segment::zero() or
Segment::copy_from_page() corrupts shared memory.
Segment::zero() should be unsafe (matching Page::fill_zero_raw()), and the
safety requirements for zero(), copy_from_page(), and copy_to_page()
should also require that no concurrent accesses race on the segment's own
page range and that mutating methods are only called on writable request
buffers.
> diff --git a/rust/kernel/block/mq/gen_disk.rs b/rust/kernel/block/mq/gen_disk.rs
> index 0fe640f3aec63..57d5431654303 100644
> --- a/rust/kernel/block/mq/gen_disk.rs
> +++ b/rust/kernel/block/mq/gen_disk.rs
[ ... ]
> @@ -106,6 +110,25 @@ pub fn capacity_sectors(mut self, capacity: u64) -> Self {
> self
> }
>
> + /// Set the maximum number of sectors (512 bytes) the device can discard in
> + /// a single request.
> + ///
> + /// Zero, the default, means that the device does not support discard.
> + pub fn max_hw_discard_sectors(mut self, sectors: u32) -> Self {
> + self.max_hw_discard_sectors = sectors;
> + self
> + }
> +
> + /// Set the discard granularity of the device in bytes.
> + ///
> + /// This is the internal allocation unit of the device. Discards smaller
> + /// than this, or not aligned to it, may not free any storage. Zero, the
> + /// default, lets the block layer use the logical block size.
> + pub fn discard_granularity(mut self, granularity: u32) -> Self {
> + self.discard_granularity = granularity;
> + self
> + }
[Severity: Low]
Does a discard_granularity of zero default to the logical block size or
the physical block size?
In block/blk-settings.c, blk_validate_limits() clamps
lim->discard_granularity with:
lim->discard_granularity =
max(lim->discard_granularity, lim->physical_block_size);
so leaving discard_granularity at zero causes the block layer to use
physical_block_size rather than logical_block_size.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117233211.3137168-1-vitaly.wool@konsulko.se?part=1
next prev parent reply other threads:[~2026-11-18 23:36 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-17 23:32 [PATCH 0/3] rust: block: add rbrd, a RAM backed block driver Vitaly Wool
2026-11-17 23:32 ` [PATCH 1/3] rust: block: add bio segment iteration and request accessors Vitaly Wool
2026-11-18 15:19 ` Andreas Hindborg
2026-11-18 23:36 ` sashiko-bot [this message]
2026-11-17 23:32 ` [PATCH 2/3] rust: page: add reference counting, raw pointers and a private bit lock Vitaly Wool
2026-11-18 15:23 ` Andreas Hindborg
2026-11-18 23:36 ` sashiko-bot
2026-11-17 23:32 ` [PATCH 3/3] rust: block: add rbrd, a RAM backed block driver Vitaly Wool
2026-11-18 23:36 ` sashiko-bot
2026-11-18 11:43 ` [PATCH 0/3] " Jan Engelhardt
2026-11-18 14:48 ` Vitaly Wool
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-222196@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=a.hindborg@kernel.org \
--cc=acourbot@nvidia.com \
--cc=aliceryhl@google.com \
--cc=axboe@kernel.dk \
--cc=bjorn3_gh@protonmail.com \
--cc=boqun@kernel.org \
--cc=dakr@kernel.org \
--cc=daniel.almeida@collabora.com \
--cc=gary@garyguo.net \
--cc=igor.b@beldev.am \
--cc=liam@infradead.org \
--cc=linux-mm@kvack.org \
--cc=ljs@kernel.org \
--cc=lossin@kernel.org \
--cc=ojeda@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
--cc=tamird@kernel.org \
--cc=tmgross@umich.edu \
--cc=vitaly.wool@konsulko.se \
--cc=work@onurozkan.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox