* [PATCH v2 1/8] rust: pci: add {enable,disable}_sriov(), to control SR-IOV capability
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-25 20:43 ` Peter Colberg
2026-09-24 19:05 ` [PATCH v2 2/8] rust: pci: add vtable attribute to pci::Driver trait Zhi Wang
` (6 subsequent siblings)
7 siblings, 1 reply; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add methods to enable and disable the Single Root I/O Virtualization
(SR-IOV) capability for a PCI device. The wrapped C methods take care
of validating whether the device is a Physical Function (PF), whether
SR-IOV is currently disabled (or enabled), and whether the number of
requested VFs does not exceed the total number of supported VFs.
Synchronously disable SR-IOV in the Rust PCI remove callback before
unbinding the PF driver. This ensures that when a Virtual
Function (VF) is bound to a driver, the corresponding Physical Function
(PF) is bound to a driver, too, which is a prerequisite for exposing a
safe Rust API that allows a VF driver to obtain the PF device for a VF
device and subsequently access the private data of the PF driver.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
rust/kernel/pci.rs | 36 ++++++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 3ec897709e89..e6dac919f02d 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -133,6 +133,10 @@ extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
// INVARIANT: `pdev` is valid for the duration of `remove_callback()`.
let pdev = unsafe { &*pdev.cast::<Device<device::CoreInternal<'_>>>() };
+ // Keep PF data installed until all VF remove callbacks have completed.
+ #[cfg(CONFIG_PCI_IOV)]
+ pdev.disable_sriov();
+
// SAFETY: `remove_callback` is only ever called after a successful call to
// `probe_callback`, hence it's guaranteed that `Device::set_drvdata()` has been called
// and stored a `Pin<KBox<T::Data<'_>>>`.
@@ -472,6 +476,38 @@ pub fn set_master(&self) {
// SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`.
unsafe { bindings::pci_set_master(self.as_raw()) };
}
+
+ /// Enable the Single Root I/O Virtualization (SR-IOV) capability for this device,
+ /// where `nr_virtfn` is number of Virtual Functions (VF) to enable.
+ #[cfg(CONFIG_PCI_IOV)]
+ pub fn enable_sriov(&self, nr_virtfn: i32) -> Result {
+ // SAFETY:
+ // `self.as_raw` returns a valid pointer to a `struct pci_dev`.
+ //
+ // `pci_enable_sriov()` checks that the enable operation is valid:
+ // - the device is a Physical Function (PF),
+ // - SR-IOV is currently disabled, and
+ // - `nr_virtfn` does not exceed the total number of supported VFs.
+ //
+ // The Core device context inherits from the Bound device context,
+ // which guarantees that the PF device is bound to a driver.
+ to_result(unsafe { bindings::pci_enable_sriov(self.as_raw(), nr_virtfn) })
+ }
+
+ /// Disable the Single Root I/O Virtualization (SR-IOV) capability for this device.
+ #[cfg(CONFIG_PCI_IOV)]
+ pub fn disable_sriov(&self) {
+ // SAFETY:
+ // `self.as_raw` returns a valid pointer to a `struct pci_dev`.
+ //
+ // `pci_disable_sriov()` checks that the disable operation is valid:
+ // - the device is a Physical Function (PF), and
+ // - SR-IOV is currently enabled.
+ //
+ // The Core device context inherits from the Bound device context,
+ // which guarantees that the PF device is bound to a driver.
+ unsafe { bindings::pci_disable_sriov(self.as_raw()) };
+ }
}
// SAFETY: `pci::Device` is a transparent wrapper of `struct pci_dev`.
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v2 1/8] rust: pci: add {enable,disable}_sriov(), to control SR-IOV capability
2026-09-24 19:05 ` [PATCH v2 1/8] rust: pci: add {enable,disable}_sriov(), to control SR-IOV capability Zhi Wang
@ 2026-09-25 20:43 ` Peter Colberg
0 siblings, 0 replies; 10+ messages in thread
From: Peter Colberg @ 2026-09-25 20:43 UTC (permalink / raw)
To: Zhi Wang
Cc: rust-for-linux, linux-pci, linux-kernel, dakr, aliceryhl,
bhelgaas, kwilczynski, ojeda, boqun, gary, bjorn3_gh, lossin,
a.hindborg, tmgross, markus.probst, cjia, smitra, ankita,
aniketa, kwankhede, targupta, kjaju, alkumar, acourbot, jhubbard,
zhiwang, jgg, alex, Peter Colberg
Hi Zhi,
On Thu, Sep 24, 2026 at 10:05:48PM +0300, Zhi Wang wrote:
> From: Peter Colberg <pcolberg@redhat.com>
Thank you for updating the series and apologies for the silence.
As part of the next revision, could you please update my email address
in all patches, which has changed (for kernel contributions only):
From: Peter Colberg <peter@colberg.org>
Thanks,
Peter
>
> Add methods to enable and disable the Single Root I/O Virtualization
> (SR-IOV) capability for a PCI device. The wrapped C methods take care
> of validating whether the device is a Physical Function (PF), whether
> SR-IOV is currently disabled (or enabled), and whether the number of
> requested VFs does not exceed the total number of supported VFs.
>
> Synchronously disable SR-IOV in the Rust PCI remove callback before
> unbinding the PF driver. This ensures that when a Virtual
> Function (VF) is bound to a driver, the corresponding Physical Function
> (PF) is bound to a driver, too, which is a prerequisite for exposing a
> safe Rust API that allows a VF driver to obtain the PF device for a VF
> device and subsequently access the private data of the PF driver.
>
> Suggested-by: Danilo Krummrich <dakr@kernel.org>
> Signed-off-by: Peter Colberg <pcolberg@redhat.com>
> Signed-off-by: Zhi Wang <zhiw@nvidia.com>
> ---
> rust/kernel/pci.rs | 36 ++++++++++++++++++++++++++++++++++++
> 1 file changed, 36 insertions(+)
>
> diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
> index 3ec897709e89..e6dac919f02d 100644
> --- a/rust/kernel/pci.rs
> +++ b/rust/kernel/pci.rs
> @@ -133,6 +133,10 @@ extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
> // INVARIANT: `pdev` is valid for the duration of `remove_callback()`.
> let pdev = unsafe { &*pdev.cast::<Device<device::CoreInternal<'_>>>() };
>
> + // Keep PF data installed until all VF remove callbacks have completed.
> + #[cfg(CONFIG_PCI_IOV)]
> + pdev.disable_sriov();
> +
> // SAFETY: `remove_callback` is only ever called after a successful call to
> // `probe_callback`, hence it's guaranteed that `Device::set_drvdata()` has been called
> // and stored a `Pin<KBox<T::Data<'_>>>`.
> @@ -472,6 +476,38 @@ pub fn set_master(&self) {
> // SAFETY: `self.as_raw` is guaranteed to be a pointer to a valid `struct pci_dev`.
> unsafe { bindings::pci_set_master(self.as_raw()) };
> }
> +
> + /// Enable the Single Root I/O Virtualization (SR-IOV) capability for this device,
> + /// where `nr_virtfn` is number of Virtual Functions (VF) to enable.
> + #[cfg(CONFIG_PCI_IOV)]
> + pub fn enable_sriov(&self, nr_virtfn: i32) -> Result {
> + // SAFETY:
> + // `self.as_raw` returns a valid pointer to a `struct pci_dev`.
> + //
> + // `pci_enable_sriov()` checks that the enable operation is valid:
> + // - the device is a Physical Function (PF),
> + // - SR-IOV is currently disabled, and
> + // - `nr_virtfn` does not exceed the total number of supported VFs.
> + //
> + // The Core device context inherits from the Bound device context,
> + // which guarantees that the PF device is bound to a driver.
> + to_result(unsafe { bindings::pci_enable_sriov(self.as_raw(), nr_virtfn) })
> + }
> +
> + /// Disable the Single Root I/O Virtualization (SR-IOV) capability for this device.
> + #[cfg(CONFIG_PCI_IOV)]
> + pub fn disable_sriov(&self) {
> + // SAFETY:
> + // `self.as_raw` returns a valid pointer to a `struct pci_dev`.
> + //
> + // `pci_disable_sriov()` checks that the disable operation is valid:
> + // - the device is a Physical Function (PF), and
> + // - SR-IOV is currently enabled.
> + //
> + // The Core device context inherits from the Bound device context,
> + // which guarantees that the PF device is bound to a driver.
> + unsafe { bindings::pci_disable_sriov(self.as_raw()) };
> + }
> }
>
> // SAFETY: `pci::Device` is a transparent wrapper of `struct pci_dev`.
> --
> 2.53.0
>
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH v2 2/8] rust: pci: add vtable attribute to pci::Driver trait
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
2026-09-24 19:05 ` [PATCH v2 1/8] rust: pci: add {enable,disable}_sriov(), to control SR-IOV capability Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 3/8] rust: pci: add is_virtfn(), to check for VFs Zhi Wang
` (5 subsequent siblings)
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add the #[vtable] attribute to pci::Driver trait and implementations,
to prepare a subsequent patch that adds an optional bus callback
sriov_configure() to enable or disable the SR-IOV capability.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
drivers/gpu/nova-core/driver.rs | 1 +
rust/kernel/pci.rs | 2 ++
samples/rust/rust_dma.rs | 1 +
samples/rust/rust_driver_auxiliary.rs | 1 +
samples/rust/rust_driver_pci.rs | 1 +
5 files changed, 6 insertions(+)
diff --git a/drivers/gpu/nova-core/driver.rs b/drivers/gpu/nova-core/driver.rs
index cf3534dd47d4..47a599c9ea4f 100644
--- a/drivers/gpu/nova-core/driver.rs
+++ b/drivers/gpu/nova-core/driver.rs
@@ -63,6 +63,7 @@ pub(crate) struct NovaCore<'bound> {
]
);
+#[vtable]
impl pci::Driver for NovaCoreDriver {
type IdInfo = ();
type Data<'bound> = NovaCore<'bound>;
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index e6dac919f02d..622cf91fe5e3 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -276,6 +276,7 @@ macro_rules! pci_device_table {
/// ]
/// );
///
+/// #[vtable]
/// impl pci::Driver for MyDriver {
/// type IdInfo = ();
/// type Data<'bound> = Self;
@@ -291,6 +292,7 @@ macro_rules! pci_device_table {
///```
/// Drivers must implement this trait in order to get a PCI driver registered. Please refer to the
/// `Adapter` documentation for an example.
+#[vtable]
pub trait Driver {
/// The type holding information about each device id supported by the driver.
// TODO: Use `associated_type_defaults` once stabilized:
diff --git a/samples/rust/rust_dma.rs b/samples/rust/rust_dma.rs
index ffb693544673..804d55a63005 100644
--- a/samples/rust/rust_dma.rs
+++ b/samples/rust/rust_dma.rs
@@ -69,6 +69,7 @@ unsafe impl kernel::transmute::FromBytes for MyStruct {}
[(pci::DeviceId::from_id(pci::Vendor::REDHAT, 0x5), ())]
);
+#[vtable]
impl pci::Driver for DmaSampleDriver {
type IdInfo = ();
type Data<'bound> = DmaSampleData<'bound>;
diff --git a/samples/rust/rust_driver_auxiliary.rs b/samples/rust/rust_driver_auxiliary.rs
index 0bee16faecc6..6cff9bf8c80c 100644
--- a/samples/rust/rust_driver_auxiliary.rs
+++ b/samples/rust/rust_driver_auxiliary.rs
@@ -90,6 +90,7 @@ struct ParentData<'bound> {
[(pci::DeviceId::from_id(pci::Vendor::REDHAT, 0x5), ())]
);
+#[vtable]
impl pci::Driver for ParentDriver {
type IdInfo = ();
type Data<'bound> = ParentData<'bound>;
diff --git a/samples/rust/rust_driver_pci.rs b/samples/rust/rust_driver_pci.rs
index 13b035a95756..50c8709739c6 100644
--- a/samples/rust/rust_driver_pci.rs
+++ b/samples/rust/rust_driver_pci.rs
@@ -139,6 +139,7 @@ fn config_space(pdev: &pci::Device<Bound>) {
}
}
+#[vtable]
impl pci::Driver for SampleDriver {
type IdInfo = TestIndex;
type Data<'bound> = SampleDriverData<'bound>;
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 3/8] rust: pci: add is_virtfn(), to check for VFs
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
2026-09-24 19:05 ` [PATCH v2 1/8] rust: pci: add {enable,disable}_sriov(), to control SR-IOV capability Zhi Wang
2026-09-24 19:05 ` [PATCH v2 2/8] rust: pci: add vtable attribute to pci::Driver trait Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 4/8] rust: pci: add is_physfn(), to check for PFs Zhi Wang
` (4 subsequent siblings)
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Alistair Popple,
Joel Fernandes, Peter Colberg, Zhi Wang
From: John Hubbard <jhubbard@nvidia.com>
Add a method to check if a PCI device is a Virtual Function (VF) created
through Single Root I/O Virtualization (SR-IOV).
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
Reviewed-by: Alistair Popple <apopple@nvidia.com>
Reviewed-by: Joel Fernandes <joelagnelf@nvidia.com>
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
rust/kernel/pci.rs | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 622cf91fe5e3..b04f6aff6c34 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -433,6 +433,14 @@ pub fn resource_start(&self, bar: u32) -> Result<bindings::resource_size_t> {
Ok(unsafe { bindings::pci_resource_start(self.as_raw(), bar.try_into()?) })
}
+ /// Returns `true` if this device is a Virtual Function (VF).
+ #[inline]
+ #[expect(dead_code)]
+ pub(crate) fn is_virtfn(&self) -> bool {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
+ unsafe { (*self.as_raw()).is_virtfn() != 0 }
+ }
+
/// Returns the size of the given PCI BAR resource.
pub fn resource_len(&self, bar: u32) -> Result<bindings::resource_size_t> {
if !Bar::index_is_valid(bar) {
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 4/8] rust: pci: add is_physfn(), to check for PFs
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
` (2 preceding siblings ...)
2026-09-24 19:05 ` [PATCH v2 3/8] rust: pci: add is_virtfn(), to check for VFs Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 5/8] rust: pci: add num_vf(), to return number of VFs Zhi Wang
` (3 subsequent siblings)
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg,
Joel Fernandes, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add a method to check if a PCI device is a Physical Function (PF).
zhiw: Keep this role check private to the PCI SR-IOV implementation
instead of extending the public `Device` API. Add a dead-code
expectation because this standalone API commit has no in-tree caller.
Reviewed-by: Joel Fernandes <joelagnelf@nvidia.com>
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
rust/kernel/pci.rs | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index b04f6aff6c34..ca009775bd61 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -433,6 +433,14 @@ pub fn resource_start(&self, bar: u32) -> Result<bindings::resource_size_t> {
Ok(unsafe { bindings::pci_resource_start(self.as_raw(), bar.try_into()?) })
}
+ /// Returns `true` if this device is a Physical Function (PF).
+ #[inline]
+ #[expect(dead_code)]
+ pub(crate) fn is_physfn(&self) -> bool {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
+ unsafe { (*self.as_raw()).is_physfn() != 0 }
+ }
+
/// Returns `true` if this device is a Virtual Function (VF).
#[inline]
#[expect(dead_code)]
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 5/8] rust: pci: add num_vf(), to return number of VFs
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
` (3 preceding siblings ...)
2026-09-24 19:05 ` [PATCH v2 4/8] rust: pci: add is_physfn(), to check for PFs Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 6/8] rust: pci: add bus callback sriov_configure(), to control SR-IOV from sysfs Zhi Wang
` (2 subsequent siblings)
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add a method to return the number of Virtual Functions (VF) enabled for
a Physical Function (PF).
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
rust/kernel/pci.rs | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index ca009775bd61..db0554f14afc 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -449,6 +449,14 @@ pub(crate) fn is_virtfn(&self) -> bool {
unsafe { (*self.as_raw()).is_virtfn() != 0 }
}
+ /// Returns the number of Virtual Functions (VF) enabled for a Physical Function (PF).
+ #[cfg(CONFIG_PCI_IOV)]
+ #[expect(dead_code)]
+ pub(crate) fn num_vf(&self) -> i32 {
+ // SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
+ unsafe { bindings::pci_num_vf(self.as_raw()) }
+ }
+
/// Returns the size of the given PCI BAR resource.
pub fn resource_len(&self, bar: u32) -> Result<bindings::resource_size_t> {
if !Bar::index_is_valid(bar) {
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 6/8] rust: pci: add bus callback sriov_configure(), to control SR-IOV from sysfs
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
` (4 preceding siblings ...)
2026-09-24 19:05 ` [PATCH v2 5/8] rust: pci: add num_vf(), to return number of VFs Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 7/8] rust: pci: add typed SR-IOV PF registration data Zhi Wang
2026-09-24 19:05 ` [PATCH v2 8/8] samples: rust: add Rust SR-IOV VF driver sample Zhi Wang
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add an optional bus callback sriov_configure() to pci::Driver trait,
using the vtable attribute to query if the driver implements the
callback. The callback is invoked when a user-space application
writes the number of VFs to the sysfs file `sriov_numvfs` to
enable SR-IOV, or zero to disable SR-IOV for a PCI device.
Invoke the callback with zero before PF unbind so drivers can release
their SR-IOV resources, including runtime-PM references. Disable any
remaining VFs before releasing the PF driver data.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
rust/kernel/pci.rs | 65 ++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 63 insertions(+), 2 deletions(-)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index db0554f14afc..cb3ed2207075 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -84,6 +84,10 @@ unsafe fn register(
(*pdrv.get()).probe = Some(Self::probe_callback);
(*pdrv.get()).remove = Some(Self::remove_callback);
(*pdrv.get()).id_table = T::ID_TABLE.as_ptr();
+ #[cfg(CONFIG_PCI_IOV)]
+ if T::HAS_SRIOV_CONFIGURE {
+ (*pdrv.get()).sriov_configure = Some(Self::sriov_configure_callback);
+ }
}
// SAFETY: `pdrv` is guaranteed to be a valid `DriverType`.
@@ -135,7 +139,13 @@ extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
// Keep PF data installed until all VF remove callbacks have completed.
#[cfg(CONFIG_PCI_IOV)]
- pdev.disable_sriov();
+ if pdev.num_vf() != 0 {
+ if T::HAS_SRIOV_CONFIGURE {
+ Self::sriov_configure_callback(pdev.as_raw(), 0);
+ crate::warn_on!(pdev.num_vf() != 0);
+ }
+ pdev.disable_sriov();
+ }
// SAFETY: `remove_callback` is only ever called after a successful call to
// `probe_callback`, hence it's guaranteed that `Device::set_drvdata()` has been called
@@ -144,6 +154,20 @@ extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
T::unbind(pdev, data);
}
+
+ #[cfg(CONFIG_PCI_IOV)]
+ extern "C" fn sriov_configure_callback(
+ pdev: *mut bindings::pci_dev,
+ nr_virtfn: c_int,
+ ) -> c_int {
+ // SAFETY: The PCI bus only ever calls the sriov_configure callback with a valid pointer to
+ // a `struct pci_dev`.
+ //
+ // INVARIANT: `pdev` is valid for the duration of `sriov_configure_callback()`.
+ let pdev = unsafe { &*pdev.cast::<Device<device::CoreInternal<'_>>>() };
+
+ from_result(|| T::sriov_configure(pdev, nr_virtfn))
+ }
}
/// Declares a kernel module that exposes a single PCI driver.
@@ -330,6 +354,44 @@ fn probe<'bound>(
fn unbind<'bound>(dev: &'bound Device<device::Core<'_>>, this: Pin<&Self::Data<'bound>>) {
let _ = (dev, this);
}
+
+ /// Single Root I/O Virtualization (SR-IOV) configure.
+ ///
+ /// Called when a user-space application enables or disables the SR-IOV capability for a
+ /// [`Device`] by writing the number of Virtual Functions (VF), `nr_virtfn` or zero to the
+ /// sysfs file `sriov_numvfs` for this device. Implementing this callback is optional.
+ ///
+ /// Further, and unlike for a PCI driver written in C, when a PF device with enabled VFs is
+ /// unbound from its bound [`Driver`], the `sriov_configure()` callback is invoked to disable
+ /// SR-IOV before the `unbind()` callback. This guarantees that when a VF device is bound to a
+ /// driver, the underlying PF device is bound to a driver, too.
+ ///
+ /// Upon success, this callback must return the number of VFs that were enabled, or zero if
+ /// SR-IOV was disabled.
+ ///
+ /// See [PCI Express I/O Virtualization].
+ ///
+ /// [PCI Express I/O Virtualization]: https://docs.kernel.org/PCI/pci-iov-howto.html
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use kernel::{device::Core, pci, prelude::*};
+ /// #[cfg(CONFIG_PCI_IOV)]
+ /// fn sriov_configure(dev: &pci::Device<Core<'_>>, nr_virtfn: i32) -> Result<i32> {
+ /// if nr_virtfn == 0 {
+ /// dev.disable_sriov();
+ /// } else {
+ /// dev.enable_sriov(nr_virtfn)?;
+ /// }
+ /// Ok(nr_virtfn)
+ /// }
+ /// ```
+ #[cfg(CONFIG_PCI_IOV)]
+ fn sriov_configure(dev: &Device<device::Core<'_>>, nr_virtfn: i32) -> Result<i32> {
+ let _ = (dev, nr_virtfn);
+ build_error!(crate::error::VTABLE_DEFAULT_ERROR)
+ }
}
/// The PCI device representation.
@@ -451,7 +513,6 @@ pub(crate) fn is_virtfn(&self) -> bool {
/// Returns the number of Virtual Functions (VF) enabled for a Physical Function (PF).
#[cfg(CONFIG_PCI_IOV)]
- #[expect(dead_code)]
pub(crate) fn num_vf(&self) -> i32 {
// SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
unsafe { bindings::pci_num_vf(self.as_raw()) }
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 7/8] rust: pci: add typed SR-IOV PF registration data
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
` (5 preceding siblings ...)
2026-09-24 19:05 ` [PATCH v2 6/8] rust: pci: add bus callback sriov_configure(), to control SR-IOV from sysfs Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
2026-09-24 19:05 ` [PATCH v2 8/8] samples: rust: add Rust SR-IOV VF driver sample Zhi Wang
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Zhi Wang
Rust PF and VF drivers bind to separate PCI devices and may reside
in different modules. A VF driver that calls PF operations needs
typed access to the data exposed by the PF driver. This data must
remain valid until VF driver removal completes.
Add `VfRegistration` to register a pinned Rust object in the PF's
driver data. Add accessors for VF drivers to borrow this object after
checking the requested Rust type. During registration teardown,
disable SR-IOV and wait for VF remove callbacks to finish before
dropping the object.
Co-developed-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
include/linux/pci.h | 7 ++
rust/kernel/pci.rs | 38 ++++--
rust/kernel/pci/sriov.rs | 253 +++++++++++++++++++++++++++++++++++++++
3 files changed, 290 insertions(+), 8 deletions(-)
create mode 100644 rust/kernel/pci/sriov.rs
diff --git a/include/linux/pci.h b/include/linux/pci.h
index d31a8d107b1e..9b6ae544469e 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -551,6 +551,13 @@ struct pci_dev {
u16 ats_cap; /* ATS Capability offset */
u8 ats_stu; /* ATS Smallest Translation Unit */
#endif
+#if defined(CONFIG_PCI_IOV) && defined(CONFIG_RUST)
+ /*
+ * Private data owned by the PF's Rust driver, readable by VF drivers
+ * through the PCI VF registration data Rust abstraction.
+ */
+ void *vf_registration_data_rust;
+#endif
#ifdef CONFIG_PCI_PRI
u16 pri_cap; /* PRI Capability offset */
u32 pri_reqs_alloc; /* Number of PRI requests allocated */
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index cb3ed2207075..831b76744a30 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -35,6 +35,8 @@
mod id;
mod io;
mod irq;
+#[cfg(CONFIG_PCI_IOV)]
+pub mod sriov;
pub use self::id::{
Class,
@@ -55,6 +57,8 @@
IrqVector,
IrqVectorRegistration, //
};
+#[cfg(CONFIG_PCI_IOV)]
+pub use self::sriov::VfRegistration;
/// An adapter for the registration of PCI drivers.
pub struct Adapter<T: Driver>(T);
@@ -166,7 +170,16 @@ extern "C" fn sriov_configure_callback(
// INVARIANT: `pdev` is valid for the duration of `sriov_configure_callback()`.
let pdev = unsafe { &*pdev.cast::<Device<device::CoreInternal<'_>>>() };
- from_result(|| T::sriov_configure(pdev, nr_virtfn))
+ // SAFETY: `sriov_configure` is called only after a successful probe and before unbind, so
+ // the stored pointer has type `T::Data<'_>` and remains valid throughout this callback.
+ let data = unsafe { pdev.as_ref().drvdata_borrow::<T::Data<'_>>() };
+
+ from_result(|| {
+ if !pdev.is_physfn() {
+ return Err(ENODEV);
+ }
+ T::sriov_configure(pdev, data, nr_virtfn)
+ })
}
}
@@ -377,8 +390,13 @@ fn unbind<'bound>(dev: &'bound Device<device::Core<'_>>, this: Pin<&Self::Data<'
///
/// ```
/// # use kernel::{device::Core, pci, prelude::*};
+ /// # struct Data;
/// #[cfg(CONFIG_PCI_IOV)]
- /// fn sriov_configure(dev: &pci::Device<Core<'_>>, nr_virtfn: i32) -> Result<i32> {
+ /// fn sriov_configure(
+ /// dev: &pci::Device<Core<'_>>,
+ /// _this: Pin<&Data>,
+ /// nr_virtfn: i32,
+ /// ) -> Result<i32> {
/// if nr_virtfn == 0 {
/// dev.disable_sriov();
/// } else {
@@ -388,8 +406,12 @@ fn unbind<'bound>(dev: &'bound Device<device::Core<'_>>, this: Pin<&Self::Data<'
/// }
/// ```
#[cfg(CONFIG_PCI_IOV)]
- fn sriov_configure(dev: &Device<device::Core<'_>>, nr_virtfn: i32) -> Result<i32> {
- let _ = (dev, nr_virtfn);
+ fn sriov_configure<'bound>(
+ dev: &'bound Device<device::Core<'_>>,
+ this: Pin<&Self::Data<'bound>>,
+ nr_virtfn: i32,
+ ) -> Result<i32> {
+ let _ = (dev, this, nr_virtfn);
build_error!(crate::error::VTABLE_DEFAULT_ERROR)
}
}
@@ -496,24 +518,24 @@ pub fn resource_start(&self, bar: u32) -> Result<bindings::resource_size_t> {
}
/// Returns `true` if this device is a Physical Function (PF).
+ #[cfg(CONFIG_PCI_IOV)]
#[inline]
- #[expect(dead_code)]
pub(crate) fn is_physfn(&self) -> bool {
// SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
unsafe { (*self.as_raw()).is_physfn() != 0 }
}
/// Returns `true` if this device is a Virtual Function (VF).
+ #[cfg(CONFIG_PCI_IOV)]
#[inline]
- #[expect(dead_code)]
- pub(crate) fn is_virtfn(&self) -> bool {
+ pub fn is_virtfn(&self) -> bool {
// SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
unsafe { (*self.as_raw()).is_virtfn() != 0 }
}
/// Returns the number of Virtual Functions (VF) enabled for a Physical Function (PF).
#[cfg(CONFIG_PCI_IOV)]
- pub(crate) fn num_vf(&self) -> i32 {
+ pub fn num_vf(&self) -> i32 {
// SAFETY: `self.as_raw` is a valid pointer to a `struct pci_dev`.
unsafe { bindings::pci_num_vf(self.as_raw()) }
}
diff --git a/rust/kernel/pci/sriov.rs b/rust/kernel/pci/sriov.rs
new file mode 100644
index 000000000000..90abe878f67c
--- /dev/null
+++ b/rust/kernel/pci/sriov.rs
@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Abstractions for PCI Single Root I/O Virtualization (SR-IOV) drivers.
+
+use super::Device as PciDevice;
+use crate::{
+ bindings,
+ device, //
+ prelude::*,
+ types::{
+ CovariantForLt,
+ ForLt, //
+ },
+};
+use core::{
+ any::TypeId,
+ marker::PhantomPinned, //
+};
+
+/// Wrapper for VF registration data stored inside a [`VfRegistration`].
+///
+/// Stores a [`TypeId`] header (derived from `F`) followed by the pinned data,
+/// so that [`PciDevice::vf_registration_data_with()`] can verify the type at
+/// runtime.
+#[repr(C)]
+#[pin_data]
+struct VfRegistrationData<'a, F: ForLt + 'static> {
+ type_id: TypeId,
+ #[pin]
+ data: F::Of<'a>,
+}
+
+static_assert!(
+ core::mem::offset_of!(VfRegistrationData<'static, CovariantForLt!(())>, type_id) == 0
+);
+
+impl<'a, F: ForLt + 'static> VfRegistrationData<'a, F> {
+ /// Pin-initializer for the registration data.
+ fn new<D>(data: D) -> impl PinInit<Self, Error> + use<'a, D, F>
+ where
+ D: PinInit<F::Of<'a>, Error> + 'a,
+ {
+ try_pin_init!(Self {
+ type_id: TypeId::of::<F>(),
+ data <- data,
+ })
+ }
+}
+
+/// SR-IOV VF registration on a PF device.
+///
+/// Owns the registration data that VF drivers access via
+/// [`PciDevice::vf_registration_data_with()`] and [`PciDevice::vf_registration_data()`].
+///
+/// The Rust PCI adapter removes all VFs before invoking the PF driver's unbind callback or
+/// dropping its data. Drop of a published registration calls `pci_disable_sriov()` before
+/// clearing the pointer and letting the data fields drop.
+#[pin_data(PinnedDrop)]
+pub struct VfRegistration<'a, F: ForLt + 'static> {
+ pdev: &'a PciDevice<device::Bound>,
+ #[pin]
+ inner: VfRegistrationData<'a, F>,
+ published: bool,
+ #[pin]
+ _pin: PhantomPinned,
+}
+
+impl<'a, F: ForLt + 'static> VfRegistration<'a, F>
+where
+ for<'b> F::Of<'b>: Send + Sync,
+{
+ /// Create a new VF registration.
+ ///
+ /// Returns a pin-initializer so the registration can be embedded directly
+ /// in the PF driver's bus device private data.
+ ///
+ /// # Safety
+ ///
+ /// The caller must ensure that the containing struct's field ordering drops
+ /// this `VfRegistration` before any resources that the registration data
+ /// borrows.
+ ///
+ /// The caller must invoke this during the PCI driver's probe and embed the result in the driver
+ /// data. On an SR-IOV PF, no VF may be enabled before probe successfully installs the complete
+ /// driver data.
+ pub unsafe fn new<'core, D>(
+ pdev: &'a PciDevice<device::Core<'core>>,
+ data: D,
+ ) -> impl PinInit<Self, Error> + use<'a, 'core, D, F>
+ where
+ D: PinInit<F::Of<'a>, Error> + 'a,
+ {
+ pin_init::pin_init_scope(move || {
+ if pdev.is_virtfn() {
+ return Err(ENODEV);
+ }
+
+ let published = pdev.is_physfn();
+ if published {
+ if pdev.num_vf() != 0 {
+ return Err(EBUSY);
+ }
+
+ if !pdev.vf_registration_data_rust().is_null() {
+ return Err(EBUSY);
+ }
+ }
+
+ Ok(try_pin_init!(Self {
+ pdev,
+ inner <- VfRegistrationData::new(data),
+ published,
+ _pin: PhantomPinned,
+ _: {
+ if *published {
+ // Store the pointer to the pinned `VfRegistrationData`
+ // on the PCI device so VF drivers can find it.
+ pdev.set_vf_registration_data_rust(
+ core::ptr::from_ref(inner.as_ref().get_ref()).cast_mut().cast(),
+ );
+ }
+ },
+ }))
+ })
+ }
+}
+
+#[pinned_drop]
+impl<F: ForLt + 'static> PinnedDrop for VfRegistration<'_, F> {
+ fn drop(self: Pin<&mut Self>) {
+ if !self.published {
+ return;
+ }
+
+ // SAFETY: `pci_disable_sriov()` is safe to call on any `pci_dev`; it
+ // is a no-op if the device has no VFs enabled. When VFs are enabled,
+ // this blocks until all VF `remove()` callbacks complete.
+ unsafe { bindings::pci_disable_sriov(self.pdev.as_raw()) };
+
+ // After `pci_disable_sriov()` all VFs are gone, so no one can read
+ // the pointer anymore.
+ self.pdev
+ .set_vf_registration_data_rust(core::ptr::null_mut());
+
+ // The pinned `inner` field is dropped automatically after this returns.
+ }
+}
+
+// SAFETY: The inner data is `Send` (enforced by the bound), and `&PciDevice` is `Send + Sync`.
+unsafe impl<F: ForLt> Send for VfRegistration<'_, F> where for<'a> F::Of<'a>: Send {}
+
+// SAFETY: The inner data is `Send + Sync`. `VfRegistration` doesn't expose mutable access;
+// VF drivers only read the data through an immutable pinned reference.
+unsafe impl<F: ForLt> Sync for VfRegistration<'_, F> where for<'a> F::Of<'a>: Send + Sync {}
+
+impl<Ctx: device::DeviceContext> PciDevice<Ctx> {
+ /// Returns the raw `vf_registration_data_rust` pointer from this device.
+ fn vf_registration_data_rust(&self) -> *mut core::ffi::c_void {
+ // SAFETY: `self.as_raw()` is valid.
+ unsafe { (*self.as_raw()).vf_registration_data_rust }
+ }
+
+ /// Sets the `vf_registration_data_rust` pointer on this device.
+ fn set_vf_registration_data_rust(&self, ptr: *mut core::ffi::c_void) {
+ // SAFETY: `self.as_raw()` is valid. PCI probe publishes the data before enabling VFs;
+ // teardown removes all VFs before withdrawing it.
+ unsafe { (*self.as_raw()).vf_registration_data_rust = ptr };
+ }
+}
+
+impl PciDevice<device::Bound> {
+ /// Returns the PF for this VF, or [`ENODEV`] if this is not a VF.
+ fn physfn(&self) -> Result<&PciDevice> {
+ if !self.is_virtfn() {
+ return Err(ENODEV);
+ }
+
+ // SAFETY: `self.as_raw()` is valid and this VF uses the `physfn` union field.
+ let pf = unsafe { (*self.as_raw()).__bindgen_anon_1.physfn };
+ if pf.is_null() {
+ return Err(ENODEV);
+ }
+
+ // SAFETY: PCI holds a PF reference until VF removal completes. The returned borrow
+ // cannot outlive this bound VF, and `PciDevice` is a transparent wrapper of `pci_dev`.
+ Ok(unsafe { &*pf.cast() })
+ }
+
+ /// Internal helper: reads the `vf_registration_data_rust` pointer from the
+ /// PF, checks the `TypeId`, and returns a pinned reference.
+ ///
+ /// # Safety
+ ///
+ /// The returned borrow must be confined by a closure higher-ranked independently over its
+ /// borrow and data lifetimes, or `F` must be covariant in its encoded lifetime.
+ unsafe fn vf_registration_data_pinned<F: ForLt + 'static>(&self) -> Result<Pin<&F::Of<'_>>> {
+ let pf = self.physfn()?;
+
+ let ptr = pf.vf_registration_data_rust();
+ if ptr.is_null() {
+ return Err(ENOENT);
+ }
+
+ // SAFETY: The Rust PCI adapter keeps the PF data installed until VF removal completes.
+ // `ptr` points to a `VfRegistrationData` whose first field is a `TypeId`.
+ let type_id = unsafe { ptr.cast::<TypeId>().read() };
+ if type_id != TypeId::of::<F>() {
+ return Err(EINVAL);
+ }
+
+ // SAFETY: TypeId check confirms the stored type matches `F`. The data
+ // is pinned inside the PF's driver data struct. Lifetime shortening
+ // from the PF's binding scope to `'_` is layout-compatible.
+ let data_ptr = unsafe {
+ let vfrd = ptr.cast::<VfRegistrationData<'_, F>>();
+ &raw const (*vfrd).data
+ };
+
+ // SAFETY: `data` is structurally pinned inside `VfRegistrationData`.
+ Ok(unsafe { Pin::new_unchecked(&*data_ptr) })
+ }
+
+ /// Access the VF registration data through a closure with an HRTB lifetime.
+ ///
+ /// `F` is the [`ForLt`](trait@ForLt) encoding of the data type. Returns
+ /// [`ENODEV`] if this is not a VF, [`ENOENT`] if no data was registered,
+ /// or [`EINVAL`] if `F` does not match the type registered by the PF.
+ ///
+ /// The closure's borrow and the registration data's lifetime are independent, so a borrow of
+ /// the context cannot be stored in invariant registration data.
+ pub fn vf_registration_data_with<F: ForLt + 'static, R>(
+ &self,
+ f: impl for<'borrow, 'data> FnOnce(Pin<&'borrow F::Of<'data>>) -> R,
+ ) -> Result<R> {
+ // SAFETY: The higher-ranked closure prevents the borrow from escaping or being stored in
+ // invariant data by keeping its lifetime independent of the erased data lifetime.
+ let pinned = unsafe { self.vf_registration_data_pinned::<F>()? };
+ Ok(f(pinned))
+ }
+
+ /// Returns a pinned reference to the VF registration data.
+ ///
+ /// Available only when `F` implements [`CovariantForLt`](trait@crate::types::CovariantForLt),
+ /// guaranteeing that shortening the PF data lifetime is sound.
+ ///
+ /// For non-covariant types, use [`Self::vf_registration_data_with()`].
+ ///
+ /// It returns the same errors as [`Self::vf_registration_data_with()`].
+ pub fn vf_registration_data<F: CovariantForLt + 'static>(&self) -> Result<Pin<&F::Of<'_>>> {
+ // SAFETY: `CovariantForLt` permits shortening the encoded lifetime to this borrow.
+ unsafe { self.vf_registration_data_pinned::<F>() }
+ }
+}
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH v2 8/8] samples: rust: add Rust SR-IOV VF driver sample
2026-09-24 19:05 [PATCH v2 0/8] Add Rust PCI SR-IOV support Zhi Wang
` (6 preceding siblings ...)
2026-09-24 19:05 ` [PATCH v2 7/8] rust: pci: add typed SR-IOV PF registration data Zhi Wang
@ 2026-09-24 19:05 ` Zhi Wang
7 siblings, 0 replies; 10+ messages in thread
From: Zhi Wang @ 2026-09-24 19:05 UTC (permalink / raw)
To: rust-for-linux, linux-pci, linux-kernel
Cc: dakr, aliceryhl, bhelgaas, kwilczynski, ojeda, boqun, gary,
bjorn3_gh, lossin, a.hindborg, tmgross, markus.probst, cjia,
smitra, ankita, aniketa, kwankhede, targupta, kjaju, alkumar,
acourbot, jhubbard, zhiwang, jgg, alex, Peter Colberg, Zhi Wang
From: Peter Colberg <pcolberg@redhat.com>
Add a new SR-IOV driver sample that demonstrates how to enable and
disable the Single Root I/O Virtualization capability for a PCI device.
The sample may be exercised using QEMU's 82576 (igb) emulation.
Implement the PF and VF as ordinary PCI drivers. Publish pinned PF data
with a mutex-protected counter inline in the PF driver data, then borrow
and invoke it explicitly from VF probe. Register the VF driver first so
it is ready before the PF can enable VFs.
Link: https://www.qemu.org/docs/master/system/devices/igb.html
Signed-off-by: Peter Colberg <pcolberg@redhat.com>
Co-developed-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
---
MAINTAINERS | 1 +
samples/rust/Kconfig | 11 ++
samples/rust/Makefile | 1 +
samples/rust/rust_driver_sriov.rs | 241 ++++++++++++++++++++++++++++++
4 files changed, 254 insertions(+)
create mode 100644 samples/rust/rust_driver_sriov.rs
diff --git a/MAINTAINERS b/MAINTAINERS
index f7a513c4ba24..da6c34bc3dcd 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -21129,6 +21129,7 @@ F: rust/helpers/pci.c
F: rust/kernel/pci.rs
F: rust/kernel/pci/
F: samples/rust/rust_driver_pci.rs
+F: samples/rust/rust_driver_sriov.rs
PCIE BANDWIDTH CONTROLLER
M: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
diff --git a/samples/rust/Kconfig b/samples/rust/Kconfig
index 31d62533ef25..737670fd68f8 100644
--- a/samples/rust/Kconfig
+++ b/samples/rust/Kconfig
@@ -128,6 +128,17 @@ config SAMPLE_RUST_DRIVER_PLATFORM
If unsure, say N.
+config SAMPLE_RUST_DRIVER_SRIOV
+ tristate "SR-IOV Driver"
+ depends on PCI_IOV
+ help
+ This option builds the Rust SR-IOV driver sample.
+
+ To compile this as a module, choose M here:
+ the module will be called rust_driver_sriov.
+
+ If unsure, say N.
+
config SAMPLE_RUST_DRIVER_USB
tristate "USB Driver"
depends on USB = y
diff --git a/samples/rust/Makefile b/samples/rust/Makefile
index b986b681cde5..238a11d5ec39 100644
--- a/samples/rust/Makefile
+++ b/samples/rust/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_SAMPLE_RUST_DRIVER_I2C) += rust_driver_i2c.o
obj-$(CONFIG_SAMPLE_RUST_I2C_CLIENT) += rust_i2c_client.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_PCI) += rust_driver_pci.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_PLATFORM) += rust_driver_platform.o
+obj-$(CONFIG_SAMPLE_RUST_DRIVER_SRIOV) += rust_driver_sriov.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_USB) += rust_driver_usb.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_FAUX) += rust_driver_faux.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_AUXILIARY) += rust_driver_auxiliary.o
diff --git a/samples/rust/rust_driver_sriov.rs b/samples/rust/rust_driver_sriov.rs
new file mode 100644
index 000000000000..c5fcf4a0c62e
--- /dev/null
+++ b/samples/rust/rust_driver_sriov.rs
@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust SR-IOV driver sample based on QEMU's 82576 ([igb]) emulation.
+//!
+//! To make this driver probe, QEMU must be run with `-device igb`.
+//!
+//! Further, enable [vIOMMU] with interrupt remapping using, e.g.,
+//!
+//! `-M q35,accel=kvm,kernel-irqchip=split -device intel-iommu,intremap=on,caching-mode=on`
+//!
+//! and append `intel_iommu=on` to the guest kernel arguments.
+//!
+//! [igb]: https://www.qemu.org/docs/master/system/devices/igb.html
+//! [vIOMMU]: https://wiki.qemu.org/Features/VT-d
+
+use kernel::{
+ device::{
+ Bound,
+ Core, //
+ },
+ driver,
+ new_mutex,
+ pci,
+ prelude::*,
+ sync::{
+ aref::ARef,
+ Mutex, //
+ },
+ types::CovariantForLt,
+ InPlaceModule, //
+};
+
+const PF_DRIVER_NAME: &CStr = c"rust_driver_sriov_pf";
+const VF_DRIVER_NAME: &CStr = c"rust_driver_sriov_vf";
+
+struct SamplePfDriver;
+struct SampleVfDriver;
+
+#[pin_data]
+struct PfApi<'bound> {
+ pdev: &'bound pci::Device<Bound>,
+ #[pin]
+ requests: Mutex<u64>,
+}
+
+type PfApiForLt = CovariantForLt!(PfApi<'_>);
+
+impl PfApi<'_> {
+ fn submit(self: Pin<&Self>, vf: &pci::Device<Bound>) -> Result<u64> {
+ let mut requests = self.requests.lock();
+ let request = (*requests).checked_add(1).ok_or(EOVERFLOW)?;
+ *requests = request;
+ drop(requests);
+
+ dev_info!(
+ self.pdev,
+ "Handle PF request {} from VF devfn {:#x}.\n",
+ request,
+ vf.dev_id()
+ );
+
+ Ok(request)
+ }
+}
+
+#[pin_data(PinnedDrop)]
+struct PfDriverData<'bound> {
+ // Keep the device alive until the registration stops exposing `PfApi::pdev`.
+ #[pin]
+ _registration: pci::VfRegistration<'bound, PfApiForLt>,
+ pdev: ARef<pci::Device>,
+}
+
+#[pin_data(PinnedDrop)]
+struct VfDriverData {
+ pdev: ARef<pci::Device>,
+}
+
+kernel::pci_device_table!(
+ PF_TABLE,
+ <SamplePfDriver as pci::Driver>::IdInfo,
+ [(
+ // E1000_DEV_ID_82576
+ pci::DeviceId::from_id(pci::Vendor::INTEL, 0x10c9),
+ ()
+ )]
+);
+
+kernel::pci_device_table!(
+ VF_TABLE,
+ <SampleVfDriver as pci::Driver>::IdInfo,
+ [(
+ // E1000_DEV_ID_82576_VF
+ pci::DeviceId::from_id(pci::Vendor::INTEL, 0x10ca),
+ ()
+ )]
+);
+
+#[vtable]
+impl pci::Driver for SamplePfDriver {
+ type IdInfo = ();
+ type Data<'bound> = PfDriverData<'bound>;
+
+ const ID_TABLE: pci::IdTable<Self::IdInfo> = &PF_TABLE;
+
+ fn probe<'bound>(
+ pdev: &'bound pci::Device<Core<'_>>,
+ _info: Option<&'bound Self::IdInfo>,
+ ) -> impl PinInit<Self::Data<'bound>, Error> + 'bound {
+ pin_init::pin_init_scope(move || {
+ dev_info!(
+ pdev,
+ "Probe Rust SR-IOV PF sample (PCI ID: {}, 0x{:x}).\n",
+ pdev.vendor_id(),
+ pdev.device_id()
+ );
+
+ pdev.enable_device_mem()?;
+ pdev.set_master();
+
+ Ok(try_pin_init!(PfDriverData {
+ // SAFETY:
+ // - probe has exclusive access to this PF before SR-IOV is enabled;
+ // - the registration is pinned in the PF driver data and dropped before `pdev`;
+ // - no other registration is created for this PF; and
+ // - VFs are enabled only after probe by `sriov_configure`.
+ _registration <- unsafe {
+ pci::VfRegistration::new(
+ pdev,
+ try_pin_init!(PfApi {
+ pdev,
+ requests <- new_mutex!(0),
+ }),
+ )
+ },
+ pdev: pdev.into(),
+ }))
+ })
+ }
+
+ fn sriov_configure<'bound>(
+ dev: &'bound pci::Device<Core<'_>>,
+ this: Pin<&Self::Data<'bound>>,
+ nr_virtfn: i32,
+ ) -> Result<i32> {
+ if nr_virtfn == 0 {
+ dev_info!(
+ this.pdev,
+ "Disable SR-IOV (PCI ID: {}, 0x{:x}).\n",
+ this.pdev.vendor_id(),
+ this.pdev.device_id()
+ );
+ dev.disable_sriov();
+ } else {
+ dev_info!(
+ this.pdev,
+ "Enable SR-IOV (PCI ID: {}, 0x{:x}).\n",
+ this.pdev.vendor_id(),
+ this.pdev.device_id()
+ );
+ dev.enable_sriov(nr_virtfn)?;
+ }
+
+ assert_eq!(dev.num_vf(), nr_virtfn);
+ Ok(nr_virtfn)
+ }
+}
+
+#[vtable]
+impl pci::Driver for SampleVfDriver {
+ type IdInfo = ();
+ type Data<'bound> = VfDriverData;
+
+ const ID_TABLE: pci::IdTable<Self::IdInfo> = &VF_TABLE;
+
+ fn probe<'bound>(
+ pdev: &'bound pci::Device<Core<'_>>,
+ _info: Option<&'bound Self::IdInfo>,
+ ) -> impl PinInit<Self::Data<'bound>, Error> + 'bound {
+ pin_init::pin_init_scope(move || {
+ dev_info!(
+ pdev,
+ "Probe Rust SR-IOV VF sample (PCI ID: {}, 0x{:x}).\n",
+ pdev.vendor_id(),
+ pdev.device_id()
+ );
+
+ let pdev_bound: &'bound pci::Device<Bound> = pdev;
+ let pf_api = pdev_bound.vf_registration_data::<PfApiForLt>()?;
+
+ pdev.enable_device_mem()?;
+ pdev.set_master();
+
+ let request = pf_api.submit(pdev)?;
+ dev_info!(pdev, "Submitted request {} through PF data.\n", request);
+
+ Ok(try_pin_init!(VfDriverData { pdev: pdev.into() }))
+ })
+ }
+}
+
+#[pinned_drop]
+impl PinnedDrop for PfDriverData<'_> {
+ fn drop(self: Pin<&mut Self>) {
+ dev_info!(self.pdev, "Remove Rust SR-IOV PF sample.\n");
+ }
+}
+
+#[pinned_drop]
+impl PinnedDrop for VfDriverData {
+ fn drop(self: Pin<&mut Self>) {
+ dev_info!(self.pdev, "Remove Rust SR-IOV VF sample.\n");
+ }
+}
+
+#[pin_data]
+struct SampleModule {
+ // Keep the VF driver registered while PF removal tears down its VFs.
+ #[pin]
+ _pf: driver::Registration<pci::Adapter<SamplePfDriver>>,
+ #[pin]
+ _vf: driver::Registration<pci::Adapter<SampleVfDriver>>,
+}
+
+impl InPlaceModule for SampleModule {
+ fn init(module: &'static ThisModule) -> impl PinInit<Self, Error> {
+ try_pin_init!(Self {
+ // The VF driver must be ready before the PF can enable VFs.
+ _vf <- driver::Registration::new(VF_DRIVER_NAME, module),
+ _pf <- driver::Registration::new(PF_DRIVER_NAME, module),
+ })
+ }
+}
+
+module! {
+ type: SampleModule,
+ name: "rust_driver_sriov",
+ authors: ["Peter Colberg"],
+ description: "Rust SR-IOV driver",
+ license: "GPL v2",
+}
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread