Rust PCI capability infrastructure and SR-IOV support
cover Rust PCI capability infrastructure and SR-IOV support
This is a follow-up to the RFC v2 series [1], reworked on top of Gary's io_projection patches [2] to use the Io/IoCapable/View infrastructure.
This patch has been used in Boot GSP with vGPU enabled series [3].
This patch introduces ExtCapability<T>, which implements the Io trait for PCI extended capability regions. It delegates IoCapable to the underlying ConfigSpace, so io_project!/io_read!/io_write! work directly on capability register structs. ExtSriovRegs provides the #[repr(C)] SR-IOV register layout, and ExtSriovCapability is a convenience alias.
Changes since RFC v2:
- Hardened calculate_ext_cap_size() against corrupt capability lists.
- Added // INVARIANT: comments at all ExtCapability construction sites (make_ext_capability and cast_sized).
- Added #[inline] to small forwarding methods (find, read_vf_bar64)
Changes since RFC:
- Rebased on io_projection branch, using Gary's Io/IoCapable traits
- ExtCapability implements Io and delegates IoCapable to ConfigSpace instead of duplicating config read/write logic
- Dropped the fallible I/O patch (now upstream in this tree)
- Added rust helper for PCI_EXT_CAP_NEXT() macro
- Replaced raw as casts with From conversions where possible
- Renamed SriovRegs/SriovCapability to ExtSriovRegs/ExtSriovCapability
[1] https://lore.kernel.org/rust-for-linux/[email protected]/
[2] https://lore.kernel.org/rust-for-linux/[email protected]/
[3] https://lore.kernel.org/rust-for-linux/[email protected]/
Zhi Wang (1):
rust: pci: add extended capability and SR-IOV support
rust/helpers/pci.c | 5 + rust/kernel/pci.rs | 7 ++ rust/kernel/pci/cap.rs | 256 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 268 insertions(+) create mode 100644 rust/kernel/pci/cap.rs
base-commit: 016f794f04888a304322c746b0a7794888d86e21
Signature · 1 line
2.51.0
PATCH v3 1/1 rust: pci: add extended capability and SR-IOV support
Introduce extended PCI capability support in rust PCI abstraction.
Implement ExtCapability<T> for PCI extended capability regions. It delegates IoCapable to the underlying ConfigSpace, so io_project!/io_read! /io_write! work directly on capability register structs.
Also add a rust helper for the PCI_EXT_CAP_NEXT() macro.
--- rust/helpers/pci.c | 5 + rust/kernel/pci.rs | 7 ++ rust/kernel/pci/cap.rs | 256 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 268 insertions(+) create mode 100644 rust/kernel/pci/cap.rs
rust/helpers/pci.c +5 -0
@@ -24,6 +24,11 @@ __rust_helper bool rust_helper_dev_is_pci(const struct device *dev)return dev_is_pci (dev); } +__rust_helper u32 rust_helper_pci_ext_cap_next(u32 header) +{ +return PCI_EXT_CAP_NEXT (header); +} +#ifndef CONFIG_PCI_MSI __rust_helper int rust_helper_pci_alloc_irq_vectors(struct pci_dev *dev, unsigned int min_vecs,
rust/kernel/pci.rs +7 -0
@@ -31,10 +31,17 @@ }, }; +mod cap;mod id;mod io;mod irq; +pub use self::cap::{ +ExtCapId , +ExtCapability , +ExtSriovCapability , +ExtSriovRegs ,// +};pub use self::id::{Class ,ClassMask ,
rust/kernel/pci/cap.rs new file +256 -0
256 lines not on this page · raw message
Signature · 1 line
2.51.0
Alexandre Courbot
reviewerRe: [PATCH v3 1/1] rust: pci: add extended capability and SR-IOV support
Hi Zhi,
On Fri Apr 10, 2026 at 3:52 AM JST, Zhi Wang wrote:
<snip>
Quoted 23 lines
rust/kernel/pci/cap.rs new file +23
-0+/// An extended PCI capability that implements [`Io`]. +/// +/// # Examples +/// +/// ```no_run +/// use kernel::pci::{ +/// self, +/// ExtSriovCapability, // +/// }; +/// use kernel::io::Io; +/// +/// fn probe_sriov(pdev: &pci::Device<kernel::device::Core>) -> Result<(), kernel::error::Error> { +/// let config = pdev.config_space_extended()?; +/// let sriov = ExtSriovCapability::find(&config)?; +/// +/// let total_vfs = kernel::io_read!(&sriov, .total_vfs); +/// let vf_offset = kernel::io_read!(&sriov, .vf_offset); +/// let bar0 = kernel::io_read!(&sriov, .vf_bar[0]); +/// kernel::io_write!(&sriov, .num_vfs, 4u16); +/// let bar0_64 = sriov.read_vf_bar64(0)?; +/// +/// Ok(()) +/// }
rust/kernel/pci/cap.rs line 67
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+/// ``` +/// +/// # Invariants +/// +/// `ptr` is within the device's extended configuration space at a valid +/// capability. For sized `T`, the region is at least `size_of::<T>()` bytes. +pub struct ExtCapability <'a,T : ?Sized +KnownSize =Region <0 >> { + config: &'aConfigSpace <'a,Extended >, + ptr: *mut T , +}
This strongly looks like this is reinventing io::View. :) Even the internals look similar. Can you check whether io::View can replace this type? This would remove all the macro business and impl blocks and simplify this patch considerably.
Quoted 39 lines
rust/kernel/pci/cap.rs new file +39
-0+ +impl <T : ?Sized +KnownSize >Io for ExtCapability <'_,T > { +type Type =T ; + +#[inline] +fn as_ptr (&self) -> *mut T { + self.ptr + } +} + +macro_rules! impl_ext_cap_io_capable { + ($ty:ty) => { +impl <T : ?Sized +KnownSize >IoCapable <$ty>for ExtCapability <'_,T > { +#[inline] +unsafe fn io_read (&self, address: *mut $ty) -> $ty { +// SAFETY: The caller guarantees `address` is within bounds of +// this capability, which is within the config space. +unsafe { self.config.io_read (address) } + } + +#[inline] +unsafe fn io_write (&self, value: $ty, address: *mut $ty) { +// SAFETY: The caller guarantees `address` is within bounds of +// this capability, which is within the config space. +unsafe { self.config.io_write (value, address) } + } + } + }; +} + +impl_ext_cap_io_capable! (u8 ); +impl_ext_cap_io_capable! (u16 ); +impl_ext_cap_io_capable! (u32 ); + +impl <'a>ExtCapability <'a> { +/// Base offset of this capability in configuration space. +#[inline] +pub fn offset (&self) ->usize { + self.ptr.addr ()
rust/kernel/pci/cap.rs line 116
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+ } + +/// Size of this capability region in bytes. +#[inline] +pub fn size (&self) ->usize { +KnownSize ::size (self.ptr) + } + +/// Cast to a typed capability, checking that the region is large enough. +pub fn cast_sized <U >(self) ->Result <ExtCapability <'a,U >> {
This allows for any cast, including invalid ones, as long as U fits. While not unsafe, this is still incorrect - I don't see any reason to make this public, which could be a way to mitigate this.
Quoted 23 lines
rust/kernel/pci/cap.rs new file +23
-0+if self.size () < core::mem::size_of ::<U >() { +return Err (EINVAL ); + } + +// INVARIANT: `self` already satisfies the invariant (ptr is within extended config +// space at a valid capability), and the size check above guarantees the region is at +// least `size_of::<U>()` bytes. +Ok (ExtCapability { + config: self.config, + ptr: core::ptr::without_provenance_mut (self.offset ()), + }) + } +} + +impl ConfigSpace <'_,Extended > { +/// Finds an extended capability by ID, returning an untyped [`ExtCapability`]. +pub fn find_ext_capability (&self, cap:ExtCapId ) ->Result <ExtCapability <'_>> { +let offset = usize::from ( +// SAFETY: `self.pdev` is valid by the type invariant of `ConfigSpace`. +unsafe { + bindings::pci_find_ext_capability (self.pdev.as_raw (), i32::from (cap.as_raw ())) + }, + );
rust/kernel/pci/cap.rs line 149
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+ +if offset ==0 { +return Err (ENODEV ); + } + +Ok (self.make_ext_capability (offset)) + } + +/// Finds the next extended capability with `cap` after `start`. +pub fn find_next_ext_capability (&self, start:u16 , cap:ExtCapId ) ->Result <ExtCapability <'_>> {
This start offset can be anything and potentially lead to invalid results being returned (I don't know what the C binding does, but assuming the worst for safety).
Listing capabilities should be done through an iterator as it provides all their benefits to users. I understand we also want a find API to look for a specific capability and that an iterator is not needed for this, but if we end up providing a way to list them, it should be through an iterator.
In any case, this method seems to be unused, so you can safely drop it for now.
Quoted 18 lines
rust/kernel/pci/cap.rs new file +18
-0+let offset = usize::from ( +// SAFETY: `self.pdev` is valid by the type invariant of `ConfigSpace`. +unsafe { + bindings::pci_find_next_ext_capability ( + self.pdev.as_raw (), + start, + i32::from (cap.as_raw ()), + ) + }, + ); + +if offset ==0 { +return Err (ENODEV ); + } + +Ok (self.make_ext_capability (offset)) + } +
rust/kernel/pci/cap.rs line 177
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+fn make_ext_capability (&self, offset:usize ) ->ExtCapability <'_> { +let size = self.calculate_ext_cap_size (offset); + +let ptr = core::ptr::slice_from_raw_parts_mut ::<u8 >( + core::ptr::without_provenance_mut (offset), + size, +// CAST: `Region<0>` is a DST like `[u8]`, so this pointer cast preserves metadata. + )as *mut Region <0 >; + +// INVARIANT: `offset` was returned by `pci_find_ext_capability` /
This method cannot make assumptions about the origin of its arguments without being unsafe, as its correct behavior depends on the goodwill of the caller. Given that we will drop find_next_ext_capability, the code can be rolled into find_ext_capability which is now the only user.
rust/kernel/pci/cap.rs line 184
Quoted 7 lines
rust/kernel/pci/cap.rs new file +7
-0+// `pci_find_next_ext_capability`, which guarantees it points to a valid capability +// within the extended configuration space. `size` is bounded by the next capability +// offset or the end of the configuration space. +ExtCapability { config: self, ptr } + } + +fn calculate_ext_cap_size (&self, offset:usize ) ->usize {
This method lacks documentation.
Quoted 50 lines
rust/kernel/pci/cap.rs new file +50
-0+let header = self.try_read32 (offset).unwrap_or (0 ); +// SAFETY: Pure bit manipulation, no preconditions. +// CAST: The next-cap pointer is a 12-bit field (max 0xFFC), always fits in `usize`. +let next_ptr =unsafe { bindings::pci_ext_cap_next (header) }as usize ; + +if next_ptr > offset { + next_ptr - offset + }else { +KnownSize ::size (self.as_ptr ()) - offset + } + } +} + +/// SR-IOV register layout per PCIe spec (64 bytes starting at cap offset). +#[repr( C )] +pub struct ExtSriovRegs { +/// Extended capability header. +pub header:u32 , +/// SR-IOV capabilities. +pub cap:u32 , +/// SR-IOV control. +pub ctrl:u16 , +/// SR-IOV status. +pub status:u16 , +/// Initial VFs. +pub initial_vfs:u16 , +/// Total VFs. +pub total_vfs:u16 , +/// Number of VFs. +pub num_vfs:u16 , +/// Function dependency link. +pub func_dep_link:u16 , +/// First VF offset. +pub vf_offset:u16 , +/// VF stride. +pub vf_stride:u16 , + _reserved:u16 , +/// VF device ID. +pub vf_device_id:u16 , +/// Supported page sizes. +pub supported_page_sizes:u32 , +/// System page size. +pub system_page_size:u32 , +/// VF BARs (BAR0–BAR5). +pub vf_bar: [u32 ;6 ], +/// VF migration state array offset. +pub migration_state:u32 , +} + +/// SR-IOV capability. See [`ExtCapability`] for usage.
rust/kernel/pci/cap.rs line 244
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+pub type ExtSriovCapability <'a> =ExtCapability <'a,ExtSriovRegs >; + +impl ExtCapability <'_,ExtSriovRegs > { +/// Find the SR-IOV capability, or `ENODEV` if not present. +#[inline] +pub fn find <'a>( + config: &'aConfigSpace <'_,Extended >, + ) ->Result <ExtCapability <'a,ExtSriovRegs >> { + config.find_ext_capability (ExtCapId ::Sriov )?.cast_sized () + }
This method looks like it belongs to ConfigSpace, and should be generic. Something like
impl<'a> ConfigSpace<'a, Extended> {
pub fn find_ext_capability::<C: ExtCapability>(&self)
-> Result<io::View<...>>
}If we use io::View to return capabilities, we can recycle the ExtCapability name for a trait that provides the information required for find_ext_capability to work properly, like the associated constant for the capability ID. In this patch, it would be implemented on ExtSriovRegs, providing the projection of the view through C.
This also opens the way for a find_capability method that handles normal capabilities and is available to both variants of ConfigSpace. I am not saying this needs to be done in this patch though.
rust/kernel/pci/cap.rs line 249
Quoted 5 lines
rust/kernel/pci/cap.rs new file +5
-0+ +/// Reads a 64-bit VF BAR from two consecutive 32-bit slots. +#[inline] +pub fn read_vf_bar64 (&self, bar_index:usize ) ->Result <u64 > { +if bar_index >=5 {
Why is this value hardcoded? If this is correct, let's make it a constant with an informative name (and possibly a comment justifying its value).
rust/kernel/pci/cap.rs line 253
Quoted 4 lines
rust/kernel/pci/cap.rs new file +4
-0+return Err (EINVAL ); + } +let low =crate ::io_read!(self, .vf_bar[bar_index]?); +let high =crate ::io_read!(self, .vf_bar[bar_index +1 ]?);
Don't we want to check whether the bar in question is actually a 64-bit BAR?
I wonder whether this also doesn't call for an iterator-based solution returning an enum with the properly-sized BAR.
Re: [PATCH v3 1/1] rust: pci: add extended capability and SR-IOV support
Quoted 35 lines · On Mon, 13 Apr 2026 15:52:28 +0900 "Alexandre Courbot" <[email protected]>…
Hi Zhi,
On Fri Apr 10, 2026 at 3:52 AM JST, Zhi Wang wrote:
<snip>Quoted 31 lines
rust/kernel/pci/cap.rs new file +12
-0+/// An extended PCI capability that implements [`Io`]. +/// +/// # Examples +/// +/// ```no_run +/// use kernel::pci::{ +/// self, +/// ExtSriovCapability, // +/// }; +/// use kernel::io::Io; +/// +/// fn probe_sriov(pdev: &pci::Device<kernel::device::Core>) -> Result<(),
kernel::error::Error> { +/// let config =pdev.config_space_extended()?; +/// let sriov =ExtSriovCapability::find(&config)?; +///rust/kernel/pci/cap.rs new file +13
-0+/// let total_vfs = kernel::io_read!(&sriov, .total_vfs); +/// let vf_offset = kernel::io_read!(&sriov, .vf_offset); +/// let bar0 = kernel::io_read!(&sriov, .vf_bar[0]); +/// kernel::io_write!(&sriov, .num_vfs, 4u16); +/// let bar0_64 = sriov.read_vf_bar64(0)?; +/// +/// Ok(()) +/// } +/// ``` +/// +/// # Invariants +/// +/// `ptr` is within the device's extended configuration space at a valid +/// capability. For sized
T, the region is at leastsize_of::<T>()bytes. +pub struct ExtCapability<'a, T: ?Sized + KnownSize = Region<0>> {
Quoted 9 lines
rust/kernel/pci/cap.rs line 67
Quoted 3 lines
rust/kernel/pci/cap.rs new file +3
-0+ config: &'a ConfigSpace<'a, Extended>, + ptr: *mut T, +}This strongly looks like this is reinventing
io::View. :) Even the internals look similar. Can you check whetherio::Viewcan replace this type? This would remove all the macro business and impl blocks and simplify this patch considerably.
Thanks for catching this. This should be updated with Gary's patches posted in the mailing list. Will address this in V4.
Quoted 52 lines
Quoted 52 lines
rust/kernel/pci/cap.rs new file +13
-0+ +impl <T : ?Sized +KnownSize >Io for ExtCapability <'_,T > { +type Type =T ; + +#[inline] +fn as_ptr (&self) -> *mut T { + self.ptr + } +} + +macro_rules! impl_ext_cap_io_capable { + ($ty:ty) => { +impl <T : ?Sized +KnownSize >IoCapable <$ty>for ExtCapability<'_, T> {
rust/kernel/pci/cap.rs new file +3
-0+#[inline] +unsafe fn io_read (&self, address: *mut $ty) -> $ty { +// SAFETY: The caller guarantees `address` is within bounds of
+ // this capability, which is within the config
space.rust/kernel/pci/cap.rs new file +5
-0+unsafe { self.config.io_read (address) } + } + +#[inline] + unsafe fn io_write(&self, value: $ty, address: *mut$ty) {
+ // SAFETY: The caller guaranteesaddressis
within bounds of
+ // this capability, which is within the config
space.rust/kernel/pci/cap.rs new file +22
-0+unsafe { self.config.io_write (value, address) } + } + } + }; +} + +impl_ext_cap_io_capable! (u8 ); +impl_ext_cap_io_capable! (u16 ); +impl_ext_cap_io_capable! (u32 ); + +impl <'a>ExtCapability <'a> { +/// Base offset of this capability in configuration space. +#[inline] +pub fn offset (&self) ->usize { + self.ptr.addr () + } + +/// Size of this capability region in bytes. +#[inline] +pub fn size (&self) ->usize { +KnownSize ::size (self.ptr) + }
Quoted 9 lines
Quoted 4 lines
(quoted diff) +2
-0+ + /// Cast to a typed capability, checking that the region islarge enough.
+ pub fn cast_sized<U>(self) -> Result<ExtCapability<'a, U>> {This allows for any cast, including invalid ones, as long as
Ufits. While not unsafe, this is still incorrect - I don't see any reason to make this public, which could be a way to mitigate this.
Agreed. With the io::View rework above, cast_sized is gone. The size check can be done internally in find_sriov().
Quoted 47 lines
Quoted 39 lines
rust/kernel/pci/cap.rs new file +5
-0+if self.size () < core::mem::size_of ::<U >() { +return Err (EINVAL ); + } + +// INVARIANT: `self` already satisfies the invariant (ptr is within extended config
+ // space at a valid capability), and the size check above
guarantees the region is atrust/kernel/pci/cap.rs new file +10
-0+// least `size_of::<U>()` bytes. +Ok (ExtCapability { + config: self.config, + ptr: core::ptr::without_provenance_mut (self.offset ()), + }) + } +} + +impl ConfigSpace <'_,Extended > { +/// Finds an extended capability by ID, returning an untyped [
ExtCapability].
+ pub fnfind_ext_capability(&self, cap: ExtCapId)->
Result<ExtCapability<'_>> {(quoted diff) +2
-0+ let offset = usize::from( + // SAFETY: `self.pdev` is valid by the type invariantof
ConfigSpace.(quoted diff) +2
-0+ unsafe { +
bindings::pci_find_ext_capability(self.pdev.as_raw(), i32::from(cap.as_raw()))rust/kernel/pci/cap.rs new file +11
-0+ }, + ); + +if offset ==0 { +return Err (ENODEV ); + } + +Ok (self.make_ext_capability (offset)) + } + +/// Finds the next extended capability with `cap` after Quoted 3 lines
start.
+ pub fn find_next_ext_capability(&self, start: u16, cap:
ExtCapId) -> Result<ExtCapability<'_>> {This
startoffset can be anything and potentially lead to invalid results being returned (I don't know what the C binding does, but assuming the worst for safety).
Quoted 9 lines
Listing capabilities should be done through an iterator as it provides all their benefits to users. I understand we also want a
findAPI to look for a specific capability and that an iterator is not needed for this, but if we end up providing a way to list them, it should be through an iterator.In any case, this method seems to be unused, so you can safely drop it for now.
Dropped in v4.
Quoted 30 lines
Quoted 30 lines
(quoted diff) +2
-0+ let offset = usize::from( + // SAFETY: `self.pdev` is valid by the type invariantof
ConfigSpace.rust/kernel/pci/cap.rs new file +17
-0+unsafe { + bindings::pci_find_next_ext_capability ( + self.pdev.as_raw (), + start, + i32::from (cap.as_raw ()), + ) + }, + ); + +if offset ==0 { +return Err (ENODEV ); + } + +Ok (self.make_ext_capability (offset)) + } + + fn make_ext_capability(&self, offset: usize) ->ExtCapability<'_> {
rust/kernel/pci/cap.rs new file +6
-0+let size = self.calculate_ext_cap_size (offset); + +let ptr = core::ptr::slice_from_raw_parts_mut ::<u8 >( + core::ptr::without_provenance_mut (offset), + size, + // CAST: `Region<0>` is a DST like `[u8]`, so thispointer cast preserves metadata.
(quoted diff) +2
-0+ ) as *mut Region<0>; +
Quoted 9 lines
Quoted 2 lines
+ // INVARIANT:
offsetwas returned bypci_find_ext_capability/This method cannot make assumptions about the origin of its arguments without being
unsafe, as its correct behavior depends on the goodwill of the caller. Given that we will dropfind_next_ext_capability, the code can be rolled intofind_ext_capabilitywhich is now the only user.
Will inline it into find_ext_capability in v4.
Quoted 89 lines
rust/kernel/pci/cap.rs line 184
Quoted 9 lines
+ //
pci_find_next_ext_capability, which guarantees it
points to a valid capability
+ // within the extended configuration space.sizeis
bounded by the next capabilityrust/kernel/pci/cap.rs new file +5
-0+// offset or the end of the configuration space. +ExtCapability { config: self, ptr } + } + +fn calculate_ext_cap_size (&self, offset:usize ) ->usize {This method lacks documentation.
Quoted 51 lines
rust/kernel/pci/cap.rs new file +3
-0+let header = self.try_read32 (offset).unwrap_or (0 ); +// SAFETY: Pure bit manipulation, no preconditions. +// CAST: The next-cap pointer is a 12-bit field (max
0xFFC), always fits inusize.
+ letnext_ptr= unsafe {bindings::pci_ext_cap_next(header)
} as usize; +rust/kernel/pci/cap.rs new file +9
-0+if next_ptr > offset { + next_ptr - offset + }else { +KnownSize ::size (self.as_ptr ()) - offset + } + } +} + +/// SR-IOV register layout per PCIe spec (64 bytes starting at cap offset). +#[repr(C)]
rust/kernel/pci/cap.rs new file +35
-0+pub struct ExtSriovRegs { +/// Extended capability header. +pub header:u32 , +/// SR-IOV capabilities. +pub cap:u32 , +/// SR-IOV control. +pub ctrl:u16 , +/// SR-IOV status. +pub status:u16 , +/// Initial VFs. +pub initial_vfs:u16 , +/// Total VFs. +pub total_vfs:u16 , +/// Number of VFs. +pub num_vfs:u16 , +/// Function dependency link. +pub func_dep_link:u16 , +/// First VF offset. +pub vf_offset:u16 , +/// VF stride. +pub vf_stride:u16 , + _reserved:u16 , +/// VF device ID. +pub vf_device_id:u16 , +/// Supported page sizes. +pub supported_page_sizes:u32 , +/// System page size. +pub system_page_size:u32 , +/// VF BARs (BAR0–BAR5). +pub vf_bar: [u32 ;6 ], +/// VF migration state array offset. +pub migration_state:u32 , +} + +/// SR-IOV capability. See [`ExtCapability`] for usage. rust/kernel/pci/cap.rs line 244
Quoted 10 lines
rust/kernel/pci/cap.rs new file +10
-0+pub type ExtSriovCapability <'a> =ExtCapability <'a,ExtSriovRegs >; + +impl ExtCapability <'_,ExtSriovRegs > { +/// Find the SR-IOV capability, or `ENODEV` if not present. +#[inline] +pub fn find <'a>( + config: &'aConfigSpace <'_,Extended >, + ) ->Result <ExtCapability <'a,ExtSriovRegs >> { + config.find_ext_capability (ExtCapId ::Sriov )?.cast_sized () + }This method looks like it belongs to
ConfigSpace, and should be generic. Something likeimpl<'a> ConfigSpace<'a, Extended> { pub fn find_ext_capability::<C: ExtCapability>(&self) -> Result<io::View<...>> }If we use
io::Viewto return capabilities, we can recycle theExtCapabilityname for a trait that provides the information required forfind_ext_capabilityto work properly, like the associated constant for the capability ID. In this patch, it would be implemented onExtSriovRegs, providing the projection of the view throughC.
Quoted 5 lines
This also opens the way for a
find_capabilitymethod that handles normal capabilities and is available to both variants ofConfigSpace. I am not saying this needs to be done in this patch though.
I've moved find to ConfigSpace::find_sriov() for now. I agree the trait-based generics direction makes sense, but with only SR-IOV as a user today I'd prefer to defer that to a follow-up when we have a second capability type. :)
Quoted 10 lines
rust/kernel/pci/cap.rs line 249
Quoted 5 lines
rust/kernel/pci/cap.rs new file +5
-0+ +/// Reads a 64-bit VF BAR from two consecutive 32-bit slots. +#[inline] +pub fn read_vf_bar64 (&self, bar_index:usize ) ->Result <u64 > { +if bar_index >=5 {Why is this value hardcoded? If this is correct, let's make it a constant with an informative name (and possibly a comment justifying its value).
Sure. I changed it to use PCI_SRIOV_NUM_BARS.
Quoted 11 lines
rust/kernel/pci/cap.rs line 253
Quoted 5 lines
rust/kernel/pci/cap.rs new file +4
-0+return Err (EINVAL ); + } +let low =crate ::io_read!(self, .vf_bar[bar_index]?); +let high =crate ::io_read!(self, .vf_bar[bar_index +1 ]?);Don't we want to check whether the bar in question is actually a 64-bit BAR?
I wonder whether this also doesn't call for an iterator-based solution returning an enum with the properly-sized BAR.
Good point. I was assuming that the driver actually know its devcie support 64-bit bar or not. Do you prefer that we can have an iterator-based solution at this time? I think it makes the code looks nicer though. :)
Z.
Gary Guo
reviewerRe: [PATCH v3 1/1] rust: pci: add extended capability and SR-IOV support
Quoted 48 lines · Zhi Wang
Quoted 35 lines · On Mon, 13 Apr 2026 15:52:28 +0900 "Alexandre Courbot" <[email protected]>…
Hi Zhi,
On Fri Apr 10, 2026 at 3:52 AM JST, Zhi Wang wrote:
<snip>Quoted 31 lines
rust/kernel/pci/cap.rs new file +12
-0+/// An extended PCI capability that implements [`Io`]. +/// +/// # Examples +/// +/// ```no_run +/// use kernel::pci::{ +/// self, +/// ExtSriovCapability, // +/// }; +/// use kernel::io::Io; +/// +/// fn probe_sriov(pdev: &pci::Device<kernel::device::Core>) -> Result<(),
kernel::error::Error> { +/// let config =pdev.config_space_extended()?; +/// let sriov =ExtSriovCapability::find(&config)?; +///rust/kernel/pci/cap.rs new file +13
-0+/// let total_vfs = kernel::io_read!(&sriov, .total_vfs); +/// let vf_offset = kernel::io_read!(&sriov, .vf_offset); +/// let bar0 = kernel::io_read!(&sriov, .vf_bar[0]); +/// kernel::io_write!(&sriov, .num_vfs, 4u16); +/// let bar0_64 = sriov.read_vf_bar64(0)?; +/// +/// Ok(()) +/// } +/// ``` +/// +/// # Invariants +/// +/// `ptr` is within the device's extended configuration space at a valid +/// capability. For sized
T, the region is at leastsize_of::<T>()bytes. +pub struct ExtCapability<'a, T: ?Sized + KnownSize = Region<0>> {Quoted 9 lines
rust/kernel/pci/cap.rs line 67
Quoted 3 lines
rust/kernel/pci/cap.rs new file +3
-0+ config: &'a ConfigSpace<'a, Extended>, + ptr: *mut T, +}This strongly looks like this is reinventing
io::View. :) Even the internals look similar. Can you check whetherio::Viewcan replace this type? This would remove all the macro business and impl blocks and simplify this patch considerably.
Quoted 2 lines
Thanks for catching this. This should be updated with Gary's patches posted in the mailing list. Will address this in V4.
I'll rebase my series and resend this week.
Best,
Gary
Alexandre Courbot
reviewerRe: [PATCH v3 1/1] rust: pci: add extended capability and SR-IOV support
In reply to Zhi WangOn Mon Apr 20, 2026 at 7:13 PM JST, Zhi Wang wrote:
<snip>
Quoted 9 lines
Quoted 9 lines
rust/kernel/pci/cap.rs line 253
Quoted 5 lines
rust/kernel/pci/cap.rs new file +4
-0+return Err (EINVAL ); + } +let low =crate ::io_read!(self, .vf_bar[bar_index]?); +let high =crate ::io_read!(self, .vf_bar[bar_index +1 ]?);Don't we want to check whether the bar in question is actually a 64-bit BAR?
Quoted 7 lines
Quoted 2 lines
I wonder whether this also doesn't call for an iterator-based solution returning an enum with the properly-sized BAR.
Good point. I was assuming that the driver actually know its devcie support 64-bit bar or not. Do you prefer that we can have an iterator-based solution at this time? I think it makes the code looks nicer though. :)
It really depends on how this code is used. If we are going through the list of BARs in client code, then yes, and iterator would be the idiomatic solution.