[PATCH 13/24] rust: auxiliary: make Driver trait lifetime-parameterized

Danilo Krummrich
2026-04-27T22:13:30Z

Make auxiliary::Driver take a lifetime parameter 'a that ties device
resources to the binding scope.

Internally, Adapter<T: Driver> becomes Adapter<F: ForLt> with a bound
for<'a> F::Of<'a>: Driver<'a>; module_auxiliary_driver! wraps the driver
type in ForLt!() so drivers don't have to.

Signed-off-by: Danilo Krummrich <dakr@kernel.org>
---
drivers/gpu/drm/nova/driver.rs | 9 ++--
rust/kernel/auxiliary.rs | 59 ++++++++++++++++++---------
samples/rust/rust_driver_auxiliary.rs | 12 ++++--
3 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/drivers/gpu/drm/nova/driver.rs b/drivers/gpu/drm/nova/driver.rs
index b1af0a099551..183d0e679a0b 100644
--- a/drivers/gpu/drm/nova/driver.rs
+++ b/drivers/gpu/drm/nova/driver.rs
@@ -42,18 +42,21 @@ pub(crate) struct NovaData {
kernel::auxiliary_device_table!(
AUX_TABLE,
MODULE_AUX_TABLE,
- <NovaDriver as auxiliary::Driver>::IdInfo,
+ <NovaDriver as auxiliary::Driver<'_>>::IdInfo,
[(
auxiliary::DeviceId::new(NOVA_CORE_MODULE_NAME, AUXILIARY_NAME),
()
)]
);

-impl auxiliary::Driver for NovaDriver {
+impl<'a> auxiliary::Driver<'a> for NovaDriver {
type IdInfo = ();
const ID_TABLE: auxiliary::IdTable<Self::IdInfo> = &AUX_TABLE;

- fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, Error> {
+ fn probe(
+ adev: &'a auxiliary::Device<Core>,
+ _info: &'a Self::IdInfo,
+ ) -> impl PinInit<Self, Error> + 'a {
let data = try_pin_init!(NovaData { adev: adev.into() });

let drm = drm::Device::<Self>::new(adev.as_ref(), data)?;
diff --git a/rust/kernel/auxiliary.rs b/rust/kernel/auxiliary.rs
index 8a278ddb5b95..f593a21a16be 100644
--- a/rust/kernel/auxiliary.rs
+++ b/rust/kernel/auxiliary.rs
@@ -38,22 +38,34 @@
};

/// An adapter for the registration of auxiliary drivers.
-pub struct Adapter<T: Driver>(T);
+///
+/// `F` is a [`ForLt`](trait@ForLt) type that maps lifetimes to the driver's device
+/// private data type, i.e. `F::Of<'a>` is the driver struct parameterized by `'a`. The macro
+/// `module_auxiliary_driver!` generates this automatically via `ForLt!()`.
+pub struct Adapter<F>(PhantomData<F>);

// SAFETY:
// - `bindings::auxiliary_driver` is a C type declared as `repr(C)`.
-// - `T` is the type of the driver's device private data.
+// - `F::Of<'static>` is the stored type of the driver's device private data.
// - `struct auxiliary_driver` embeds a `struct device_driver`.
// - `DEVICE_DRIVER_OFFSET` is the correct byte offset to the embedded `struct device_driver`.
-unsafe impl<T: Driver + 'static> driver::DriverLayout for Adapter<T> {
+unsafe impl<F> driver::DriverLayout for Adapter<F>
+where
+ F: ForLt + 'static,
+ for<'a> F::Of<'a>: Driver<'a>,
+{
type DriverType = bindings::auxiliary_driver;
- type DriverData = ForLt!(T);
+ type DriverData = F;
const DEVICE_DRIVER_OFFSET: usize = core::mem::offset_of!(Self::DriverType, driver);
}

// SAFETY: A call to `unregister` for a given instance of `DriverType` is guaranteed to be valid if
// a preceding call to `register` has been successful.
-unsafe impl<T: Driver + 'static> driver::RegistrationOps for Adapter<T> {
+unsafe impl<F> driver::RegistrationOps for Adapter<F>
+where
+ F: ForLt + 'static,
+ for<'a> F::Of<'a>: Driver<'a>,
+{
unsafe fn register(
adrv: &Opaque<Self::DriverType>,
name: &'static CStr,
@@ -64,7 +76,7 @@ unsafe fn register(
(*adrv.get()).name = name.as_char_ptr();
(*adrv.get()).probe = Some(Self::probe_callback);
(*adrv.get()).remove = Some(Self::remove_callback);
- (*adrv.get()).id_table = T::ID_TABLE.as_ptr();
+ (*adrv.get()).id_table = <F::Of<'static> as Driver<'static>>::ID_TABLE.as_ptr();
}

// SAFETY: `adrv` is guaranteed to be a valid `DriverType`.
@@ -79,7 +91,11 @@ unsafe fn unregister(adrv: &Opaque<Self::DriverType>) {
}
}

-impl<T: Driver + 'static> Adapter<T> {
+impl<F> Adapter<F>
+where
+ F: ForLt + 'static,
+ for<'a> F::Of<'a>: Driver<'a>,
+{
extern "C" fn probe_callback(
adev: *mut bindings::auxiliary_device,
id: *const bindings::auxiliary_device_id,
@@ -93,12 +109,12 @@ extern "C" fn probe_callback(
// SAFETY: `DeviceId` is a `#[repr(transparent)`] wrapper of `struct auxiliary_device_id`
// and does not add additional invariants, so it's safe to transmute.
let id = unsafe { &*id.cast::<DeviceId>() };
- let info = T::ID_TABLE.info(id.index());

from_result(|| {
- let data = T::probe(adev, info);
+ let info = <F::Of<'_> as Driver<'_>>::ID_TABLE.info(id.index());
+ let data = <F::Of<'_> as Driver<'_>>::probe(adev, info);

- adev.as_ref().set_drvdata::<ForLt!(T)>(data)?;
+ adev.as_ref().set_drvdata::<F>(data)?;
Ok(0)
})
}
@@ -111,19 +127,21 @@ extern "C" fn remove_callback(adev: *mut bindings::auxiliary_device) {
let adev = unsafe { &*adev.cast::<Device<device::CoreInternal>>() };

// 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>>`.
- let data = unsafe { adev.as_ref().drvdata_borrow::<ForLt!(T)>() };
+ // `probe_callback`, hence it's guaranteed that drvdata has been set.
+ let data = unsafe { adev.as_ref().drvdata_borrow::<F>() };

- T::unbind(adev, data);
+ <F::Of<'_> as Driver<'_>>::unbind(adev, data);
}
}

/// Declares a kernel module that exposes a single auxiliary driver.
#[macro_export]
macro_rules! module_auxiliary_driver {
- ($($f:tt)*) => {
- $crate::module_driver!(<T>, $crate::auxiliary::Adapter<T>, { $($f)* });
+ (type: $type:ty, $($rest:tt)*) => {
+ $crate::module_driver!(<T>, $crate::auxiliary::Adapter<T>, {
+ type: $crate::types::ForLt!($type),
+ $($rest)*
+ });
};
}

@@ -195,7 +213,7 @@ macro_rules! auxiliary_device_table {
/// The auxiliary driver trait.
///
/// Drivers must implement this trait in order to get an auxiliary driver registered.
-pub trait Driver {
+pub trait Driver<'a>: Send {
/// The type holding information about each device id supported by the driver.
///
/// TODO: Use associated_type_defaults once stabilized:
@@ -209,7 +227,10 @@ pub trait Driver {
/// Auxiliary driver probe.
///
/// Called when an auxiliary device is matches a corresponding driver.
- fn probe(dev: &Device<device::Core>, id_info: &Self::IdInfo) -> impl PinInit<Self, Error>;
+ fn probe(
+ dev: &'a Device<device::Core>,
+ id_info: &'a Self::IdInfo,
+ ) -> impl PinInit<Self, Error> + 'a;

/// Auxiliary driver unbind.
///
@@ -221,7 +242,7 @@ pub trait Driver {
/// operations to gracefully tear down the device.
///
/// Otherwise, release operations for driver resources should be performed in `Self::drop`.
- fn unbind(dev: &Device<device::Core>, this: Pin<&Self>) {
+ fn unbind(dev: &'a Device<device::Core>, this: Pin<&'a Self>) {
let _ = (dev, this);
}
}
diff --git a/samples/rust/rust_driver_auxiliary.rs b/samples/rust/rust_driver_auxiliary.rs
index f57b2b03adb6..d35963ac7fa4 100644
--- a/samples/rust/rust_driver_auxiliary.rs
+++ b/samples/rust/rust_driver_auxiliary.rs
@@ -26,16 +26,19 @@
kernel::auxiliary_device_table!(
AUX_TABLE,
MODULE_AUX_TABLE,
- <AuxiliaryDriver as auxiliary::Driver>::IdInfo,
+ <AuxiliaryDriver as auxiliary::Driver<'_>>::IdInfo,
[(auxiliary::DeviceId::new(MODULE_NAME, AUXILIARY_NAME), ())]
);

-impl auxiliary::Driver for AuxiliaryDriver {
+impl<'a> auxiliary::Driver<'a> for AuxiliaryDriver {
type IdInfo = ();

const ID_TABLE: auxiliary::IdTable<Self::IdInfo> = &AUX_TABLE;

- fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, Error> {
+ fn probe(
+ adev: &'a auxiliary::Device<Core>,
+ _info: &'a Self::IdInfo,
+ ) -> impl PinInit<Self, Error> + 'a {
dev_info!(
adev,
"Probing auxiliary driver for auxiliary device with id={}\n",
@@ -123,7 +126,8 @@ struct SampleModule {
#[allow(clippy::type_complexity)]
_pci_driver: driver::Registration<pci::Adapter<ForLt!(ParentDriver)>>,
#[pin]
- _aux_driver: driver::Registration<auxiliary::Adapter<AuxiliaryDriver>>,
+ #[allow(clippy::type_complexity)]
+ _aux_driver: driver::Registration<auxiliary::Adapter<ForLt!(AuxiliaryDriver)>>,
}

impl InPlaceModule for SampleModule {
--
2.54.0