Add Rust PCI SR-IOV support

(quoted diff) +2 -0

+        to_result(unsafe { bindings::pci_enable_sriov(self.as_raw(), nr_virtfn) })
+    }

rust/kernel/pci/iov.rs +4 -0

+        // SAFETY: `self.as_raw()` is valid and this call runs in the PCI core callback context.
+        unsafe { bindings::pci_num_vf(self.as_raw()) }
+    }
+}

Quoted 4 lines · Zhi Wang

(quoted diff) +2 -0

+impl Device<device::Core<'_>> {
+    /// Returns the number of Virtual Functions (VF) enabled for a

Physical Function (PF).
+ pub fn num_vf(&self) -> i32 {

For the reasons mentioned in patch 1, I'd make this return u16.

I suggest to do the converstion with .try_into().expect("pdev->sriov->num_VFs is u16").

Quoted 5 lines

+ // SAFETY: self.as_raw() is valid and this call runs in
the PCI core callback context.

rust/kernel/pci/iov.rs +3 -0

+        unsafe { bindings::pci_num_vf(self.as_raw()) }
+    }
+}

rust/kernel/pci.rs +2 -0

index 1599b3a613d7..8782e9b06e64 100644
@@ -51,6 +51,8 @@
     Extended,
     Normal, //
 };
+#[cfg(CONFIG_PCI_IOV)]
+pub use self::iov::VfRegistration;
 pub use self::irq::{
     IrqType,
     IrqTypes,

rust/kernel/pci.rs +6 -0

+        try_pin_init!(Self {
+            type_id: TypeId::of::<F>(),
+            data <- data,
+        })
+    }
+}

rust/kernel/pci.rs +9 -0

+    pub unsafe fn new(
+        pdev: &'a Device<device::Core<'_>>,
+        data: impl PinInit<F::Of<'a>, Error> + 'a,
+    ) -> impl PinInit<Self, Error> + 'a {
+        let pdev: &'a Device<device::Bound> = pdev;
+        try_pin_init!(Self {
+            _: {
+                if pdev.is_virtfn() {
+                    return Err(ENODEV);

rust/kernel/pci.rs +35 -0

+
+                // 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

rust/kernel/pci.rs +53 -0

+        }
+
+        // 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, [`ENOENT`] if 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.
+    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()`].
+    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>() }
+    }
+}

Signature · 1 line

2.53.0

Quoted 19 lines · Zhi Wang

rust/kernel/pci.rs +2 -0

index 1599b3a613d7..8782e9b06e64 100644
@@ -51,6 +51,8 @@
     Extended,
     Normal, //
 };
+#[cfg(CONFIG_PCI_IOV)]
+pub use self::iov::VfRegistration;
 pub use self::irq::{
     IrqType,
     IrqTypes,

@@ -331,6 +333,9 @@ fn probe<'bound>(
     /// operations to gracefully tear down the device.
     ///
     /// Otherwise, release operations for driver resources should

be performed in Drop.
+ ///

Quoted 4 lines

+ /// For a PF with enabled VFs, VfRegistration disables
SR-IOV when it is dropped. This
+ /// callback must leave resources accessed by VF drivers
available until then.

I don't think we need this comment, neither this callback (which I plan to remove anyway) nor T::Data::drop() can remove resources that can still be accessed by VF drivers in the first place.

You could have something like Mutex<Option<_>> of course, but that would be intentional then.

rust/kernel/pci.rs

Quoted 7 lines

!= 0 {
+ // SAFETY: This initializer runs during PF
probing, and no VFs are enabled.
+ if !unsafe {
(*pdev.as_raw()).vf_registration_data_rust }.is_null() {

rust/kernel/pci.rs +2 -0

+                    return Err(EBUSY);
+                }

Those two checks can go into the first _: block, no?

Quoted 7 lines

rust/kernel/pci.rs +2 -0

+
+                // SAFETY: The data is initialized and pinned, the

slot is unoccupied, and
+ // no VF can access it yet. No fallible work
follows publication.

rust/kernel/pci.rs +2 -0

+                unsafe {
+                    (*pdev.as_raw()).vf_registration_data_rust =

rust/kernel/pci.rs

Quoted 10 lines

rust/kernel/pci.rs +2 -0

+    ///
+    /// 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<'_>>> {

rust/kernel/pci.rs +3 -0

+        if !self.is_virtfn() {
+            return Err(ENODEV);
+        }

We don't want to exclude PF drivers to access this. Have a look at drivers/gpu/nova-core/api.rs, it makes sense for the PF driver to provide a helper API around this.

rust/kernel/pci.rs

Quoted 12 lines

+ // 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.

rust/kernel/pci.rs +7 -0

+        let ptr = unsafe {
+            let pf = (*self.as_raw()).__bindgen_anon_1.physfn;
+            (*pf).vf_registration_data_rust
+        };
+
+        if ptr.is_null() {
+            return Err(ENOENT);

Maybe ENODEV?

Quoted 75 lines

rust/kernel/pci.rs +3 -0

+        }
+
+        // SAFETY: The registration keeps its data installed until

VF removal completes,

rust/kernel/pci.rs +2 -0

+        // including when probe initialization rolls back.
+        // `ptr` points to a `VfRegistrationData` whose first

field is a TypeId.

rust/kernel/pci.rs +6 -0

+        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.

rust/kernel/pci.rs +6 -0

+        let data_ptr = unsafe {
+            let vfrd = ptr.cast::<VfRegistrationData<'_, F>>();
+            &raw const (*vfrd).data
+        };
+
+        // SAFETY: `data` is structurally pinned inside

VfRegistrationData.

rust/kernel/pci.rs +4 -0

+        Ok(unsafe { Pin::new_unchecked(&*data_ptr) })
+    }
+
+    /// Access the VF registration data through a closure with an

HRTB lifetime.

rust/kernel/pci.rs +2 -0

+    ///
+    /// `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.

rust/kernel/pci.rs +2 -0

+    ///
+    /// 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.

rust/kernel/pci.rs +5 -0

+    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>()? };

rust/kernel/pci.rs +6 -0

+        Ok(f(pinned))
+    }
+
+    /// Returns a pinned reference to the VF registration data.
+    ///
+    /// Available only when `F` implements

[CovariantForLt](trait@crate::types::CovariantForLt),

rust/kernel/pci.rs +3 -0

+    /// guaranteeing that shortening the PF data lifetime is sound.
+    ///
+    /// For non-covariant types, use

[Self::vf_registration_data_with()].

rust/kernel/pci.rs +2 -0

+    ///
+    /// 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.

rust/kernel/pci.rs +3 -0

+        unsafe { self.vf_registration_data_pinned::<F>() }
+    }
+}

Signature · 1 line

2.53.0

+pub struct SriovEnable<'callback> {

rust/kernel/pci/iov.rs +26 -0

+}
+
+impl<'callback> SriovEnable<'callback> {
+    /// Returns the number of VFs requested for this callback.
+    pub fn num_vfs(&self) -> u32 {
+        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: u32) -> Result<SriovEnabled<'callback>> {
+        if num_vfs == 0 || num_vfs > self.num_vfs {
+            return Err(EINVAL);
+        }
+        let num_vfs = c_int::try_from(num_vfs).map_err(|_| EOVERFLOW)?;
+
+        // 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)?;

rust/kernel/pci/iov.rs +10 -0

+    }
+}
+
+impl Drop for SriovEnabled<'_> {
+    fn drop(&mut self) {
+        if let Some(pdev) = self.pdev.take() {
+            pdev.disable_sriov();
+        }
+    }
+}

Quoted 1 line · Zhi Wang

+pub struct SriovEnable<'callback> {

Quoted 4 lines

rust/kernel/pci/iov.rs +3 -0

+/// Enabled VFs awaiting successful completion of `sriov_enable()`.
+pub struct SriovEnabled<'callback> {
+    pdev: Option<&'callback

Device<device::CoreInternal<'callback>>>,

This doesn't need to be an Option.

rust/kernel/pci/iov.rs pub(crate) fn disable_sriov(&self) { · line 139

Quoted 8 lines

rust/kernel/pci/iov.rs +8 -0

+    num_vfs: c_int,
+}
+
+impl SriovEnabled<'_> {
+    #[expect(dead_code)]
+    fn disarm(mut self) -> c_int {
+        self.pdev = None;
+        self.num_vfs

Instead of the Option dance, you can use ManuallyDrop to prevent the destructor from running.

Quoted 10 lines

rust/kernel/pci/iov.rs +10 -0

+    }
+}
+
+impl Drop for SriovEnabled<'_> {
+    fn drop(&mut self) {
+        if let Some(pdev) = self.pdev.take() {
+            pdev.disable_sriov();
+        }
+    }
+}

+ dev: &'bound Device<device::Core<'_>>,

+ this: Pin<&Self::Data<'bound>>,

rust/kernel/pci.rs +5 -0

+        token: SriovEnable<'callback>,
+    ) -> Result<SriovEnabled<'callback>> {
+        let _ = (dev, this, token);
+        build_error!(crate::error::VTABLE_DEFAULT_ERROR)
+    }

rust/kernel/pci.rs +9 -0

+    #[cfg(CONFIG_PCI_IOV)]
+    fn sriov_disable<'bound>(
+        dev: &'bound Device<device::Core<'_>>,
+        this: Pin<&Self::Data<'bound>>,
+        token: SriovDisable<'_>,
+    ) -> Result {
+        let _ = (dev, this, token);
+        build_error!(crate::error::VTABLE_DEFAULT_ERROR)
+    }
 }

rust/kernel/pci/iov.rs +9 -0

+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 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()`.

rust/kernel/pci/iov.rs +21 -0

+            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: u32::from(num_vfs),
+                    },
+                )?;
+                Ok(enabled.disarm())
+            }
+        })
+    }
+}

samples/rust/rust_driver_sriov.rs new file +11 -0

+}
+
+kernel::pci_device_table!(
+    PF_TABLE,
+    <SamplePfDriver as pci::Driver>::IdInfo,
+    [(
+        // E1000_DEV_ID_82576
+        pci::DeviceId::from_id(pci::Vendor::INTEL, 0x10c9),
+        ()
+    )]
+);

samples/rust/rust_driver_sriov.rs new file +30 -0

+#[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_enable`.
+                _registration <- unsafe {
+                    pci::VfRegistration::new(

samples/rust/rust_driver_sriov.rs new file +20 -0

+#[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;

samples/rust/rust_driver_sriov.rs new file +6 -0

+    }
+}
+
+#[pinned_drop]
+impl PinnedDrop for PfDriverData<'_> {
+    fn drop(self: Pin<&mut Self>) {

On Wed Sep 30, 2026 at 12:18 PM CEST, Zhi Wang wrote:

Quoted 6 lines

samples/rust/rust_driver_sriov.rs new file +6 -0

+kernel::pci_device_table!(
+    VF_TABLE,
+    <SampleVfDriver as pci::Driver>::IdInfo,
+    [(
+        // E1000_DEV_ID_82576_VF
+        pci::DeviceId::from_id(pci::Vendor::INTEL, 0x10ca),

samples/rust/rust_driver_sriov.rs line 87

Quoted 3 lines

samples/rust/rust_driver_sriov.rs new file +3 -0

+        ()
+    )]
+);

Since this is two drivers in the same module, can we please put everythng that belongs to the PF driver first and then everything that belongs into the VF driver second please? We could also make it two separate files.

Quoted 35 lines

samples/rust/rust_driver_sriov.rs new file +15 -0

+#[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",

samples/rust/rust_driver_sriov.rs new file +10 -0

+                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_enable.

samples/rust/rust_driver_sriov.rs new file +2 -0

+                _registration <- unsafe {
+                    pci::VfRegistration::new(

samples/rust/rust_driver_sriov.rs line 138

Quoted 10 lines

samples/rust/rust_driver_sriov.rs new file +10 -0

+                        pdev,
+                        try_pin_init!(PfApi {
+                            pdev,
+                            requests <- new_mutex!(0),
+                        }),
+                    )
+                },
+                pdev: pdev.into(),
+            }))
+        })

Let's put everything within a single try_pin_init!() block please.

Quoted 29 lines

samples/rust/rust_driver_sriov.rs new file +15 -0

+#[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",

samples/rust/rust_driver_sriov.rs new file +6 -0

+                pdev.vendor_id(),
+                pdev.device_id()
+            );
+
+            let pdev_bound: &'bound pci::Device<Bound> = pdev;
+            let pf_api =

pdev_bound.vf_registration_data::<PfApiForLt>()?; +

samples/rust/rust_driver_sriov.rs new file +5 -0

+            pdev.enable_device_mem()?;
+            pdev.set_master();
+
+            let request = pf_api.submit(pdev)?;
+            dev_info!(pdev, "Submitted request {} through PF

data.\n", request); +

Review

Quoted 2 lines

(quoted diff) +2 -0

+            Ok(try_pin_init!(VfDriverData { pdev: pdev.into() }))
+        })

Same here. Also no need for pdev_bound, it derefs automatically, you can just call pdev.vf_registration_data().

Quoted 6 lines

samples/rust/rust_driver_sriov.rs new file +6 -0

+    }
+}
+
+#[pinned_drop]
+impl PinnedDrop for PfDriverData<'_> {
+    fn drop(self: Pin<&mut Self>) {

samples/rust/rust_driver_sriov.rs line 222

Quoted 10 lines

samples/rust/rust_driver_sriov.rs new file +10 -0

+        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");
+    }
+}

Let's drop those, we don't really need them.

Here's the two probe() functions I came up with:

    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()
                );
            },

            _: {
                pdev.enable_device_mem()?;
                pdev.set_master();
            },

            // 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_enable`.
            _registration <- unsafe {
                pci::VfRegistration::new(
                    pdev,
                    try_pin_init!(PfApi {
                        pdev,
                        requests <- new_mutex!(0),
                    }),
                )
            },

            pdev,
        })
    }

    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()
                );
            },

            _: {
                pdev.enable_device_mem()?;
                pdev.set_master();
            },

            pdev,

            _: {
                let pf_api =

pdev.vf_registration_data::<PfApiForLt>()?;

let request = pf_api.submit(pdev)?; dev_info!(pdev, "Submitted request {} through PF
data.\n", request); },

        })
    }

Note that enable_device() and set_master() have their own block as they will be replaced with a pci::DeviceEnableGuard soon.