* [PATCH v5 1/9] rust: pci: add internal SR-IOV enable and disable helpers
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:17 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 2/9] rust: pci: add vtable attribute to pci::Driver trait Simon Song
` (7 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Peter Colberg <peter@colberg.org>
Wrap pci_enable_sriov() and pci_disable_sriov() on Device<CoreInternal>
for use by the SR-IOV callback tokens and their rollback guard.
Keep these operations internal so drivers can only enable or disable
VFs through the callback-scoped API introduced later in this series.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <peter@colberg.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/pci.rs | 2 ++
rust/kernel/pci/iov.rs | 48 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 50 insertions(+)
create mode 100644 rust/kernel/pci/iov.rs
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index f47974d3e76..e522fdddc34 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -36,6 +36,8 @@
mod cap;
mod id;
mod io;
+#[cfg(CONFIG_PCI_IOV)]
+mod iov;
mod irq;
pub use self::cap::{
diff --git a/rust/kernel/pci/iov.rs b/rust/kernel/pci/iov.rs
new file mode 100644
index 00000000000..6f8f95ed618
--- /dev/null
+++ b/rust/kernel/pci/iov.rs
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Abstractions for PCI Single Root I/O Virtualization (SR-IOV) drivers.
+
+use super::Device;
+
+use crate::{
+ bindings,
+ device,
+ error::to_result,
+ prelude::*, //
+};
+
+impl Device<device::CoreInternal<'_>> {
+ /// Enable the Single Root I/O Virtualization (SR-IOV) capability for this device,
+ /// where `nr_virtfn` is number of Virtual Functions (VF) to enable.
+ #[inline]
+ #[expect(dead_code)]
+ pub(crate) fn enable_sriov(&self, nr_virtfn: u16) -> 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 [`CoreInternal`] 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.into()) })
+ }
+
+ /// Disable the Single Root I/O Virtualization (SR-IOV) capability for this device.
+ #[inline]
+ #[expect(dead_code)]
+ pub(crate) 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 [`CoreInternal`] 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()) };
+ }
+}
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 2/9] rust: pci: add vtable attribute to pci::Driver trait
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
2026-10-30 17:12 ` [PATCH v5 1/9] rust: pci: add internal SR-IOV enable and disable helpers Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:17 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 3/9] rust: pci: add is_virtfn(), to check for VFs Simon Song
` (6 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Peter Colberg <peter@colberg.org>
Add the #[vtable] attribute to pci::Driver and its implementations to
support the optional sriov_enable() and sriov_disable() callbacks
introduced later in this series.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <peter@colberg.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@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 87917dea4f5..dc6febeee65 100644
--- a/drivers/gpu/nova-core/driver.rs
+++ b/drivers/gpu/nova-core/driver.rs
@@ -101,6 +101,7 @@ pub(crate) fn bar1_resource_index(pdev: &pci::Device<Bound>) -> Result<u32> {
]
);
+#[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 e522fdddc34..c60edd01b70 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -283,6 +283,7 @@ macro_rules! pci_device_table {
/// ]
/// );
///
+/// #[vtable]
/// impl pci::Driver for MyDriver {
/// type IdInfo = ();
/// type Data<'bound> = Self;
@@ -298,6 +299,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 ffb69354467..804d55a6300 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 0bee16faecc..6cff9bf8c80 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 13b035a9575..50c8709739c 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.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 3/9] rust: pci: add is_virtfn(), to check for VFs
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
2026-10-30 17:12 ` [PATCH v5 1/9] rust: pci: add internal SR-IOV enable and disable helpers Simon Song
2026-10-30 17:12 ` [PATCH v5 2/9] rust: pci: add vtable attribute to pci::Driver trait Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:21 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 4/9] rust: pci: add num_vf(), to return number of VFs Simon Song
` (5 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
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 <peter@colberg.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/pci.rs | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index c60edd01b70..9e1d02588af 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -363,6 +363,13 @@ fn as_raw(&self) -> *mut bindings::pci_dev {
}
impl Device {
+ /// Returns `true` if this device is a Virtual Function (VF).
+ #[inline]
+ 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 PCI vendor ID as [`Vendor`].
///
/// # Examples
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 4/9] rust: pci: add num_vf(), to return number of VFs
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (2 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 3/9] rust: pci: add is_virtfn(), to check for VFs Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:21 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 5/9] rust: pci: drop driver data before remove returns Simon Song
` (4 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Peter Colberg <peter@colberg.org>
Add a method to return the number of Virtual Functions (VF) enabled for
a Physical Function (PF).
Expose the query in the PCI core callback context and return u16,
matching the type of the VF count stored by the PCI core.
Signed-off-by: Peter Colberg <peter@colberg.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/pci/iov.rs | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/rust/kernel/pci/iov.rs b/rust/kernel/pci/iov.rs
index 6f8f95ed618..1ff0ce94f16 100644
--- a/rust/kernel/pci/iov.rs
+++ b/rust/kernel/pci/iov.rs
@@ -11,6 +11,17 @@
prelude::*, //
};
+impl Device<device::Core<'_>> {
+ /// Returns the number of Virtual Functions (VF) enabled for a Physical Function (PF).
+ #[inline]
+ pub fn num_vf(&self) -> u16 {
+ // SAFETY: `self.as_raw()` is valid and this call runs in the PCI core callback context.
+ unsafe { bindings::pci_num_vf(self.as_raw()) }
+ .try_into()
+ .expect("pdev->sriov->num_VFs is u16")
+ }
+}
+
impl Device<device::CoreInternal<'_>> {
/// Enable the Single Root I/O Virtualization (SR-IOV) capability for this device,
/// where `nr_virtfn` is number of Virtual Functions (VF) to enable.
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 5/9] rust: pci: drop driver data before remove returns
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (3 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 4/9] rust: pci: add num_vf(), to return number of VFs Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:21 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 6/9] rust: pci: add typed SR-IOV PF registration data Simon Song
` (3 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Zhi Wang <zhiw@nvidia.com>
Drop PCI private data before the remove callback returns, so its
destructors run within PCI core's removal context.
Call unbind while private data remains installed, then take and release
the data. Taking it clears drvdata, so post_unbind does not release it
again. All borrows must end before the data is removed.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/device.rs | 4 ++--
rust/kernel/pci.rs | 6 ++++++
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs
index 2291d85b684..1f6bb58396e 100644
--- a/rust/kernel/device.rs
+++ b/rust/kernel/device.rs
@@ -243,8 +243,8 @@ impl<Ctx: InternalBoundContext> Device<Ctx> {
///
/// # Safety
///
- /// - Must only be called after a preceding call to [`Device::set_drvdata`] and before the
- /// device is fully unbound.
+ /// - The data stored by [`Device::set_drvdata`] must still be installed and remain valid
+ /// for the returned borrow.
/// - The type `T` must match the type of the `ForeignOwnable` previously stored by
/// [`Device::set_drvdata`].
pub unsafe fn drvdata_borrow<T>(&self) -> Pin<&T> {
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 9e1d02588af..8092f56ee2b 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -150,6 +150,12 @@ extern "C" fn remove_callback(pdev: *mut bindings::pci_dev) {
let data = unsafe { pdev.as_ref().drvdata_borrow::<T::Data<'_>>() };
T::unbind(pdev, data);
+
+ // SAFETY: The driver's unbind callback has returned, and no callbacks retain a borrow.
+ let data = unsafe { pdev.as_ref().drvdata_obtain::<T::Data<'_>>() };
+
+ // Drop private data before returning to PCI core, while its removal context is valid.
+ drop(data);
}
}
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 6/9] rust: pci: add typed SR-IOV PF registration data
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (4 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 5/9] rust: pci: drop driver data before remove returns Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:32 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 7/9] rust: pci: add SR-IOV enable and disable tokens Simon Song
` (2 subsequent siblings)
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Zhi Wang <zhiw@nvidia.com>
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 object in the PF's private
data. VF drivers can borrow it after checking the requested Rust
type, using a higher-ranked closure or a covariant lifetime encoding.
Capture the core callback context in the initializer. Reject active
VFs and an occupied registration slot before initializing the payload,
then recheck the slot before publication in case the payload initializer
created another registration. Publish only after all fallible work.
During registration teardown, disable SR-IOV and wait for VF remove
callbacks to finish before clearing the pointer and 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>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
include/linux/pci.h | 7 ++
rust/kernel/pci.rs | 2 +
rust/kernel/pci/iov.rs | 205 ++++++++++++++++++++++++++++++++++++++++-
3 files changed, 213 insertions(+), 1 deletion(-)
diff --git a/include/linux/pci.h b/include/linux/pci.h
index d31a8d107b1..9b6ae544469 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 8092f56ee2b..83d62f95b7e 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -60,6 +60,8 @@
Extended,
Normal, //
};
+#[cfg(CONFIG_PCI_IOV)]
+pub use self::iov::VfRegistration;
pub use self::irq::{
IrqType,
IrqTypes,
diff --git a/rust/kernel/pci/iov.rs b/rust/kernel/pci/iov.rs
index 1ff0ce94f16..83fa1ecfa50 100644
--- a/rust/kernel/pci/iov.rs
+++ b/rust/kernel/pci/iov.rs
@@ -8,7 +8,15 @@
bindings,
device,
error::to_result,
- prelude::*, //
+ prelude::*,
+ types::{
+ CovariantForLt,
+ ForLt, //
+ }, //
+};
+use core::{
+ any::TypeId,
+ marker::PhantomPinned, //
};
impl Device<device::Core<'_>> {
@@ -57,3 +65,198 @@ pub(crate) fn disable_sriov(&self) {
unsafe { bindings::pci_disable_sriov(self.as_raw()) };
}
}
+
+/// Wrapper for VF registration data stored inside a [`VfRegistration`].
+///
+/// Stores a [`TypeId`] header (derived from `F`) followed by the pinned data,
+/// so that [`Device::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.
+ #[inline]
+ fn new<E>(data: impl PinInit<F::Of<'a>, E>) -> impl PinInit<Self, E> {
+ try_pin_init!(Self {
+ type_id: TypeId::of::<F>(),
+ data <- data,
+ }? E)
+ }
+}
+
+/// SR-IOV VF registration on a PF device.
+///
+/// Owns the registration data that VF drivers access via
+/// [`Device::vf_registration_data_with()`] and [`Device::vf_registration_data()`].
+///
+/// Drop disables SR-IOV before clearing the registration pointer and releasing the data.
+#[pin_data(PinnedDrop)]
+pub struct VfRegistration<'a, F: ForLt + 'static> {
+ pdev: &'a Device<device::Bound>,
+ #[pin]
+ inner: VfRegistrationData<'a, F>,
+ #[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 returned registration must be embedded in the driver's bus device private data.
+ pub unsafe fn new<'core, I>(
+ pdev: &'a Device<device::Core<'core>>,
+ data: I,
+ ) -> impl PinInit<Self, Error> + 'a + use<'a, 'core, F, I>
+ where
+ I: PinInit<F::Of<'a>, Error> + 'a,
+ {
+ try_pin_init!(Self {
+ _: {
+ if pdev.is_virtfn() {
+ return Err(ENODEV);
+ }
+ if pdev.num_vf() != 0 {
+ return Err(EBUSY);
+ }
+ // SAFETY: The core callback serializes changes to this device's registration.
+ if !unsafe { (*pdev.as_raw()).vf_registration_data_rust }.is_null() {
+ return Err(EBUSY);
+ }
+ },
+ pdev,
+ inner <- VfRegistrationData::new(data),
+ _pin: PhantomPinned,
+ _: {
+ // The data initializer may have registered another object on this device.
+ // SAFETY: The captured core context still serializes registration changes.
+ if !unsafe { (*pdev.as_raw()).vf_registration_data_rust }.is_null() {
+ return Err(EBUSY);
+ }
+
+ // SAFETY: The data is initialized and pinned, the slot is unoccupied, and
+ // no VF can access it yet. No fallible work follows publication.
+ unsafe {
+ (*pdev.as_raw()).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>) {
+ // 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()) };
+
+ // SAFETY: The device is valid and all VF remove callbacks have completed, so no VF
+ // can access the registration pointer. The data remains alive until this returns.
+ unsafe { (*self.pdev.as_raw()).vf_registration_data_rust = core::ptr::null_mut() };
+ }
+}
+
+// SAFETY: The inner data is `Send` (enforced by the bound), and `&Device` 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 Device<device::Bound> {
+ /// Internal helper: reads the `vf_registration_data_rust` pointer from the
+ /// PF, checks the `TypeId`, and returns a pinned reference.
+ ///
+ /// # Safety
+ ///
+ /// The data lifetime must be hidden behind a higher-ranked closure independently of the
+ /// reference lifetime, or `F` must be covariant in its encoded lifetime.
+ unsafe fn vf_registration_data_pinned<F: ForLt + 'static>(&self) -> Result<Pin<&F::Of<'_>>> {
+ if !self.is_virtfn() {
+ return Err(ENODEV);
+ }
+
+ // SAFETY: This bound VF uses the `physfn` union field. PCI retains its PF until
+ // VF removal completes, and the PF keeps the registration installed until then.
+ let ptr = unsafe {
+ let pf = (*self.as_raw()).__bindgen_anon_1.physfn;
+ (*pf).vf_registration_data_rust
+ };
+
+ if ptr.is_null() {
+ return Err(ENODEV);
+ }
+
+ // SAFETY: The registration keeps its data installed until VF removal completes,
+ // including when probe initialization rolls back.
+ // `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 or no data was registered,
+ /// or [`EINVAL`] if `F` does not match the type registered by the PF.
+ ///
+ /// The reference is borrowed from this VF, while the registration data's lifetime remains
+ /// abstract so the closure cannot store shorter-lived references in invariant data.
+ #[inline]
+ pub fn vf_registration_data_with<'this, F: ForLt + 'static, R>(
+ &'this self,
+ f: impl for<'a> FnOnce(Pin<&'this F::Of<'a>>) -> R,
+ ) -> Result<R> {
+ // SAFETY: The closure is higher-ranked over the data lifetime, independently of `'this`.
+ // It cannot insert shorter-lived references, and the outer borrow cannot outlive this VF.
+ 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()`].
+ #[inline]
+ 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.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 6/9] rust: pci: add typed SR-IOV PF registration data
2026-10-30 17:12 ` [PATCH v5 6/9] rust: pci: add typed SR-IOV PF registration data Simon Song
@ 2026-10-30 17:32 ` sashiko-bot
0 siblings, 0 replies; 19+ messages in thread
From: sashiko-bot @ 2026-10-30 17:32 UTC (permalink / raw)
To: Simon Song, linux-pci
> From: Zhi Wang <zhiw@nvidia.com>
>
> 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 object in the PF's private
> data. VF drivers can borrow it after checking the requested Rust
> type, using a higher-ranked closure or a covariant lifetime encoding.
>
> Capture the core callback context in the initializer. Reject active
> VFs and an occupied registration slot before initializing the payload,
> then recheck the slot before publication in case the payload initializer
> created another registration. Publish only after all fallible work.
>
> During registration teardown, disable SR-IOV and wait for VF remove
> callbacks to finish before clearing the pointer and 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>
> Signed-off-by: Simon Song <xinmengs@nvidia.com>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261030171230.196717-1-xinmengs@nvidia.com?part=6
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 7/9] rust: pci: add SR-IOV enable and disable tokens
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (5 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 6/9] rust: pci: add typed SR-IOV PF registration data Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:21 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 8/9] rust: pci: add SR-IOV enable and disable callbacks Simon Song
2026-10-30 17:12 ` [PATCH v5 9/9] samples: rust: add Rust SR-IOV PF and VF driver samples Simon Song
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Zhi Wang <zhiw@nvidia.com>
Enabling VFs can succeed before the driver's remaining setup fails.
Use a callback-scoped token to return an enabled guard that disables
SR-IOV when dropped, rolling back those VFs on a later error.
Add SriovEnable, SriovEnabled and SriovDisable for the split callbacks
introduced next. Tie each token to its PF and callback lifetime, and
limit the enabled count to the user's request. The PCI adapter disarms
the guard when accepting a successful enable callback.
Require a VfRegistration to own final VF teardown after that handoff.
Drivers that do not share data with VFs can register (). A disable
token permits explicit shutdown without forcing it on a rejected
request.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/pci.rs | 7 +++-
rust/kernel/pci/iov.rs | 94 ++++++++++++++++++++++++++++++++++++++++--
2 files changed, 97 insertions(+), 4 deletions(-)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 83d62f95b7e..3a768477014 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -61,7 +61,12 @@
Normal, //
};
#[cfg(CONFIG_PCI_IOV)]
-pub use self::iov::VfRegistration;
+pub use self::iov::{
+ SriovDisable,
+ SriovEnable,
+ SriovEnabled,
+ VfRegistration, //
+};
pub use self::irq::{
IrqType,
IrqTypes,
diff --git a/rust/kernel/pci/iov.rs b/rust/kernel/pci/iov.rs
index 83fa1ecfa50..197b0c2bb0f 100644
--- a/rust/kernel/pci/iov.rs
+++ b/rust/kernel/pci/iov.rs
@@ -16,7 +16,8 @@
};
use core::{
any::TypeId,
- marker::PhantomPinned, //
+ marker::PhantomPinned,
+ mem::ManuallyDrop, //
};
impl Device<device::Core<'_>> {
@@ -34,7 +35,6 @@ impl Device<device::CoreInternal<'_>> {
/// Enable the Single Root I/O Virtualization (SR-IOV) capability for this device,
/// where `nr_virtfn` is number of Virtual Functions (VF) to enable.
#[inline]
- #[expect(dead_code)]
pub(crate) fn enable_sriov(&self, nr_virtfn: u16) -> Result {
// SAFETY:
// - `self.as_raw` returns a valid pointer to a `struct pci_dev`.
@@ -51,7 +51,6 @@ pub(crate) fn enable_sriov(&self, nr_virtfn: u16) -> Result {
/// Disable the Single Root I/O Virtualization (SR-IOV) capability for this device.
#[inline]
- #[expect(dead_code)]
pub(crate) fn disable_sriov(&self) {
// SAFETY:
// - `self.as_raw` returns a valid pointer to a `struct pci_dev`.
@@ -66,6 +65,95 @@ pub(crate) fn disable_sriov(&self) {
}
}
+/// Permission to enable VFs during a driver's `sriov_enable()` callback.
+///
+/// The PCI adapter creates this token for the PF being configured. It cannot be cloned or sent
+/// to another thread, and its lifetime is restricted to the callback. Enabling VFs consumes it.
+///
+/// The callback lifetime cannot be extended:
+///
+/// ```ignore,compile_fail
+/// use kernel::pci::SriovEnable;
+///
+/// fn escape(token: SriovEnable<'_>) -> SriovEnable<'static> {
+/// token
+/// }
+/// ```
+pub struct SriovEnable<'a> {
+ pdev: &'a Device<device::CoreInternal<'a>>,
+ num_vfs: u16,
+}
+
+impl<'a> SriovEnable<'a> {
+ /// Returns the number of VFs requested for this callback.
+ #[inline]
+ pub fn num_vfs(&self) -> u16 {
+ self.num_vfs
+ }
+
+ /// Enables between one and the requested number of VFs.
+ ///
+ /// VF drivers can probe before this method returns, so the PF resources they access must
+ /// already be initialized. The returned guard disables the VFs if subsequent setup fails.
+ /// Return it from `sriov_enable()` to leave the VFs enabled on callback success.
+ pub fn enable(self, num_vfs: u16) -> Result<SriovEnabled<'a>> {
+ if num_vfs == 0 || num_vfs > self.num_vfs {
+ return Err(EINVAL);
+ }
+
+ // SAFETY: The PF's driver data and registration remain installed throughout this callback.
+ // The registration owns final VF teardown after the enable guard is disarmed.
+ if unsafe { (*self.pdev.as_raw()).vf_registration_data_rust }.is_null() {
+ return Err(ENODEV);
+ }
+
+ self.pdev.enable_sriov(num_vfs)?;
+ Ok(SriovEnabled {
+ pdev: self.pdev,
+ num_vfs,
+ })
+ }
+}
+
+/// Enabled VFs awaiting successful completion of `sriov_enable()`.
+pub struct SriovEnabled<'a> {
+ pdev: &'a Device<device::CoreInternal<'a>>,
+ num_vfs: u16,
+}
+
+impl SriovEnabled<'_> {
+ #[inline]
+ #[expect(dead_code)]
+ fn disarm(self) -> u16 {
+ ManuallyDrop::new(self).num_vfs
+ }
+}
+
+impl Drop for SriovEnabled<'_> {
+ fn drop(&mut self) {
+ self.pdev.disable_sriov();
+ }
+}
+
+/// Permission to disable VFs during a driver's `sriov_disable()` callback.
+///
+/// The PCI adapter creates this token for the PF being configured. It cannot be cloned or sent
+/// to another thread, and its lifetime is restricted to the callback. Dropping the token does
+/// not disable VFs, allowing the callback to reject a disable request.
+pub struct SriovDisable<'a> {
+ pdev: &'a Device<device::CoreInternal<'a>>,
+}
+
+impl SriovDisable<'_> {
+ /// Disables all VFs and waits for their drivers to unbind.
+ ///
+ /// The PF resources used by VF drivers must remain available until this method returns.
+ #[inline]
+ pub fn disable(self) {
+ self.pdev.disable_sriov();
+ }
+}
+
/// Wrapper for VF registration data stored inside a [`VfRegistration`].
///
/// Stores a [`TypeId`] header (derived from `F`) followed by the pinned data,
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 7/9] rust: pci: add SR-IOV enable and disable tokens
2026-10-30 17:12 ` [PATCH v5 7/9] rust: pci: add SR-IOV enable and disable tokens Simon Song
@ 2026-10-30 17:21 ` sashiko-bot
0 siblings, 0 replies; 19+ messages in thread
From: sashiko-bot @ 2026-10-30 17:21 UTC (permalink / raw)
To: Simon Song, linux-pci
> From: Zhi Wang <zhiw@nvidia.com>
>
> Enabling VFs can succeed before the driver's remaining setup fails.
> Use a callback-scoped token to return an enabled guard that disables
> SR-IOV when dropped, rolling back those VFs on a later error.
>
> Add SriovEnable, SriovEnabled and SriovDisable for the split callbacks
> introduced next. Tie each token to its PF and callback lifetime, and
> limit the enabled count to the user's request. The PCI adapter disarms
> the guard when accepting a successful enable callback.
>
> Require a VfRegistration to own final VF teardown after that handoff.
> Drivers that do not share data with VFs can register (). A disable
> token permits explicit shutdown without forcing it on a rejected
> request.
>
> Suggested-by: Danilo Krummrich <dakr@kernel.org>
> Signed-off-by: Zhi Wang <zhiw@nvidia.com>
> Signed-off-by: Simon Song <xinmengs@nvidia.com>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261030171230.196717-1-xinmengs@nvidia.com?part=7
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 8/9] rust: pci: add SR-IOV enable and disable callbacks
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (6 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 7/9] rust: pci: add SR-IOV enable and disable tokens Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:23 ` sashiko-bot
2026-10-30 17:12 ` [PATCH v5 9/9] samples: rust: add Rust SR-IOV PF and VF driver samples Simon Song
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Peter Colberg <peter@colberg.org>
Allow Rust PCI drivers to configure SR-IOV through sriov_numvfs.
Split the C configure callback into sriov_enable() and sriov_disable(),
passing pinned driver data and a token for the requested operation.
Require drivers to implement both callbacks together.
Return the enabled guard's VF count on success and disarm its rollback.
On a disable request, verify that the driver has removed all VFs before
reporting success. VfRegistration handles VF removal during PF teardown;
these callbacks only handle explicit configuration requests.
The PCI core invokes sriov_configure only through the PF-only
sriov_numvfs sysfs attribute, so no extra PF role check is needed.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: Peter Colberg <peter@colberg.org>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
rust/kernel/pci.rs | 91 ++++++++++++++++++++++++++++++++++++++++++
rust/kernel/pci/iov.rs | 51 +++++++++++++++++++----
2 files changed, 135 insertions(+), 7 deletions(-)
diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs
index 3a768477014..5de784373ec 100644
--- a/rust/kernel/pci.rs
+++ b/rust/kernel/pci.rs
@@ -96,12 +96,22 @@ unsafe fn register(
name: &'static CStr,
module: &'static ThisModule,
) -> Result {
+ #[cfg(CONFIG_PCI_IOV)]
+ build_assert!(
+ T::HAS_SRIOV_ENABLE == T::HAS_SRIOV_DISABLE,
+ "PCI drivers must implement both sriov_enable and sriov_disable"
+ );
+
// SAFETY: It's safe to set the fields of `struct pci_driver` on initialization.
unsafe {
(*pdrv.get()).name = name.as_char_ptr();
(*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_ENABLE {
+ (*pdrv.get()).sriov_configure = Some(Self::sriov_configure_callback);
+ }
}
// SAFETY: `pdrv` is guaranteed to be a valid `DriverType`.
@@ -350,6 +360,87 @@ fn probe<'bound>(
fn unbind<'bound>(dev: &'bound Device<device::Core<'_>>, this: Pin<&Self::Data<'bound>>) {
let _ = (dev, this);
}
+
+ /// Enables Single Root I/O Virtualization (SR-IOV) for a PF.
+ ///
+ /// Called when userspace writes a nonzero VF count to `sriov_numvfs`. The token carries the
+ /// requested count and permission to enable VFs on this PF. Return the guard obtained from
+ /// [`SriovEnable::enable()`] after completing setup; dropping it rolls back the enable.
+ ///
+ /// The PF must own a [`VfRegistration`] before enabling VFs. That registration disables
+ /// SR-IOV when the driver data is destroyed, while resources needed by VF drivers remain live.
+ /// Implement this callback and [`Self::sriov_disable()`] together, or implement neither.
+ ///
+ /// 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::*, //
+ /// # };
+ /// # struct Data;
+ /// fn sriov_enable<'a>(
+ /// _dev: &'a pci::Device<Core<'_>>,
+ /// _data: Pin<&Data>,
+ /// token: pci::SriovEnable<'a>,
+ /// ) -> Result<pci::SriovEnabled<'a>> {
+ /// let num_vfs = token.num_vfs();
+ /// let enabled = token.enable(num_vfs)?;
+ /// // Complete any additional setup before returning the guard.
+ /// Ok(enabled)
+ /// }
+ /// ```
+ #[cfg(CONFIG_PCI_IOV)]
+ fn sriov_enable<'a>(
+ dev: &'a Device<device::Core<'_>>,
+ data: Pin<&Self::Data<'a>>,
+ token: SriovEnable<'a>,
+ ) -> Result<SriovEnabled<'a>> {
+ let _ = (dev, data, token);
+ build_error!(crate::error::VTABLE_DEFAULT_ERROR)
+ }
+
+ /// Disables all VFs of a PF in response to a userspace request.
+ ///
+ /// Called when userspace writes zero to `sriov_numvfs`. Call [`SriovDisable::disable()`]
+ /// while resources used by VF drivers are still available. Returning an error before calling
+ /// it leaves the VFs enabled. Returning success requires that all VFs have been disabled.
+ ///
+ /// This callback is not invoked during PF unbind; [`VfRegistration`] owns that teardown.
+ /// Implement this callback and [`Self::sriov_enable()`] together, or implement neither.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use kernel::{
+ /// # device::Core,
+ /// # pci,
+ /// # prelude::*, //
+ /// # };
+ /// # struct Data;
+ /// fn sriov_disable<'a>(
+ /// _dev: &'a pci::Device<Core<'_>>,
+ /// _data: Pin<&Data>,
+ /// token: pci::SriovDisable<'a>,
+ /// ) -> Result {
+ /// token.disable();
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(CONFIG_PCI_IOV)]
+ fn sriov_disable<'a>(
+ dev: &'a Device<device::Core<'_>>,
+ data: Pin<&Self::Data<'a>>,
+ token: SriovDisable<'a>,
+ ) -> Result {
+ let _ = (dev, data, token);
+ build_error!(crate::error::VTABLE_DEFAULT_ERROR)
+ }
}
/// The PCI device representation.
diff --git a/rust/kernel/pci/iov.rs b/rust/kernel/pci/iov.rs
index 197b0c2bb0f..2af9f4c20b8 100644
--- a/rust/kernel/pci/iov.rs
+++ b/rust/kernel/pci/iov.rs
@@ -2,12 +2,19 @@
//! Abstractions for PCI Single Root I/O Virtualization (SR-IOV) drivers.
-use super::Device;
+use super::{
+ Adapter,
+ Device,
+ Driver, //
+};
use crate::{
bindings,
device,
- error::to_result,
+ error::{
+ from_result,
+ to_result, //
+ },
prelude::*,
types::{
CovariantForLt,
@@ -65,7 +72,7 @@ pub(crate) fn disable_sriov(&self) {
}
}
-/// Permission to enable VFs during a driver's `sriov_enable()` callback.
+/// Permission to enable VFs during a driver's [`Driver::sriov_enable()`] callback.
///
/// The PCI adapter creates this token for the PF being configured. It cannot be cloned or sent
/// to another thread, and its lifetime is restricted to the callback. Enabling VFs consumes it.
@@ -95,7 +102,7 @@ pub fn num_vfs(&self) -> u16 {
///
/// VF drivers can probe before this method returns, so the PF resources they access must
/// already be initialized. The returned guard disables the VFs if subsequent setup fails.
- /// Return it from `sriov_enable()` to leave the VFs enabled on callback success.
+ /// Return it from [`Driver::sriov_enable()`] to leave the VFs enabled on callback success.
pub fn enable(self, num_vfs: u16) -> Result<SriovEnabled<'a>> {
if num_vfs == 0 || num_vfs > self.num_vfs {
return Err(EINVAL);
@@ -115,7 +122,7 @@ pub fn enable(self, num_vfs: u16) -> Result<SriovEnabled<'a>> {
}
}
-/// Enabled VFs awaiting successful completion of `sriov_enable()`.
+/// Enabled VFs awaiting successful completion of [`Driver::sriov_enable()`].
pub struct SriovEnabled<'a> {
pdev: &'a Device<device::CoreInternal<'a>>,
num_vfs: u16,
@@ -123,7 +130,6 @@ pub struct SriovEnabled<'a> {
impl SriovEnabled<'_> {
#[inline]
- #[expect(dead_code)]
fn disarm(self) -> u16 {
ManuallyDrop::new(self).num_vfs
}
@@ -135,7 +141,7 @@ fn drop(&mut self) {
}
}
-/// Permission to disable VFs during a driver's `sriov_disable()` callback.
+/// Permission to disable VFs during a driver's [`Driver::sriov_disable()`] callback.
///
/// The PCI adapter creates this token for the PF being configured. It cannot be cloned or sent
/// to another thread, and its lifetime is restricted to the callback. Dropping the token does
@@ -154,6 +160,37 @@ pub fn disable(self) {
}
}
+impl<T: Driver> Adapter<T> {
+ pub(super) extern "C" fn sriov_configure_callback(
+ pdev: *mut bindings::pci_dev,
+ nr_virtfn: c_int,
+ ) -> c_int {
+ // SAFETY: The PCI core calls this through the PF-only `sriov_numvfs` sysfs attribute,
+ // with a valid `struct pci_dev` and while holding the device lock.
+ //
+ // INVARIANT: `pdev` is valid for the duration of `sriov_configure_callback()`.
+ let pdev = unsafe { &*pdev.cast::<Device<device::CoreInternal<'_>>>() };
+
+ // 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 nr_virtfn == 0 {
+ T::sriov_disable(pdev, data, SriovDisable { pdev })?;
+ if pdev.num_vf() != 0 {
+ return Err(EBUSY);
+ }
+ Ok(0)
+ } else {
+ let num_vfs = u16::try_from(nr_virtfn).map_err(|_| EINVAL)?;
+ let enabled = T::sriov_enable(pdev, data, SriovEnable { pdev, num_vfs })?;
+ Ok(enabled.disarm().into())
+ }
+ })
+ }
+}
+
/// Wrapper for VF registration data stored inside a [`VfRegistration`].
///
/// Stores a [`TypeId`] header (derived from `F`) followed by the pinned data,
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 8/9] rust: pci: add SR-IOV enable and disable callbacks
2026-10-30 17:12 ` [PATCH v5 8/9] rust: pci: add SR-IOV enable and disable callbacks Simon Song
@ 2026-10-30 17:23 ` sashiko-bot
0 siblings, 0 replies; 19+ messages in thread
From: sashiko-bot @ 2026-10-30 17:23 UTC (permalink / raw)
To: Simon Song, linux-pci
> From: Peter Colberg <peter@colberg.org>
>
> Allow Rust PCI drivers to configure SR-IOV through sriov_numvfs.
> Split the C configure callback into sriov_enable() and sriov_disable(),
> passing pinned driver data and a token for the requested operation.
> Require drivers to implement both callbacks together.
>
> Return the enabled guard's VF count on success and disarm its rollback.
> On a disable request, verify that the driver has removed all VFs before
> reporting success. VfRegistration handles VF removal during PF teardown;
> these callbacks only handle explicit configuration requests.
>
> The PCI core invokes sriov_configure only through the PF-only
> sriov_numvfs sysfs attribute, so no extra PF role check is needed.
>
> Suggested-by: Danilo Krummrich <dakr@kernel.org>
> Signed-off-by: Peter Colberg <peter@colberg.org>
> Signed-off-by: Zhi Wang <zhiw@nvidia.com>
> Signed-off-by: Simon Song <xinmengs@nvidia.com>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261030171230.196717-1-xinmengs@nvidia.com?part=8
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 9/9] samples: rust: add Rust SR-IOV PF and VF driver samples
2026-10-30 17:12 [PATCH v5 0/9] Add Rust PCI SR-IOV support Simon Song
` (7 preceding siblings ...)
2026-10-30 17:12 ` [PATCH v5 8/9] rust: pci: add SR-IOV enable and disable callbacks Simon Song
@ 2026-10-30 17:12 ` Simon Song
2026-10-30 17:26 ` sashiko-bot
8 siblings, 1 reply; 19+ messages in thread
From: Simon Song @ 2026-10-30 17:12 UTC (permalink / raw)
To: dakr, acourbot, kvm, rust-for-linux, nova-gpu, linux-pci
Cc: alex, jgg, yishaih, skolothumtho, kevin.tian, airlied, simona,
ojeda, alex.gaynor, boqun.feng, gary, bjorn3_gh, lossin,
a.hindborg, aliceryhl, tmgross, markus.probst, jhubbard, apopple,
joelagnelf, ecourtney, cjia, smitra, kjaju, alkumar, ankita,
aniketa, kwankhede, targupta, linux-kernel, zhiwang, zhiw, boqun,
daniel.almeida, tamird, work, jgg, bhelgaas, kwilczynski,
dri-devel, peter, xinmengs
From: Peter Colberg <peter@colberg.org>
Add separate PF and VF driver modules that demonstrate SR-IOV using
QEMU's 82576 (igb) emulation.
The PF publishes a pinned API object in its private data and exposes a
submit_request() helper. The VF calls this helper with its Bound device
borrow. The helper performs the typed registration lookup in the PF
crate, keeping the API object and its lifetime encoding private.
Adapt the nova-core/nova-drm rules in drivers/gpu/Makefile, preserving
their metadata, export-selection and MODVERSIONS recipes with the sample
object names and paths. Set the PF crate name explicitly because its Rust
root file has a _main suffix.
Keep the helper out of line so the VF module has a real symbol dependency
on the PF module. The module loader therefore holds the PF module while
the VF module is loaded, and modprobe loads the dependency automatically.
Each driver has its own module registration. The VF module can be unloaded
and reloaded while the PF remains bound. Unbinding the PF disables SR-IOV
and removes its VFs before releasing the registered data. The shared
Kconfig option builds both drivers as modules or both into the kernel.
Link: https://www.qemu.org/docs/master/system/devices/igb.html
Signed-off-by: Peter Colberg <peter@colberg.org>
Co-developed-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Zhi Wang <zhiw@nvidia.com>
Signed-off-by: Simon Song <xinmengs@nvidia.com>
---
MAINTAINERS | 1 +
samples/rust/Kconfig | 12 ++
samples/rust/Makefile | 50 ++++++
samples/rust/rust_driver_sriov_pf_exports.c | 9 ++
samples/rust/rust_driver_sriov_pf_main.rs | 164 ++++++++++++++++++++
samples/rust/rust_driver_sriov_vf.rs | 70 +++++++++
6 files changed, 306 insertions(+)
create mode 100644 samples/rust/rust_driver_sriov_pf_exports.c
create mode 100644 samples/rust/rust_driver_sriov_pf_main.rs
create mode 100644 samples/rust/rust_driver_sriov_vf.rs
diff --git a/MAINTAINERS b/MAINTAINERS
index 04709f381d0..2f3c0a7f7bd 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -21142,6 +21142,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_*
PCIE BANDWIDTH CONTROLLER
M: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
diff --git a/samples/rust/Kconfig b/samples/rust/Kconfig
index 31d62533ef2..00e20e9f122 100644
--- a/samples/rust/Kconfig
+++ b/samples/rust/Kconfig
@@ -128,6 +128,18 @@ config SAMPLE_RUST_DRIVER_PLATFORM
If unsure, say N.
+config SAMPLE_RUST_DRIVER_SRIOV
+ tristate "SR-IOV PF and VF Drivers"
+ depends on PCI_IOV
+ help
+ This option builds the Rust SR-IOV PF and VF driver samples.
+
+ To compile these as modules, choose M here:
+ the modules will be called rust_driver_sriov_pf and rust_driver_sriov_vf.
+ The VF module depends on the PF module.
+
+ 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 b986b681cde..f7142bc4ddc 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_pf.o rust_driver_sriov_vf.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
@@ -20,4 +21,53 @@ obj-$(CONFIG_SAMPLE_RUST_SOC) += rust_soc.o
rust_print-y := rust_print_main.o rust_print_events.o
+rust_driver_sriov_pf-y := rust_driver_sriov_pf_main.o rust_driver_sriov_pf_exports.o
+
+# Follow the nova-core/nova-drm cross-crate rules in drivers/gpu/Makefile.
+# Export Rust symbols from the PF only if the VF actually references them.
+sriov-pf-export-deps := $(if $(CONFIG_SAMPLE_RUST_DRIVER_SRIOV),$(obj)/rust_driver_sriov_vf.o)
+
+rust_needed_exports = \
+ { $(if $(strip $(2)),$(NM) -u $(2);,) echo "__DEFINED_RUST_SYMBOLS__"; \
+ $(NM) -p --defined-only $(1); } | \
+ awk -v fmt='$(3)' ' \
+ /^__DEFINED_RUST_SYMBOLS__$$/ { defs = 1; next } \
+ !defs { if ($$NF ~ /^_R/) needed[$$NF] = 1; next } \
+ defs && $$2 ~ /(T|R|D|B)/ && $$3 ~ /^_R/ && \
+ $$3 !~ /_(init|cleanup)_module$$/ && \
+ $$3 !~ /__(pfx|cfi|odr_asan)/ && \
+ $$3 in needed { printf fmt, $$3 } \
+ '
+
+quiet_cmd_exports = EXPORTS $@
+ cmd_exports = \
+ $(call rust_needed_exports,$<,$(sriov-pf-export-deps),EXPORT_SYMBOL_RUST_GPL(%s);\n) > $@
+
+$(obj)/exports_rust_driver_sriov_pf_generated.h: $(obj)/rust_driver_sriov_pf_main.o $(sriov-pf-export-deps) FORCE
+ $(call if_changed,exports)
+
+targets += exports_rust_driver_sriov_pf_generated.h
+
+$(obj)/rust_driver_sriov_pf_exports.o: $(obj)/exports_rust_driver_sriov_pf_generated.h
+CFLAGS_rust_driver_sriov_pf_exports.o := -I $(objtree)/$(obj)
+
+ifdef CONFIG_MODVERSIONS
+# The C export shim declares Rust symbols as `extern int`, so reuse its export
+# list but generate symbol CRCs from the Rust object instead of the shim's DWARF.
+$(obj)/rust_driver_sriov_pf_exports.o: private cmd_gensymtypes_c = \
+ $(call getexportsymbols,\1) | \
+ $(objtree)/scripts/gendwarfksyms/gendwarfksyms \
+ $(if $(KBUILD_GENDWARFKSYMS_STABLE), --stable) \
+ $(if $(KBUILD_SYMTYPES), --symtypes $(@:.o=.symtypes),) \
+ $(obj)/rust_driver_sriov_pf_main.o
+endif
+
+# Output the PF's crate metadata for use by the VF at compile time.
+RUSTFLAGS_rust_driver_sriov_pf_main.o += --crate-name rust_driver_sriov_pf \
+ --emit=metadata=$(objtree)/$(obj)/librust_driver_sriov_pf.rmeta
+
+# Allow the VF to import the PF's types.
+$(obj)/rust_driver_sriov_vf.o: $(obj)/rust_driver_sriov_pf_main.o
+RUSTFLAGS_rust_driver_sriov_vf.o := -L $(objtree)/$(obj) --extern rust_driver_sriov_pf
+
subdir-$(CONFIG_SAMPLE_RUST_HOSTPROGS) += hostprogs
diff --git a/samples/rust/rust_driver_sriov_pf_exports.c b/samples/rust/rust_driver_sriov_pf_exports.c
new file mode 100644
index 00000000000..49e435f8f6e
--- /dev/null
+++ b/samples/rust/rust_driver_sriov_pf_exports.c
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/* Export the PF crate's symbols used by the VF driver. */
+
+#include <linux/export.h>
+
+#define EXPORT_SYMBOL_RUST_GPL(sym) extern int sym; EXPORT_SYMBOL_GPL(sym)
+
+#include "exports_rust_driver_sriov_pf_generated.h"
diff --git a/samples/rust/rust_driver_sriov_pf_main.rs b/samples/rust/rust_driver_sriov_pf_main.rs
new file mode 100644
index 00000000000..b0795663aea
--- /dev/null
+++ b/samples/rust/rust_driver_sriov_pf_main.rs
@@ -0,0 +1,164 @@
+// 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.
+//!
+//! Load `rust_driver_sriov_vf` with `modprobe` to load both the PF and VF drivers.
+//! The VF module depends on the PF module through [`submit_request()`].
+//!
+//! [igb]: https://www.qemu.org/docs/master/system/devices/igb.html
+//! [vIOMMU]: https://wiki.qemu.org/Features/VT-d
+
+use kernel::{
+ device::{
+ Bound,
+ Core, //
+ },
+ new_mutex,
+ pci,
+ prelude::*,
+ sync::Mutex,
+ types::CovariantForLt, //
+};
+
+struct SamplePfDriver;
+
+#[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)
+ }
+}
+
+/// Submits a request to the PF associated with a bound VF.
+// Keep this call out of line so the VF module has a symbol dependency on the PF module.
+#[inline(never)]
+pub fn submit_request(vf: &pci::Device<Bound>) -> Result<u64> {
+ vf.vf_registration_data::<PfApiForLt>()?.submit(vf)
+}
+
+#[pin_data]
+struct PfDriverData<'bound> {
+ #[pin]
+ _registration: pci::VfRegistration<'bound, PfApiForLt>,
+ pdev: &'bound pci::Device<Bound>,
+}
+
+kernel::pci_device_table!(
+ PF_TABLE,
+ <SamplePfDriver as pci::Driver>::IdInfo,
+ [(
+ // E1000_DEV_ID_82576
+ pci::DeviceId::from_id(pci::Vendor::INTEL, 0x10c9),
+ ()
+ )]
+);
+
+#[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 {
+ try_pin_init!(PfDriverData {
+ _: {
+ dev_info!(
+ pdev,
+ "Probe Rust SR-IOV PF sample (PCI ID: {}, 0x{:x}).\n",
+ pdev.vendor_id(),
+ pdev.device_id()
+ );
+ },
+ // SAFETY: The registration is embedded in the PF driver's private data.
+ _registration <- unsafe {
+ pci::VfRegistration::new(
+ pdev,
+ try_pin_init!(PfApi {
+ pdev,
+ requests <- new_mutex!(0),
+ }),
+ )
+ },
+ _: {
+ pdev.enable_device_mem()?;
+ pdev.set_master();
+ },
+ pdev,
+ })
+ }
+
+ fn sriov_enable<'a>(
+ dev: &'a pci::Device<Core<'_>>,
+ data: Pin<&Self::Data<'a>>,
+ token: pci::SriovEnable<'a>,
+ ) -> Result<pci::SriovEnabled<'a>> {
+ dev_info!(
+ data.pdev,
+ "Enable SR-IOV (PCI ID: {}, 0x{:x}).\n",
+ data.pdev.vendor_id(),
+ data.pdev.device_id()
+ );
+
+ let num_vfs = token.num_vfs();
+ let enabled = token.enable(num_vfs)?;
+ assert_eq!(dev.num_vf(), num_vfs);
+ Ok(enabled)
+ }
+
+ fn sriov_disable<'a>(
+ dev: &'a pci::Device<Core<'_>>,
+ data: Pin<&Self::Data<'a>>,
+ token: pci::SriovDisable<'a>,
+ ) -> Result {
+ dev_info!(
+ data.pdev,
+ "Disable SR-IOV (PCI ID: {}, 0x{:x}).\n",
+ data.pdev.vendor_id(),
+ data.pdev.device_id()
+ );
+
+ token.disable();
+ assert_eq!(dev.num_vf(), 0);
+ Ok(())
+ }
+}
+
+kernel::module_pci_driver! {
+ type: SamplePfDriver,
+ name: "rust_driver_sriov_pf",
+ authors: ["Peter Colberg"],
+ description: "Rust SR-IOV PF driver",
+ license: "GPL v2",
+}
diff --git a/samples/rust/rust_driver_sriov_vf.rs b/samples/rust/rust_driver_sriov_vf.rs
new file mode 100644
index 00000000000..bc8e5fdc8ce
--- /dev/null
+++ b/samples/rust/rust_driver_sriov_vf.rs
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Virtual Function driver for the Rust SR-IOV sample.
+
+use kernel::{
+ device::{
+ Bound,
+ Core, //
+ },
+ pci,
+ prelude::*, //
+};
+
+struct SampleVfDriver;
+
+#[pin_data]
+struct VfDriverData<'bound> {
+ pdev: &'bound pci::Device<Bound>,
+}
+
+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 SampleVfDriver {
+ type IdInfo = ();
+ type Data<'bound> = VfDriverData<'bound>;
+
+ 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 {
+ try_pin_init!(VfDriverData {
+ _: {
+ dev_info!(
+ pdev,
+ "Probe Rust SR-IOV VF sample (PCI ID: {}, 0x{:x}).\n",
+ pdev.vendor_id(),
+ pdev.device_id()
+ );
+ },
+ _: {
+ let request = rust_driver_sriov_pf::submit_request(pdev)?;
+ dev_info!(pdev, "Submitted request {} through PF data.\n", request);
+ },
+ _: {
+ pdev.enable_device_mem()?;
+ pdev.set_master();
+ },
+ pdev,
+ })
+ }
+}
+
+kernel::module_pci_driver! {
+ type: SampleVfDriver,
+ name: "rust_driver_sriov_vf",
+ authors: ["Peter Colberg"],
+ description: "Rust SR-IOV VF driver",
+ license: "GPL v2",
+}
--
2.43.7
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 9/9] samples: rust: add Rust SR-IOV PF and VF driver samples
2026-10-30 17:12 ` [PATCH v5 9/9] samples: rust: add Rust SR-IOV PF and VF driver samples Simon Song
@ 2026-10-30 17:26 ` sashiko-bot
0 siblings, 0 replies; 19+ messages in thread
From: sashiko-bot @ 2026-10-30 17:26 UTC (permalink / raw)
To: Simon Song, linux-pci
> From: Peter Colberg <peter@colberg.org>
>
> Add separate PF and VF driver modules that demonstrate SR-IOV using
> QEMU's 82576 (igb) emulation.
>
> The PF publishes a pinned API object in its private data and exposes a
> submit_request() helper. The VF calls this helper with its Bound device
> borrow. The helper performs the typed registration lookup in the PF
> crate, keeping the API object and its lifetime encoding private.
>
> Adapt the nova-core/nova-drm rules in drivers/gpu/Makefile, preserving
> their metadata, export-selection and MODVERSIONS recipes with the sample
> object names and paths. Set the PF crate name explicitly because its Rust
> root file has a _main suffix.
>
> Keep the helper out of line so the VF module has a real symbol dependency
> on the PF module. The module loader therefore holds the PF module while
> the VF module is loaded, and modprobe loads the dependency automatically.
>
> Each driver has its own module registration. The VF module can be unloaded
> and reloaded while the PF remains bound. Unbinding the PF disables SR-IOV
> and removes its VFs before releasing the registered data. The shared
> Kconfig option builds both drivers as modules or both into the kernel.
>
> Link: https://www.qemu.org/docs/master/system/devices/igb.html
> Signed-off-by: Peter Colberg <peter@colberg.org>
> Co-developed-by: Zhi Wang <zhiw@nvidia.com>
> Signed-off-by: Zhi Wang <zhiw@nvidia.com>
> Signed-off-by: Simon Song <xinmengs@nvidia.com>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261030171230.196717-1-xinmengs@nvidia.com?part=9
^ permalink raw reply [flat|nested] 19+ messages in thread