Skip to contentSkip to conversation

Introduce DeviceContext

PATCH Superseded Lyude Paul 3 participants 10 messages Jan 22 – Jan 23

Subsystems (5)

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Lyude Paul

author
#0 lore raw

v3 cover Introduce DeviceContext

Previous version of this patch series:
https://patchwork.freedesktop.org/series/160217/#rev1

One of the unsolved issues we still have with the rust DRM bindings is the ability to limit certain Device operations to contexts where we can guarantee that a Device has been fully initialized and registered with userspace, or vice-versa (e.g. must be unregistered).

While the previous solution for this that I had was simply not exposing drm::Device at all until the device has been registered with userspace, unfortunately this isn't enough since:

* As we found out with Tyr, drivers occasionally need to be able to create GEM objects before device registration
* We would still need to be able to handle KMS callbacks which could be invoked after KMS init but before userspace registration (not handled in this series specifically, but DeviceContext will be required for handling this).

This patch series provides a pretty nice solution to this, by implementing a very similar solution to kernel::device::DeviceContext:
introducing our own DeviceContext type state.

This patch series depends on the two pre-requisite patch series:

* https://patchwork.freedesktop.org/series/160523/
* https://patchwork.freedesktop.org/series/160525/

Series-wide changes

V2:
* s/DeviceCtx/DeviceContext/ for consistency
* Move private driver-data availability to the Registration DeviceContext
* s/AnyCtx/Init/

More changes described in each patch description.

Lyude Paul (3):
rust/drm: Introduce DeviceContext
rust/drm: Don't setup private driver data until registration rust/drm/gem: Use DeviceContext with GEM objects

 drivers/gpu/drm/nova/driver.rs |  10 +-
 drivers/gpu/drm/nova/gem.rs    |  11 +-
 drivers/gpu/drm/tyr/driver.rs  |  12 +-
 drivers/gpu/drm/tyr/gem.rs     |   3 +-
 rust/kernel/drm/device.rs      | 246 +++++++++++++++++++++++++--------
 rust/kernel/drm/driver.rs      |  55 ++++++--
 rust/kernel/drm/gem/mod.rs     |  64 ++++++---
 rust/kernel/drm/mod.rs         |   4 +
 8 files changed, 303 insertions(+), 102 deletions(-)

base-commit: 6ea52b6d8f33ae627f4dcf43b12b6e713a8b9331
prerequisite-patch-id: d596b2a5a81fb067cb267fe30b6e2d8fd47fddad
prerequisite-patch-id: 32f09c643498c714d92a6a87b3de220b5d37b41e
prerequisite-patch-id: 28f11c925aab9ed9d4fa70dbbf2c4a7accb5c05d

Signature · 1 line
2.52.0
author
#1 lore raw

PATCH v3 1/3 rust/drm: Introduce DeviceContext

One of the tricky things about DRM bindings in Rust is the fact that initialization of a DRM device is a multi-step process. It's quite normal for a device driver to start making use of its DRM device for tasks like creating GEM objects before userspace registration happens. This is an issue in rust though, since prior to userspace registration the device is only partly initialized. This means there's a plethora of DRM device operations we can't yet expose without opening up the door to UB if the DRM device in question isn't yet registered.

Additionally, this isn't something we can reliably check at runtime. And even if we could, performing an operation which requires the device be registered when the device isn't actually registered is a programmer bug, meaning there's no real way to gracefully handle such a mistake at runtime. And even if that wasn't the case, it would be horrendously annoying and noisy to have to check if a device is registered constantly throughout a driver.

In order to solve this, we first take inspiration from kernel::device::DeviceContext and introduce kernel::drm::DeviceContext. This provides us with a ZST type that we can generalize over to represent contexts where a device is known to have been registered with userspace at some point in time (Registered), along with contexts where we can't make such a guarantee (Uninit).

It's important to note we intentionally do not provide a DeviceContext which represents an unregistered device. This is because there's no reasonable way to guarantee that a device with long-living references to itself will not be registered eventually with userspace. Instead, we provide a new-type for this: UnregisteredDevice which can provide a guarantee that the Device has never been registered with userspace. To ensure this, we modify Registration so that creating a new Registration requires passing ownership of an UnregisteredDevice.

---
V2:
* Make sure that UnregisteredDevice is not thread-safe (since DRM device initialization is also not thread-safe)
* Rename from AnyCtx to Uninit, I think this name actually makes a bit more sense.
* Change assume_registered() to assume_ctx()
Since it looks like in some situations, we'll want to update the DeviceContext of a object to the latest DeviceContext we know the Device to be in.
* Rename Init to Uninit
When we eventually add KMS support, we're going to have 3 different DeviceContexts - Uninit, Init, Registered. Additionally, aside from not being registered there are a number of portions of the rest of the Device which also aren't usable before at least the Init context - so the naming of Uninit makes this a little clearer.
* s/DeviceContext/DeviceContext/
For consistency with the rest of the kernel
* Drop as_ref::<Device<T, Uninit>>() for now since I don't actually think we need this quite yet
V3:
* Get rid of drm_dev_ctx!, as we don't actually need to implement Send or Sync ourselves
* Remove mention of C function in drm::device::Registration rustdoc
* Add more documentation to the DeviceContext trait, go into detail about the various setup phases and such.
* Add missing period to comment in UnregisteredDevice::new().

 drivers/gpu/drm/nova/driver.rs |   8 +-
 drivers/gpu/drm/tyr/driver.rs  |  10 +-
 rust/kernel/drm/device.rs      | 179 +++++++++++++++++++++++++++------
 rust/kernel/drm/driver.rs      |  38 +++++--
 rust/kernel/drm/mod.rs         |   4 +
 5 files changed, 193 insertions(+), 46 deletions(-)
drivers/gpu/drm/nova/driver.rs +4 -4
index b1af0a099551d..99d6841b69cbc 100644
@@ -21,7 +21,7 @@ pub(crate) struct NovaDriver {
 }
 
 /// Convienence type alias for the DRM device type for this driver
-pub(crate) type NovaDevice = drm::Device<NovaDriver>;
+pub(crate) type NovaDevice<Ctx = drm::Registered> = drm::Device<NovaDriver, Ctx>;
 
 #[pin_data]
 pub(crate) struct NovaData {
@@ -56,10 +56,10 @@ impl auxiliary::Driver for NovaDriver {
     fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, Error> {
         let data = try_pin_init!(NovaData { adev: adev.into() });
 
-        let drm = drm::Device::<Self>::new(adev.as_ref(), data)?;
-        drm::Registration::new_foreign_owned(&drm, adev.as_ref(), 0)?;
+        let drm = drm::UnregisteredDevice::<Self>::new(adev.as_ref(), data)?;
+        let drm = drm::Registration::new_foreign_owned(drm, adev.as_ref(), 0)?;
 
-        Ok(Self { drm })
+        Ok(Self { drm: drm.into() })
     }
 }
 
drivers/gpu/drm/tyr/driver.rs +6 -4
index 2a45d02888253..ac265a60f5667 100644
@@ -30,7 +30,7 @@
 pub(crate) type IoMem = kernel::io::mem::IoMem<SZ_2M>;
 
 /// Convenience type alias for the DRM device type for this driver.
-pub(crate) type TyrDevice = drm::Device<TyrDriver>;
+pub(crate) type TyrDevice<Ctx = drm::Registered> = drm::Device<TyrDriver, Ctx>;
 
 #[pin_data(PinnedDrop)]
 pub(crate) struct TyrDriver {
@@ -133,10 +133,12 @@ fn probe(
                 gpu_info,
         });
 
-        let tdev: ARef<TyrDevice> = drm::Device::new(pdev.as_ref(), data)?;
-        drm::driver::Registration::new_foreign_owned(&tdev, pdev.as_ref(), 0)?;
+        let tdev = drm::UnregisteredDevice::<Self>::new(pdev.as_ref(), data)?;
+        let tdev = drm::driver::Registration::new_foreign_owned(tdev, pdev.as_ref(), 0)?;
 
-        let driver = TyrDriver { device: tdev };
+        let driver = TyrDriver {
+            device: tdev.into(),
+        };
 
         // We need this to be dev_info!() because dev_dbg!() does not work at
         // all in Rust for now, and we need to see whether probe succeeded.
rust/kernel/drm/device.rs +150 -29

273 lines not on this page · raw message

rust/kernel/drm/driver.rs +29 -9
index 5233bdebc9fcd..da9f1bfef1f14 100644
@@ -13,6 +13,10 @@
     prelude::*,
     sync::aref::ARef, //
 };
+use core::{
+    mem,
+    ptr::NonNull, //
+};
 
 /// Driver use the GEM memory manager. This should be set for all modern drivers.
 pub(crate) const FEAT_GEM: u32 = bindings::drm_driver_feature_DRIVER_GEM;
@@ -123,31 +127,47 @@ pub trait Driver {
 pub struct Registration<T: Driver>(ARef<drm::Device<T>>);
 
 impl<T: Driver> Registration<T> {
-    fn new(drm: &drm::Device<T>, flags: usize) -> Result<Self> {
+    fn new(drm: drm::UnregisteredDevice<T>, flags: usize) -> Result<Self> {
         // SAFETY: `drm.as_raw()` is valid by the invariants of `drm::Device`.
         to_result(unsafe { bindings::drm_dev_register(drm.as_raw(), flags) })?;
 
-        Ok(Self(drm.into()))
+        // SAFETY: We just called `drm_dev_register` above
+        let new = NonNull::from(unsafe { drm.assume_ctx() });
+
+        // Leak the ARef from UnregisteredDevice in preparation for transferring its ownership.
+        mem::forget(drm);
+
+        // SAFETY: `drm`'s `Drop` constructor was never called, ensuring that there remains at least
+        // one reference to the device - which we take ownership over here.
+        let new = unsafe { ARef::from_raw(new) };
+
+        Ok(Self(new))
     }
 
-    /// Registers a new [`Device`](drm::Device) with userspace.
+    /// Registers a new [`UnregisteredDevice`](drm::UnregisteredDevice) with userspace.
     ///
     /// Ownership of the [`Registration`] object is passed to [`devres::register`].
-    pub fn new_foreign_owned(
-        drm: &drm::Device<T>,
-        dev: &device::Device<device::Bound>,
+    pub fn new_foreign_owned<'a>(
+        drm: drm::UnregisteredDevice<T>,
+        dev: &'a device::Device<device::Bound>,
         flags: usize,
-    ) -> Result
+    ) -> Result<&'a drm::Device<T>>
     where
         T: 'static,
     {
-        if drm.as_ref().as_raw() != dev.as_raw() {
+        let this_dev: &device::Device = drm.as_ref();
+        if this_dev.as_raw() != dev.as_raw() {
             return Err(EINVAL);
         }
 
         let reg = Registration::<T>::new(drm, flags)?;
+        let drm = NonNull::from(reg.device());
+
+        devres::register(dev, reg, GFP_KERNEL)?;
 
-        devres::register(dev, reg, GFP_KERNEL)
+        // SAFETY: Since `reg` was passed to devres::register(), the device now owns the lifetime
+        // of the DRM registration - ensuring that this references lives for at least as long as 'a.
+        Ok(unsafe { drm.as_ref() })
     }
 
     /// Returns a reference to the `Device` instance for this registration.
rust/kernel/drm/mod.rs +4 -0
index 1b82b6945edf2..64a43cb0fe57c 100644
@@ -9,6 +9,10 @@
 pub mod ioctl;
 
 pub use self::device::Device;
+pub use self::device::DeviceContext;
+pub use self::device::Registered;
+pub use self::device::Uninit;
+pub use self::device::UnregisteredDevice;
 pub use self::driver::Driver;
 pub use self::driver::DriverInfo;
 pub use self::driver::Registration;
Signature · 1 line
2.52.0
maintainer Reviewed-by on v3 1/3
#2 lore raw

Re: [PATCH v3 1/3] rust/drm: Introduce DeviceContext

Hi Lyude,

Quoted 65 lines · Lyude Paul

One of the tricky things about DRM bindings in Rust is the fact that initialization of a DRM device is a multi-step process. It's quite normal for a device driver to start making use of its DRM device for tasks like creating GEM objects before userspace registration happens. This is an issue in rust though, since prior to userspace registration the device is only partly initialized. This means there's a plethora of DRM device operations we can't yet expose without opening up the door to UB if the DRM device in question isn't yet registered.

Additionally, this isn't something we can reliably check at runtime. And even if we could, performing an operation which requires the device be registered when the device isn't actually registered is a programmer bug, meaning there's no real way to gracefully handle such a mistake at runtime. And even if that wasn't the case, it would be horrendously annoying and noisy to have to check if a device is registered constantly throughout a driver.

In order to solve this, we first take inspiration from kernel::device::DeviceContext and introduce kernel::drm::DeviceContext. This provides us with a ZST type that we can generalize over to represent contexts where a device is known to have been registered with userspace at some point in time (Registered), along with contexts where we can't make such a guarantee (Uninit).

It's important to note we intentionally do not provide a DeviceContext which represents an unregistered device. This is because there's no reasonable way to guarantee that a device with long-living references to itself will not be registered eventually with userspace. Instead, we provide a new-type for this: UnregisteredDevice which can provide a guarantee that the Device has never been registered with userspace. To ensure this, we modify Registration so that creating a new Registration requires passing ownership of an UnregisteredDevice.

---
V2:
* Make sure that UnregisteredDevice is not thread-safe (since DRM device initialization is also not thread-safe)
* Rename from AnyCtx to Uninit, I think this name actually makes a bit more sense.
* Change assume_registered() to assume_ctx()
Since it looks like in some situations, we'll want to update the DeviceContext of a object to the latest DeviceContext we know the Device to be in.
* Rename Init to Uninit
When we eventually add KMS support, we're going to have 3 different DeviceContexts - Uninit, Init, Registered. Additionally, aside from not being registered there are a number of portions of the rest of the Device which also aren't usable before at least the Init context - so the naming of Uninit makes this a little clearer.
* s/DeviceContext/DeviceContext/
For consistency with the rest of the kernel
* Drop as_ref::<Device<T, Uninit>>() for now since I don't actually think we need this quite yet
V3:
* Get rid of drm_dev_ctx!, as we don't actually need to implement Send or Sync ourselves
* Remove mention of C function in drm::device::Registration rustdoc
* Add more documentation to the DeviceContext trait, go into detail about the various setup phases and such.
* Add missing period to comment in UnregisteredDevice::new().

Quoted 7 lines
drivers/gpu/drm/nova/driver.rs |   8 +-
drivers/gpu/drm/tyr/driver.rs  |  10 +-
rust/kernel/drm/device.rs      | 179 +++++++++++++++++++++++++++------
rust/kernel/drm/driver.rs      |  38 +++++--
rust/kernel/drm/mod.rs         |   4 +
5 files changed, 193 insertions(+), 46 deletions(-)
maintainer
#3 lore raw

Re: [PATCH v3 1/3] rust/drm: Introduce DeviceContext

In reply to Lyude Paul

drivers/gpu/drm/nova/driver.rs pub(crate) struct NovaDriver { · line 24

Quoted 10 lines · Lyude Paul
drivers/gpu/drm/nova/driver.rs +1 -1
index b1af0a099551d..99d6841b69cbc 100644
@@ -21,7 +21,7 @@ pub(crate) struct NovaDriver {
 }
 
 /// Convienence type alias for the DRM device type for this driver
-pub(crate) type NovaDevice = drm::Device<NovaDriver>;
+pub(crate) type NovaDevice<Ctx = drm::Registered> = drm::Device<NovaDriver, Ctx>;

Nothing for this patch (series), but I think we should get rid of this type alias, I think it's confusing.

drivers/gpu/drm/nova/driver.rs pub(crate) struct NovaDriver {

Quoted 9 lines
drivers/gpu/drm/nova/driver.rs +9 -0
+/// A typed DRM device with a specific [`drm::Driver`] implementation and [`DeviceContext`].
+///
+/// Since DRM devices can be used before being fully initialized and registered with userspace, `C`
+/// represents the furthest [`DeviceContext`] we can guarantee that this [`Device`] has reached.
+///
+/// Keep in mind: this means that an unregistered device can still have the registration state
+/// [`Registered`] as long as it was registered with userspace once in the past, and that the
+/// behavior of such a device is still well-defined. In such a situation, the behavior of any
+/// functions which interact with userspace will simply be no-ops. Additionally, a device with the

This is still not correct, the are not guaranteed to be no-ops. We can still have callbacks from userspace after the DRM device is unregistered.

Quoted 16 lines
drivers/gpu/drm/nova/driver.rs +16 -0
+/// registration state [`Uninit`] simply does not have a guaranteed registration state at compile
+/// time, and could be either registered or unregistered. Since there is no way to guarantee a
+/// long-lived reference to an unregistered device would remain unregistered, we do not provide a
+/// [`DeviceContext`] for this.
+///
+/// # Invariants
+///
+/// * `self.dev` is a valid instance of a `struct device`.
+/// * The data layout of `Self` remains the same across all implementations of `C`.
+/// * Any invariants for `C` also apply.
+#[repr(C)]
+pub struct Device<T: drm::Driver, C: DeviceContext = Registered> {
+    dev: Opaque<bindings::drm_device>,
+    data: T::Data,
+    _ctx: PhantomData<C>,
+}

<snip>

Quoted 9 lines
drivers/gpu/drm/nova/driver.rs +3 -4
-    /// Registers a new [`Device`](drm::Device) with userspace.
+    /// Registers a new [`UnregisteredDevice`](drm::UnregisteredDevice) with userspace.
     ///
     /// Ownership of the [`Registration`] object is passed to [`devres::register`].
-    pub fn new_foreign_owned(
-        drm: &drm::Device<T>,
-        dev: &device::Device<device::Bound>,
+    pub fn new_foreign_owned<'a>(
+        drm: drm::UnregisteredDevice<T>,

drivers/gpu/drm/nova/driver.rs

Quoted 10 lines
drivers/gpu/drm/nova/driver.rs +4 -2
+        dev: &'a device::Device<device::Bound>,
         flags: usize,
-    ) -> Result
+    ) -> Result<&'a drm::Device<T>>
     where
         T: 'static,
     {
-        if drm.as_ref().as_raw() != dev.as_raw() {
+        let this_dev: &device::Device = drm.as_ref();
+        if this_dev.as_raw() != dev.as_raw() {

I still think this change is unnecessary and the name 'this_dev' is misleading, as it actually is the parent device.

Quoted 13 lines
             return Err(EINVAL);
         }
 
         let reg = Registration::<T>::new(drm, flags)?;
drivers/gpu/drm/nova/driver.rs +6 -1
+        let drm = NonNull::from(reg.device());
+
+        devres::register(dev, reg, GFP_KERNEL)?;
 
-        devres::register(dev, reg, GFP_KERNEL)
+        // SAFETY: Since `reg` was passed to devres::register(), the device now owns the lifetime
+        // of the DRM registration - ensuring that this references lives for at least as long as 'a.
+        Ok(unsafe { drm.as_ref() })
     }
author
#4 lore raw

PATCH v3 2/3 rust/drm: Don't setup private driver data until registration

In reply to Lyude Paul

Now that we have a DeviceContext that we can use to represent whether a Device is known to have been registered, we can make it so that drivers can create their Devices but wait until the registration phase to assign their private data to the Device. This is desirable as some drivers need to make use of the DRM device early on before finalizing their private driver data.

As such, this change makes it so that the driver's private data can currently only be accessed through Device<T, Registered> types and not Device<T, Uninit>.

---
 drivers/gpu/drm/nova/driver.rs |  4 +--
 drivers/gpu/drm/tyr/driver.rs  |  4 +--
 rust/kernel/drm/device.rs      | 63 ++++++++++++++++++++--------------
 rust/kernel/drm/driver.rs      | 19 ++++++++--
 4 files changed, 58 insertions(+), 32 deletions(-)
drivers/gpu/drm/nova/driver.rs +2 -2
index 99d6841b69cbc..8cea5f68c3b04 100644
@@ -56,8 +56,8 @@ impl auxiliary::Driver for NovaDriver {
     fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, Error> {
         let data = try_pin_init!(NovaData { adev: adev.into() });
 
-        let drm = drm::UnregisteredDevice::<Self>::new(adev.as_ref(), data)?;
-        let drm = drm::Registration::new_foreign_owned(drm, adev.as_ref(), 0)?;
+        let drm = drm::UnregisteredDevice::<Self>::new(adev.as_ref())?;
+        let drm = drm::Registration::new_foreign_owned(drm, adev.as_ref(), data, 0)?;
 
         Ok(Self { drm: drm.into() })
     }
drivers/gpu/drm/tyr/driver.rs +2 -2
index ac265a60f5667..e73c56659ea75 100644
@@ -133,8 +133,8 @@ fn probe(
                 gpu_info,
         });
 
-        let tdev = drm::UnregisteredDevice::<Self>::new(pdev.as_ref(), data)?;
-        let tdev = drm::driver::Registration::new_foreign_owned(tdev, pdev.as_ref(), 0)?;
+        let tdev = drm::UnregisteredDevice::<Self>::new(pdev.as_ref())?;
+        let tdev = drm::driver::Registration::new_foreign_owned(tdev, pdev.as_ref(), data, 0)?;
 
         let driver = TyrDriver {
             device: tdev.into(),
rust/kernel/drm/device.rs +38 -25

111 lines not on this page · raw message

rust/kernel/drm/driver.rs +16 -3
index da9f1bfef1f14..a16605b407159 100644
@@ -15,7 +15,8 @@
 };
 use core::{
     mem,
-    ptr::NonNull, //
+    ptr::NonNull,
+    sync::atomic::*, //
 };
 
 /// Driver use the GEM memory manager. This should be set for all modern drivers.
@@ -127,7 +128,18 @@ pub trait Driver {
 pub struct Registration<T: Driver>(ARef<drm::Device<T>>);
 
 impl<T: Driver> Registration<T> {
-    fn new(drm: drm::UnregisteredDevice<T>, flags: usize) -> Result<Self> {
+    fn new(
+        drm: drm::UnregisteredDevice<T>,
+        data: impl PinInit<T::Data, Error>,
+        flags: usize,
+    ) -> Result<Self> {
+        // SAFETY:
+        // - `raw_data` is a valid pointer to uninitialized memory.
+        // - `raw_data` will not move until it is dropped.
+        unsafe { data.__pinned_init(drm.0.data.get().cast()) }?;
+
+        drm.data_is_init.store(true, Ordering::Relaxed);
+
         // SAFETY: `drm.as_raw()` is valid by the invariants of `drm::Device`.
         to_result(unsafe { bindings::drm_dev_register(drm.as_raw(), flags) })?;
 
@@ -150,6 +162,7 @@ fn new(drm: drm::UnregisteredDevice<T>, flags: usize) -> Result<Self> {
     pub fn new_foreign_owned<'a>(
         drm: drm::UnregisteredDevice<T>,
         dev: &'a device::Device<device::Bound>,
+        data: impl PinInit<T::Data, Error>,
         flags: usize,
     ) -> Result<&'a drm::Device<T>>
     where
@@ -160,7 +173,7 @@ pub fn new_foreign_owned<'a>(
             return Err(EINVAL);
         }
 
-        let reg = Registration::<T>::new(drm, flags)?;
+        let reg = Registration::<T>::new(drm, data, flags)?;
         let drm = NonNull::from(reg.device());
 
         devres::register(dev, reg, GFP_KERNEL)?;
Signature · 1 line
2.52.0
maintainer
#5 lore raw

Re: [PATCH v3 2/3] rust/drm: Don't setup private driver data until registration

Hi Lyude,

Quoted 116 lines · Lyude Paul

Now that we have a DeviceContext that we can use to represent whether a Device is known to have been registered, we can make it so that drivers can create their Devices but wait until the registration phase to assign their private data to the Device. This is desirable as some drivers need to make use of the DRM device early on before finalizing their private driver data.

As such, this change makes it so that the driver's private data can currently only be accessed through Device<T, Registered> types and not Device<T, Uninit>.

---

drivers/gpu/drm/nova/driver.rs |  4 +--
drivers/gpu/drm/tyr/driver.rs  |  4 +--
rust/kernel/drm/device.rs      | 63 ++++++++++++++++++++--------------
rust/kernel/drm/driver.rs      | 19 ++++++++--
4 files changed, 58 insertions(+), 32 deletions(-)
drivers/gpu/drm/nova/driver.rs +2 -2
index 99d6841b69cbc..8cea5f68c3b04 100644
@@ -56,8 +56,8 @@ impl auxiliary::Driver for NovaDriver {
    fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Self, Error> {
        let data = try_pin_init!(NovaData { adev: adev.into() });
 
-        let drm = drm::UnregisteredDevice::<Self>::new(adev.as_ref(), data)?;
-        let drm = drm::Registration::new_foreign_owned(drm, adev.as_ref(), 0)?;
+        let drm = drm::UnregisteredDevice::<Self>::new(adev.as_ref())?;
+        let drm = drm::Registration::new_foreign_owned(drm, adev.as_ref(), data, 0)?;
 
        Ok(Self { drm: drm.into() })
    }
drivers/gpu/drm/tyr/driver.rs +2 -2
index ac265a60f5667..e73c56659ea75 100644
@@ -133,8 +133,8 @@ fn probe(
                gpu_info,
        });
 
-        let tdev = drm::UnregisteredDevice::<Self>::new(pdev.as_ref(), data)?;
-        let tdev = drm::driver::Registration::new_foreign_owned(tdev, pdev.as_ref(), 0)?;
+        let tdev = drm::UnregisteredDevice::<Self>::new(pdev.as_ref())?;
+        let tdev = drm::driver::Registration::new_foreign_owned(tdev, pdev.as_ref(), data, 0)?;
 
        let driver = TyrDriver {
            device: tdev.into(),
rust/kernel/drm/device.rs +8 -22
index f529bc7fc4032..0e81957cf8c28 100644
@@ -26,13 +26,15 @@
 };
 use core::{
    alloc::Layout,
+    cell::UnsafeCell,
    marker::PhantomData,
-    mem,
-    ops::Deref,
-    ptr::{
+    mem::{
        self,
-        NonNull, //
+        MaybeUninit, //
    },
+    ops::Deref,
+    ptr::NonNull,
+    sync::atomic::*,
 };
 
 #[cfg(CONFIG_DRM_LEGACY)]
@@ -141,7 +143,7 @@ impl DeviceContext for Uninit {}
 ///
 /// The device in `self.0` is guaranteed to be a newly created [`Device`] that has not yet been
 /// registered with userspace until this type is dropped.
-pub struct UnregisteredDevice<T: drm::Driver>(ARef<Device<T, Uninit>>, NotThreadSafe);
+pub struct UnregisteredDevice<T: drm::Driver>(pub(crate) ARef<Device<T, Uninit>>, NotThreadSafe);
 
 impl<T: drm::Driver> Deref for UnregisteredDevice<T> {
    type Target = Device<T, Uninit>;
@@ -188,7 +190,7 @@ impl<T: drm::Driver> UnregisteredDevice<T> {
    /// Create a new `UnregisteredDevice` for a `drm::Driver`.
    ///
    /// This can be used to create a [`Registration`](kernel::drm::Registration).
-    pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<Self> {
+    pub fn new(dev: &device::Device) -> Result<Self> {
        // `__drm_dev_alloc` uses `kmalloc()` to allocate memory, hence ensure a `kmalloc()`
        // compatible `Layout`.
        let layout = Kmalloc::aligned_layout(Layout::new::<Self>());
@@ -207,22 +209,6 @@ pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<S
        .cast();
        let raw_drm = NonNull::new(from_err_ptr(raw_drm)?).ok_or(ENOMEM)?;
 
-        // SAFETY: `raw_drm` is a valid pointer to `Self`.
-        let raw_data = unsafe { ptr::addr_of_mut!((*raw_drm.as_ptr()).data) };
-
-        // SAFETY:
-        // - `raw_data` is a valid pointer to uninitialized memory.
-        // - `raw_data` will not move until it is dropped.
-        unsafe { data.__pinned_init(raw_data) }.inspect_err(|_| {
-            // SAFETY: `raw_drm` is a valid pointer to `Self`, given that `__drm_dev_alloc` was
-            // successful.
-            let drm_dev = unsafe { Device::into_drm_device(raw_drm) };
-
-            // SAFETY: `__drm_dev_alloc()` was successful, hence `drm_dev` must be valid and the
-            // refcount must be non-zero.
-            unsafe { bindings::drm_dev_put(drm_dev) };
-        })?;
-
        // SAFETY: The reference count is one, and now we take ownership of that reference as a
        // `drm::Device`.
        // INVARIANT: We just created the device above, but have yet to call `drm_dev_register`.

rust/kernel/drm/device.rs pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<S · line 245

Quoted 7 lines
rust/kernel/drm/device.rs +3 -1
@@ -254,7 +240,15 @@ pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<S
 #[repr(C)]
 pub struct Device<T: drm::Driver, C: DeviceContext = Registered> {
    dev: Opaque<bindings::drm_device>,
-    data: T::Data,
+
+    /// Keeps track of whether we've initialized the device data yet.
+    pub(crate) data_is_init: AtomicBool,

Why don’t we make the data a member of the Registered context?

Quoted 64 lines
rust/kernel/drm/device.rs +27 -2
+
+    /// The Driver's private data.
+    ///
+    /// This must only be written to from [`drm::Registration::new`].
+    pub(crate) data: UnsafeCell<MaybeUninit<T::Data>>,
+
    _ctx: PhantomData<C>,
 }
 
@@ -305,6 +299,21 @@ extern "C" fn release(ptr: *mut bindings::drm_device) {
        // SAFETY: `ptr` is a valid pointer to a `struct drm_device` and embedded in `Self`.
        let this = unsafe { Self::from_drm_device(ptr) };
 
+        {
+            // SAFETY:
+            // - Since we are in release(), we are guaranteed that no one else has access to `this`.
+            // - We confirmed above that `this` is a valid pointer to an initialized `Self`.
+            let this = unsafe { &mut *this };
+            if this.data_is_init.load(Ordering::Relaxed) {
+                // SAFETY:
+                // - Since we are in release(), we are guaranteed that no one else has access to
+                //   `this`.
+                // - We checked that the data is initialized above.
+                // - We do not use `data` any point after calling this function.
+                unsafe { (&mut *this.data.get()).assume_init_drop() };
+            }
+        }
+
        // SAFETY:
        // - When `release` runs it is guaranteed that there is no further access to `this`.
        // - `this` is valid for dropping.
@@ -323,11 +332,15 @@ pub(crate) unsafe fn assume_ctx<NewCtx: DeviceContext>(&self) -> &Device<T, NewC
    }
 }
 
-impl<T: drm::Driver, C: DeviceContext> Deref for Device<T, C> {
+impl<T: drm::Driver> Deref for Device<T, Registered> {
    type Target = T::Data;
 
    fn deref(&self) -> &Self::Target {
-        &self.data
+        // SAFETY:
+        // - `data` is initialized before any `Device`s with the `Registered` context are available
+        //   to the user.
+        // - `data` is only written to once in `Registration::new()`, so this read will never race.
+        unsafe { (&*self.data.get()).assume_init_ref() }
    }
 }
 
rust/kernel/drm/driver.rs +2 -1
index da9f1bfef1f14..a16605b407159 100644
@@ -15,7 +15,8 @@
 };
 use core::{
    mem,
-    ptr::NonNull, //
+    ptr::NonNull,
+    sync::atomic::*, //
 };
 
 /// Driver use the GEM memory manager. This should be set for all modern drivers.

rust/kernel/drm/driver.rs pub trait Driver { · line 135

Quoted 9 lines
rust/kernel/drm/driver.rs +5 -1
@@ -127,7 +128,18 @@ pub trait Driver {
 pub struct Registration<T: Driver>(ARef<drm::Device<T>>);
 
 impl<T: Driver> Registration<T> {
-    fn new(drm: drm::UnregisteredDevice<T>, flags: usize) -> Result<Self> {
+    fn new(
+        drm: drm::UnregisteredDevice<T>,
+        data: impl PinInit<T::Data, Error>,
+        flags: usize,
+    ) -> Result<Self> {

IIUC this consumes UnregisteredDevice and returns

Registration<T: Driver>(ARef<drm::Device<T>>);

i.e.:

Registration<T: Driver>(ARef<drm::Device<T, C = Registered>>);

Again, the Registered typestate seems like the perfect place to store T::Data.

Quoted 30 lines
rust/kernel/drm/driver.rs +9 -1
+        // SAFETY:
+        // - `raw_data` is a valid pointer to uninitialized memory.
+        // - `raw_data` will not move until it is dropped.
+        unsafe { data.__pinned_init(drm.0.data.get().cast()) }?;
+
+        drm.data_is_init.store(true, Ordering::Relaxed);
+
        // SAFETY: `drm.as_raw()` is valid by the invariants of `drm::Device`.
        to_result(unsafe { bindings::drm_dev_register(drm.as_raw(), flags) })?;
 
@@ -150,6 +162,7 @@ fn new(drm: drm::UnregisteredDevice<T>, flags: usize) -> Result<Self> {
    pub fn new_foreign_owned<'a>(
        drm: drm::UnregisteredDevice<T>,
        dev: &'a device::Device<device::Bound>,
+        data: impl PinInit<T::Data, Error>,
        flags: usize,
    ) -> Result<&'a drm::Device<T>>
    where
@@ -160,7 +173,7 @@ pub fn new_foreign_owned<'a>(
            return Err(EINVAL);
        }
 
-        let reg = Registration::<T>::new(drm, flags)?;
+        let reg = Registration::<T>::new(drm, data, flags)?;
        let drm = NonNull::from(reg.device());
 
        devres::register(dev, reg, GFP_KERNEL)?;
Signature · 1 line
2.52.0
#6 lore raw

Re: [PATCH v3 2/3] rust/drm: Don't setup private driver data until registration

Quoted 4 lines · Daniel Almeida
Quoted 4 lines
(quoted diff) +0 -0
@@ -254,7 +240,15 @@ pub fn new(dev: &device::Device, data: impl

PinInit<T::Data, Error>) -> Result<S
#[repr(C)]
pub struct Device<T: drm::Driver, C: DeviceContext = Registered> {

Quoted 8 lines
Quoted 6 lines

     dev: Opaque<bindings::drm_device>,
-    data: T::Data,
+
+    /// Keeps track of whether we've initialized the device data yet.
+    pub(crate) data_is_init: AtomicBool,

Why don’t we make the data a member of the Registered context?

A couple of different reasons. For one: not having it embedded as part of Device would complicate trying to go from the device's private data using container_of! to the actual Device struct, which isn't great for workqueues.

The other much more important reason is that Registered isn't going to be the only typestate that has access to the driver's private data in the future. With KMS, nearly all of the modesetting callbacks for a driver can be invoked before userspace registration. E.g. consider a modesetting driver that needs to perform a modeset pre-registration so that the hardware is in a known good state before being exposed to userspace.

To clarify what this looks like: you'll recall that I made a diagram showing a high-level overview of the DRM initialization process for the documentation for DeviceContext. The second stage in that diagram, which I'm currently calling Init, is the context that we're going to need to eventually add a typestate for.

FWIW, this is more or less what the flow will look like with this new context. Indenting indicates calling down to a function from within the function above

* UnregisteredDevice::new(d: device::Device) -> UnregisteredDevice<T>
- // Creates Crtcs, Connectors, etc. KmsDriver::probe(d: &UninitializedKmsDevice)
* // The driver sets stuff up
* Registration::new_foreign_owned(
  dev: UnregisteredDevice,
  data: impl PinInit<T::Data>
):
- // Initialize data, so driver data is ready at this point
- KmsDriver::pre_registration_init(d: &Device<T, Init>)
- // Perform actual userspace registration

If it wasn't clear too: this means tyr won't really need to do anything when we add the new DeviceContext typestate :)

Quoted 9 lines
Quoted 9 lines

+
+    /// The Driver's private data.
+    ///
+    /// This must only be written to from [drm::Registration::new].
+    pub(crate) data: UnsafeCell<MaybeUninit<T::Data>>, +
     _ctx: PhantomData<C>,

author
#7 lore raw

PATCH v3 3/3 rust/drm/gem: Use DeviceContext with GEM objects

In reply to Lyude Paul

Now that we have the ability to represent the context in which a DRM device is in at compile-time, we can start carrying around this context with GEM object types in order to allow a driver to safely create GEM objects before a DRM device has registered with userspace.

---
 drivers/gpu/drm/nova/driver.rs |  2 +-
 drivers/gpu/drm/nova/gem.rs    | 11 +++---
 drivers/gpu/drm/tyr/driver.rs  |  2 +-
 drivers/gpu/drm/tyr/gem.rs     |  3 +-
 rust/kernel/drm/device.rs      | 14 ++++----
 rust/kernel/drm/driver.rs      |  2 +-
 rust/kernel/drm/gem/mod.rs     | 64 +++++++++++++++++++++++-----------
 7 files changed, 63 insertions(+), 35 deletions(-)
drivers/gpu/drm/nova/driver.rs +1 -1
index 8cea5f68c3b04..2c13261450406 100644
@@ -67,7 +67,7 @@ fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<S
 impl drm::Driver for NovaDriver {
     type Data = NovaData;
     type File = File;
-    type Object = gem::Object<NovaObject>;
+    type Object<Ctx: drm::DeviceContext> = gem::Object<NovaObject, Ctx>;
 
     const INFO: drm::DriverInfo = INFO;
 
drivers/gpu/drm/nova/gem.rs +7 -4
index 6ccfa5da57617..f6e98b9db58d8 100644
@@ -2,7 +2,7 @@
 
 use kernel::{
     drm,
-    drm::{gem, gem::BaseObject},
+    drm::{gem, gem::BaseObject, DeviceContext},
     page,
     prelude::*,
     sync::aref::ARef,
@@ -20,20 +20,23 @@ pub(crate) struct NovaObject {}
 impl gem::DriverObject for NovaObject {
     type Driver = NovaDriver;
 
-    fn new(_dev: &NovaDevice, _size: usize) -> impl PinInit<Self, Error> {
+    fn new<Ctx: DeviceContext>(_dev: &NovaDevice<Ctx>, _size: usize) -> impl PinInit<Self, Error> {
         try_pin_init!(NovaObject {})
     }
 }
 
 impl NovaObject {
     /// Create a new DRM GEM object.
-    pub(crate) fn new(dev: &NovaDevice, size: usize) -> Result<ARef<gem::Object<Self>>> {
+    pub(crate) fn new<Ctx: DeviceContext>(
+        dev: &NovaDevice<Ctx>,
+        size: usize,
+    ) -> Result<ARef<gem::Object<Self, Ctx>>> {
         if size == 0 {
             return Err(EINVAL);
         }
         let aligned_size = page::page_align(size).ok_or(EINVAL)?;
 
-        gem::Object::new(dev, aligned_size)
+        gem::Object::<Self, Ctx>::new(dev, aligned_size)
     }
 
     /// Look up a GEM object handle for a `File` and return an `ObjectRef` for it.
drivers/gpu/drm/tyr/driver.rs +1 -1
index e73c56659ea75..03e337d95521c 100644
@@ -177,7 +177,7 @@ fn drop(self: Pin<&mut Self>) {
 impl drm::Driver for TyrDriver {
     type Data = TyrData;
     type File = File;
-    type Object = drm::gem::Object<TyrObject>;
+    type Object<R: drm::DeviceContext> = drm::gem::Object<TyrObject, R>;
 
     const INFO: drm::DriverInfo = INFO;
 
drivers/gpu/drm/tyr/gem.rs +2 -1
index 1273bf89dbd5d..00804f8c14bd4 100644
@@ -3,6 +3,7 @@
 use crate::driver::TyrDevice;
 use crate::driver::TyrDriver;
 use kernel::drm::gem;
+use kernel::drm::DeviceContext;
 use kernel::prelude::*;
 
 /// GEM Object inner driver data
@@ -12,7 +13,7 @@ pub(crate) struct TyrObject {}
 impl gem::DriverObject for TyrObject {
     type Driver = TyrDriver;
 
-    fn new(_dev: &TyrDevice, _size: usize) -> impl PinInit<Self, Error> {
+    fn new<Ctx: DeviceContext>(_dev: &TyrDevice<Ctx>, _size: usize) -> impl PinInit<Self, Error> {
         try_pin_init!(TyrObject {})
     }
 }
rust/kernel/drm/device.rs +7 -7
index 0e81957cf8c28..4c03105e6a817 100644
@@ -163,13 +163,13 @@ impl<T: drm::Driver> UnregisteredDevice<T> {
         master_set: None,
         master_drop: None,
         debugfs_init: None,
-        gem_create_object: T::Object::ALLOC_OPS.gem_create_object,
-        prime_handle_to_fd: T::Object::ALLOC_OPS.prime_handle_to_fd,
-        prime_fd_to_handle: T::Object::ALLOC_OPS.prime_fd_to_handle,
-        gem_prime_import: T::Object::ALLOC_OPS.gem_prime_import,
-        gem_prime_import_sg_table: T::Object::ALLOC_OPS.gem_prime_import_sg_table,
-        dumb_create: T::Object::ALLOC_OPS.dumb_create,
-        dumb_map_offset: T::Object::ALLOC_OPS.dumb_map_offset,
+        gem_create_object: T::Object::<Uninit>::ALLOC_OPS.gem_create_object,
+        prime_handle_to_fd: T::Object::<Uninit>::ALLOC_OPS.prime_handle_to_fd,
+        prime_fd_to_handle: T::Object::<Uninit>::ALLOC_OPS.prime_fd_to_handle,
+        gem_prime_import: T::Object::<Uninit>::ALLOC_OPS.gem_prime_import,
+        gem_prime_import_sg_table: T::Object::<Uninit>::ALLOC_OPS.gem_prime_import_sg_table,
+        dumb_create: T::Object::<Uninit>::ALLOC_OPS.dumb_create,
+        dumb_map_offset: T::Object::<Uninit>::ALLOC_OPS.dumb_map_offset,
         show_fdinfo: None,
         fbdev_probe: None,
 
rust/kernel/drm/driver.rs +1 -1
index a16605b407159..94ebaf19ac069 100644
@@ -110,7 +110,7 @@ pub trait Driver {
     type Data: Sync + Send;
 
     /// The type used to manage memory for this driver.
-    type Object: AllocImpl;
+    type Object<Ctx: drm::DeviceContext>: AllocImpl;
 
     /// The type used to represent a DRM File (client)
     type File: drm::file::DriverFile;
rust/kernel/drm/gem/mod.rs +44 -20

188 lines not on this page · raw message

Signature · 1 line
2.52.0
maintainer
#8 lore raw

Re: [PATCH v3 3/3] rust/drm/gem: Use DeviceContext with GEM objects

Hi Lyude,

Quoted 117 lines · Lyude Paul

Now that we have the ability to represent the context in which a DRM device is in at compile-time, we can start carrying around this context with GEM object types in order to allow a driver to safely create GEM objects before a DRM device has registered with userspace.

---

drivers/gpu/drm/nova/driver.rs |  2 +-
drivers/gpu/drm/nova/gem.rs    | 11 +++---
drivers/gpu/drm/tyr/driver.rs  |  2 +-
drivers/gpu/drm/tyr/gem.rs     |  3 +-
rust/kernel/drm/device.rs      | 14 ++++----
rust/kernel/drm/driver.rs      |  2 +-
rust/kernel/drm/gem/mod.rs     | 64 +++++++++++++++++++++++-----------
7 files changed, 63 insertions(+), 35 deletions(-)
drivers/gpu/drm/nova/driver.rs +1 -1
index 8cea5f68c3b04..2c13261450406 100644
@@ -67,7 +67,7 @@ fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<S
 impl drm::Driver for NovaDriver {
    type Data = NovaData;
    type File = File;
-    type Object = gem::Object<NovaObject>;
+    type Object<Ctx: drm::DeviceContext> = gem::Object<NovaObject, Ctx>;
 
    const INFO: drm::DriverInfo = INFO;
 
drivers/gpu/drm/nova/gem.rs +7 -4
index 6ccfa5da57617..f6e98b9db58d8 100644
@@ -2,7 +2,7 @@
 
 use kernel::{
    drm,
-    drm::{gem, gem::BaseObject},
+    drm::{gem, gem::BaseObject, DeviceContext},
    page,
    prelude::*,
    sync::aref::ARef,
@@ -20,20 +20,23 @@ pub(crate) struct NovaObject {}
 impl gem::DriverObject for NovaObject {
    type Driver = NovaDriver;
 
-    fn new(_dev: &NovaDevice, _size: usize) -> impl PinInit<Self, Error> {
+    fn new<Ctx: DeviceContext>(_dev: &NovaDevice<Ctx>, _size: usize) -> impl PinInit<Self, Error> {
        try_pin_init!(NovaObject {})
    }
 }
 
 impl NovaObject {
    /// Create a new DRM GEM object.
-    pub(crate) fn new(dev: &NovaDevice, size: usize) -> Result<ARef<gem::Object<Self>>> {
+    pub(crate) fn new<Ctx: DeviceContext>(
+        dev: &NovaDevice<Ctx>,
+        size: usize,
+    ) -> Result<ARef<gem::Object<Self, Ctx>>> {
        if size == 0 {
            return Err(EINVAL);
        }
        let aligned_size = page::page_align(size).ok_or(EINVAL)?;
 
-        gem::Object::new(dev, aligned_size)
+        gem::Object::<Self, Ctx>::new(dev, aligned_size)
    }
 
    /// Look up a GEM object handle for a `File` and return an `ObjectRef` for it.
drivers/gpu/drm/tyr/driver.rs +1 -1
index e73c56659ea75..03e337d95521c 100644
@@ -177,7 +177,7 @@ fn drop(self: Pin<&mut Self>) {
 impl drm::Driver for TyrDriver {
    type Data = TyrData;
    type File = File;
-    type Object = drm::gem::Object<TyrObject>;
+    type Object<R: drm::DeviceContext> = drm::gem::Object<TyrObject, R>;
 
    const INFO: drm::DriverInfo = INFO;
 
drivers/gpu/drm/tyr/gem.rs +2 -1
index 1273bf89dbd5d..00804f8c14bd4 100644
@@ -3,6 +3,7 @@
 use crate::driver::TyrDevice;
 use crate::driver::TyrDriver;
 use kernel::drm::gem;
+use kernel::drm::DeviceContext;
 use kernel::prelude::*;
 
 /// GEM Object inner driver data
@@ -12,7 +13,7 @@ pub(crate) struct TyrObject {}
 impl gem::DriverObject for TyrObject {
    type Driver = TyrDriver;
 
-    fn new(_dev: &TyrDevice, _size: usize) -> impl PinInit<Self, Error> {
+    fn new<Ctx: DeviceContext>(_dev: &TyrDevice<Ctx>, _size: usize) -> impl PinInit<Self, Error> {
        try_pin_init!(TyrObject {})
    }
 }
rust/kernel/drm/device.rs +0 -4
index 0e81957cf8c28..4c03105e6a817 100644
@@ -163,13 +163,13 @@ impl<T: drm::Driver> UnregisteredDevice<T> {
        master_set: None,
        master_drop: None,
        debugfs_init: None,
-        gem_create_object: T::Object::ALLOC_OPS.gem_create_object,
-        prime_handle_to_fd: T::Object::ALLOC_OPS.prime_handle_to_fd,
-        prime_fd_to_handle: T::Object::ALLOC_OPS.prime_fd_to_handle,
-        gem_prime_import: T::Object::ALLOC_OPS.gem_prime_import,

rust/kernel/drm/device.rs impl<T: drm::Driver> UnregisteredDevice<T> { · line 172

Quoted 10 lines
rust/kernel/drm/device.rs +7 -3
-        gem_prime_import_sg_table: T::Object::ALLOC_OPS.gem_prime_import_sg_table,
-        dumb_create: T::Object::ALLOC_OPS.dumb_create,
-        dumb_map_offset: T::Object::ALLOC_OPS.dumb_map_offset,
+        gem_create_object: T::Object::<Uninit>::ALLOC_OPS.gem_create_object,
+        prime_handle_to_fd: T::Object::<Uninit>::ALLOC_OPS.prime_handle_to_fd,
+        prime_fd_to_handle: T::Object::<Uninit>::ALLOC_OPS.prime_fd_to_handle,
+        gem_prime_import: T::Object::<Uninit>::ALLOC_OPS.gem_prime_import,
+        gem_prime_import_sg_table: T::Object::<Uninit>::ALLOC_OPS.gem_prime_import_sg_table,
+        dumb_create: T::Object::<Uninit>::ALLOC_OPS.dumb_create,
+        dumb_map_offset: T::Object::<Uninit>::ALLOC_OPS.dumb_map_offset,

Why are we specifically going with Uninit here?

Quoted 40 lines
rust/kernel/drm/device.rs +0 -0
        show_fdinfo: None,
        fbdev_probe: None,
 
rust/kernel/drm/driver.rs +1 -1
index a16605b407159..94ebaf19ac069 100644
@@ -110,7 +110,7 @@ pub trait Driver {
    type Data: Sync + Send;
 
    /// The type used to manage memory for this driver.
-    type Object: AllocImpl;
+    type Object<Ctx: drm::DeviceContext>: AllocImpl;
 
    /// The type used to represent a DRM File (client)
    type File: drm::file::DriverFile;
rust/kernel/drm/gem/mod.rs +5 -0
index b4199945db378..3af9f52f8eda4 100644
@@ -8,6 +8,10 @@
    bindings,
    drm::{
        self,
+        device::{
+            DeviceContext,
+            Registered, //
+        },
        driver::{
            AllocImpl,
            AllocOps, //
@@ -22,6 +26,7 @@
    types::Opaque,
 };
 use core::{
+    marker::PhantomData,
    ops::Deref,
    ptr::NonNull, //
 };

rust/kernel/drm/gem/mod.rs line 45

Quoted 8 lines
rust/kernel/drm/gem/mod.rs +5 -0
@@ -33,21 +38,30 @@
 /// [`DriverFile`]: drm::file::DriverFile
 pub type DriverFile<T> = drm::File<<<T as DriverObject>::Driver as drm::Driver>::File>;
 
+/// A type alias for retrieving the current [`AllocImpl`] for a given [`DriverObject`].
+///
+/// [`Driver`]: drm::Driver
+pub type DriverAllocImpl<T, Ctx = Registered> =
+    <<T as DriverObject>::Driver as drm::Driver>::Object<Ctx>;

Should this be a follow up patch instead?

Quoted 179 lines
rust/kernel/drm/gem/mod.rs +34 -20
+
 /// GEM object functions, which must be implemented by drivers.
 pub trait DriverObject: Sync + Send + Sized {
    /// Parent `Driver` for this object.
    type Driver: drm::Driver;
 
    /// Create a new driver data object for a GEM object of a given size.
-    fn new(dev: &drm::Device<Self::Driver>, size: usize) -> impl PinInit<Self, Error>;
+    fn new<Ctx: DeviceContext>(
+        dev: &drm::Device<Self::Driver, Ctx>,
+        size: usize,
+    ) -> impl PinInit<Self, Error>;
 
    /// Open a new handle to an existing object, associated with a File.
-    fn open(_obj: &<Self::Driver as drm::Driver>::Object, _file: &DriverFile<Self>) -> Result {
+    fn open(_obj: &DriverAllocImpl<Self>, _file: &DriverFile<Self>) -> Result {
        Ok(())
    }
 
    /// Close a handle to an existing object, associated with a File.
-    fn close(_obj: &<Self::Driver as drm::Driver>::Object, _file: &DriverFile<Self>) {}
+    fn close(_obj: &DriverAllocImpl<Self>, _file: &DriverFile<Self>) {}
 }
 
 /// Trait that represents a GEM object subtype
@@ -73,9 +87,12 @@ extern "C" fn open_callback<T: DriverObject>(
    // SAFETY: `open_callback` is only ever called with a valid pointer to a `struct drm_file`.
    let file = unsafe { DriverFile::<T>::from_raw(raw_file) };
 
-    // SAFETY: `open_callback` is specified in the AllocOps structure for `DriverObject<T>`,
-    // ensuring that `raw_obj` is contained within a `DriverObject<T>`
-    let obj = unsafe { <<T::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj) };
+    // SAFETY:
+    // * `open_callback` is specified in the AllocOps structure for `DriverObject`, ensuring that
+    //   `raw_obj` is contained within a `DriverAllocImpl<T>`
+    // * It is only possible for `open_callback` to be called after device registration, ensuring
+    //   that the object's device is in the `Registered` state.
+    let obj: &DriverAllocImpl<T> = unsafe { IntoGEMObject::from_raw(raw_obj) };
 
    match T::open(obj, file) {
        Err(e) => e.to_errno(),
@@ -92,12 +109,12 @@ extern "C" fn close_callback<T: DriverObject>(
 
    // SAFETY: `close_callback` is specified in the AllocOps structure for `Object<T>`, ensuring
    // that `raw_obj` is indeed contained within a `Object<T>`.
-    let obj = unsafe { <<T::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj) };
+    let obj: &DriverAllocImpl<T> = unsafe { IntoGEMObject::from_raw(raw_obj) };
 
    T::close(obj, file);
 }
 
-impl<T: DriverObject> IntoGEMObject for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> IntoGEMObject for Object<T, Ctx> {
    fn as_raw(&self) -> *mut bindings::drm_gem_object {
        self.obj.get()
    }
@@ -105,7 +122,7 @@ fn as_raw(&self) -> *mut bindings::drm_gem_object {
    unsafe fn from_raw<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self {
        // SAFETY: `obj` is guaranteed to be in an `Object<T>` via the safety contract of this
        // function
-        unsafe { &*crate::container_of!(Opaque::cast_from(self_ptr), Object<T>, obj) }
+        unsafe { &*crate::container_of!(Opaque::cast_from(self_ptr), Object<T, Ctx>, obj) }
    }
 }
 
@@ -122,7 +139,7 @@ fn size(&self) -> usize {
    fn create_handle<D, F>(&self, file: &drm::File<F>) -> Result<u32>
    where
        Self: AllocImpl<Driver = D>,
-        D: drm::Driver<Object = Self, File = F>,
+        D: drm::Driver<Object<Registered> = Self, File = F>,
        F: drm::file::DriverFile<Driver = D>,
    {
        let mut handle: u32 = 0;
@@ -137,7 +154,7 @@ fn create_handle<D, F>(&self, file: &drm::File<F>) -> Result<u32>
    fn lookup_handle<D, F>(file: &drm::File<F>, handle: u32) -> Result<ARef<Self>>
    where
        Self: AllocImpl<Driver = D>,
-        D: drm::Driver<Object = Self, File = F>,
+        D: drm::Driver<Object<Registered> = Self, File = F>,
        F: drm::file::DriverFile<Driver = D>,
    {
        // SAFETY: The arguments are all valid per the type invariants.
@@ -177,16 +194,18 @@ impl<T: IntoGEMObject> BaseObject for T {}
 ///
 /// # Invariants
 ///
-/// - `self.obj` is a valid instance of a `struct drm_gem_object`.
+/// * `self.obj` is a valid instance of a `struct drm_gem_object`.
+/// * Any type invariants of `Ctx` apply to the parent DRM device for this GEM object.
 #[repr(C)]
 #[pin_data]
-pub struct Object<T: DriverObject + Send + Sync> {
+pub struct Object<T: DriverObject + Send + Sync, Ctx: DeviceContext = Registered> {
    obj: Opaque<bindings::drm_gem_object>,
    #[pin]
    data: T,
+    _ctx: PhantomData<Ctx>,
 }
 
-impl<T: DriverObject> Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> Object<T, Ctx> {
    const OBJECT_FUNCS: bindings::drm_gem_object_funcs = bindings::drm_gem_object_funcs {
        free: Some(Self::free_callback),
        open: Some(open_callback::<T>),
@@ -206,11 +225,12 @@ impl<T: DriverObject> Object<T> {
    };
 
    /// Create a new GEM object.
-    pub fn new(dev: &drm::Device<T::Driver>, size: usize) -> Result<ARef<Self>> {
+    pub fn new(dev: &drm::Device<T::Driver, Ctx>, size: usize) -> Result<ARef<Self>> {
        let obj: Pin<KBox<Self>> = KBox::pin_init(
            try_pin_init!(Self {
                obj: Opaque::new(bindings::drm_gem_object::default()),
                data <- T::new(dev, size),
+                _ctx: PhantomData,
            }),
            GFP_KERNEL,
        )?;
@@ -219,6 +239,8 @@ pub fn new(dev: &drm::Device<T::Driver>, size: usize) -> Result<ARef<Self>> {
        unsafe { (*obj.as_raw()).funcs = &Self::OBJECT_FUNCS };
 
        // SAFETY: The arguments are all valid per the type invariants.
+        // INVARIANT: We use `dev` for creating the GEM object, which is known to be in state `Ctx` -
+        // ensuring that the GEM object's pointer to the DRM device is always in the same state.
        to_result(unsafe { bindings::drm_gem_object_init(dev.as_raw(), obj.obj.get(), size) })?;
 
        // SAFETY: We will never move out of `Self` as `ARef<Self>` is always treated as pinned.
@@ -232,13 +254,15 @@ pub fn new(dev: &drm::Device<T::Driver>, size: usize) -> Result<ARef<Self>> {
    }
 
    /// Returns the `Device` that owns this GEM object.
-    pub fn dev(&self) -> &drm::Device<T::Driver> {
+    pub fn dev(&self) -> &drm::Device<T::Driver, Ctx> {
        // SAFETY:
        // - `struct drm_gem_object.dev` is initialized and valid for as long as the GEM
        //   object lives.
        // - The device we used for creating the gem object is passed as &drm::Device<T::Driver> to
        //   Object::<T>::new(), so we know that `T::Driver` is the right generic parameter to use
        //   here.
+        // - Any type invariants of `Ctx` are upheld by using the same `Ctx` for the `Device` we
+        //   return.
        unsafe { drm::Device::from_raw((*self.as_raw()).dev) }
    }
 
@@ -264,7 +288,7 @@ extern "C" fn free_callback(obj: *mut bindings::drm_gem_object) {
 }
 
 // SAFETY: Instances of `Object<T>` are always reference-counted.
-unsafe impl<T: DriverObject> crate::sync::aref::AlwaysRefCounted for Object<T> {
+unsafe impl<T: DriverObject, Ctx: DeviceContext> AlwaysRefCounted for Object<T, Ctx> {
    fn inc_ref(&self) {
        // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
        unsafe { bindings::drm_gem_object_get(self.as_raw()) };
@@ -279,9 +303,9 @@ unsafe fn dec_ref(obj: NonNull<Self>) {
    }
 }
 
-impl<T: DriverObject> super::private::Sealed for Object<T> {}
+impl<T: DriverObject, Ctx: DeviceContext> super::private::Sealed for Object<T, Ctx> {}
 
-impl<T: DriverObject> Deref for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> Deref for Object<T, Ctx> {
    type Target = T;
 
    fn deref(&self) -> &Self::Target {
@@ -289,7 +313,7 @@ fn deref(&self) -> &Self::Target {
    }
 }
 
-impl<T: DriverObject> AllocImpl for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> AllocImpl for Object<T, Ctx> {
    type Driver = T::Driver;
 
    const ALLOC_OPS: AllocOps = AllocOps {
Signature · 1 line
2.52.0
#9 lore raw

Re: [PATCH v3 3/3] rust/drm/gem: Use DeviceContext with GEM objects

Quoted 27 lines · Daniel Almeida
Quoted 27 lines

    }
}

rust/kernel/drm/device.rs +1 -7
index 0e81957cf8c28..4c03105e6a817 100644
@@ -163,13 +163,13 @@ impl<T: drm::Driver> UnregisteredDevice<T> {
         master_set: None,
         master_drop: None,
         debugfs_init: None,
-        gem_create_object: T::Object::ALLOC_OPS.gem_create_object,
-        prime_handle_to_fd:
 T::Object::ALLOC_OPS.prime_handle_to_fd,
-        prime_fd_to_handle:
 T::Object::ALLOC_OPS.prime_fd_to_handle,
-        gem_prime_import: T::Object::ALLOC_OPS.gem_prime_import,
-        gem_prime_import_sg_table:
 T::Object::ALLOC_OPS.gem_prime_import_sg_table,
-        dumb_create: T::Object::ALLOC_OPS.dumb_create,
-        dumb_map_offset: T::Object::ALLOC_OPS.dumb_map_offset,
+        gem_create_object:

T::Object::<Uninit>::ALLOC_OPS.gem_create_object, +        prime_handle_to_fd:
T::Object::<Uninit>::ALLOC_OPS.prime_handle_to_fd, +        prime_fd_to_handle:
T::Object::<Uninit>::ALLOC_OPS.prime_fd_to_handle, +        gem_prime_import:

Quoted 8 lines
Quoted 6 lines

T::Object::<Uninit>::ALLOC_OPS.gem_prime_import,
+        gem_prime_import_sg_table:
T::Object::<Uninit>::ALLOC_OPS.gem_prime_import_sg_table, +        dumb_create: T::Object::<Uninit>::ALLOC_OPS.dumb_create, +        dumb_map_offset:
T::Object::<Uninit>::ALLOC_OPS.dumb_map_offset,

Why are we specifically going with Uninit here?

I think this was just an assumption that similarly to KMS callbacks, gem callbacks can also happen before registration. except, that some of these clearly can't happen before registration - whoops.

But this being said - it doesn't really make any difference what the DeviceContext is here. The DeviceContext generic here isn't actually used in any way, nor is it used by the C callback, it's just here because we have to specify it on the associated type.

Quoted 289 lines
Quoted 48 lines

        show_fdinfo: None,
        fbdev_probe: None,

rust/kernel/drm/driver.rs +1 -1
index a16605b407159..94ebaf19ac069 100644
@@ -110,7 +110,7 @@ pub trait Driver {
     type Data: Sync + Send;
 
     /// The type used to manage memory for this driver.
-    type Object: AllocImpl;
+    type Object<Ctx: drm::DeviceContext>: AllocImpl;
 
     /// The type used to represent a DRM File (client)
     type File: drm::file::DriverFile;
rust/kernel/drm/gem/mod.rs +4 -0
index b4199945db378..3af9f52f8eda4 100644
@@ -8,6 +8,10 @@
     bindings,
     drm::{
         self,
+        device::{
+            DeviceContext,
+            Registered, //
+        },
         driver::{
             AllocImpl,

            AllocOps, //

rust/kernel/drm/gem/mod.rs +1 -0
@@ -22,6 +26,7 @@
     types::Opaque,
 };
 use core::{
+    marker::PhantomData,
     ops::Deref,

    ptr::NonNull, //
};

rust/kernel/drm/gem/mod.rs +0 -0
@@ -33,21 +38,30 @@
 /// [`DriverFile`]: drm::file::DriverFile

pub type DriverFile<T> = drm::File<<<T as DriverObject>::Driver as drm::Driver>::File>;

+/// A type alias for retrieving the current [AllocImpl] for a given [DriverObject].

rust/kernel/drm/gem/mod.rs line 45

Quoted 4 lines
rust/kernel/drm/gem/mod.rs +4 -0
+///
+/// [`Driver`]: drm::Driver
+pub type DriverAllocImpl<T, Ctx = Registered> =
+    <<T as DriverObject>::Driver as drm::Driver>::Object<Ctx>;

Should this be a follow up patch instead?

Quoted 234 lines

+
/// GEM object functions, which must be implemented by drivers. pub trait DriverObject: Sync + Send + Sized {
    /// Parent Driver for this object.
    type Driver: drm::Driver;

    /// Create a new driver data object for a GEM object of a given size.
-    fn new(dev: &drm::Device<Self::Driver>, size: usize) -> impl PinInit<Self, Error>;
+    fn new<Ctx: DeviceContext>(
+        dev: &drm::Device<Self::Driver, Ctx>,
+        size: usize,
+    ) -> impl PinInit<Self, Error>;

    /// Open a new handle to an existing object, associated with a File.
-    fn open(_obj: &<Self::Driver as drm::Driver>::Object, _file:
&DriverFile<Self>) -> Result {
+    fn open(_obj: &DriverAllocImpl<Self>, _file:
&DriverFile<Self>) -> Result {
        Ok(())
    }

    /// Close a handle to an existing object, associated with a File.
-    fn close(_obj: &<Self::Driver as drm::Driver>::Object, _file:
&DriverFile<Self>) {}
+    fn close(_obj: &DriverAllocImpl<Self>, _file:
&DriverFile<Self>) {}
}

/// Trait that represents a GEM object subtype

rust/kernel/drm/gem/mod.rs +0 -0
@@ -73,9 +87,12 @@ extern "C" fn open_callback<T: DriverObject>(
     // SAFETY: `open_callback` is only ever called with a valid

pointer to a struct drm_file.
    let file = unsafe { DriverFile::<T>::from_raw(raw_file) };

-    // SAFETY: open_callback is specified in the AllocOps structure for DriverObject<T>,
-    // ensuring that raw_obj is contained within a DriverObject<T>
-    let obj = unsafe { <<T::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj) };
+    // SAFETY:
+    // * open_callback is specified in the AllocOps structure for DriverObject, ensuring that
+    //   raw_obj is contained within a DriverAllocImpl<T> +    // * It is only possible for open_callback to be called after device registration, ensuring
+    //   that the object's device is in the Registered state. +    let obj: &DriverAllocImpl<T> = unsafe { IntoGEMObject::from_raw(raw_obj) };

    match T::open(obj, file) {
        Err(e) => e.to_errno(),

rust/kernel/drm/gem/mod.rs +0 -0
@@ -92,12 +109,12 @@ extern "C" fn close_callback<T: DriverObject>(
 
     // SAFETY: `close_callback` is specified in the AllocOps

structure for Object<T>, ensuring
    // that raw_obj is indeed contained within a Object<T>. -    let obj = unsafe { <<T::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj) };
+    let obj: &DriverAllocImpl<T> = unsafe { IntoGEMObject::from_raw(raw_obj) };

    T::close(obj, file);
}

rust/kernel/drm/gem/mod.rs +1 -1
-impl<T: DriverObject> IntoGEMObject for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> IntoGEMObject for

Object<T, Ctx> {
    fn as_raw(&self) -> *mut bindings::drm_gem_object { self.obj.get()
    }

rust/kernel/drm/gem/mod.rs +0 -1
@@ -105,7 +122,7 @@ fn as_raw(&self) -> *mut
 bindings::drm_gem_object {
     unsafe fn from_raw<'a>(self_ptr: *mut bindings::drm_gem_object)
-> &'a Self {
         // SAFETY: `obj` is guaranteed to be in an `Object<T>` via

the safety contract of this
        // function
-        unsafe { &*crate::container_of!(Opaque::cast_from(self_ptr), Object<T>, obj) }
+        unsafe { &*crate::container_of!(Opaque::cast_from(self_ptr), Object<T, Ctx>, obj) }
    }
}

rust/kernel/drm/gem/mod.rs +0 -0
@@ -122,7 +139,7 @@ fn size(&self) -> usize {

    fn create_handle<D, F>(&self, file: &drm::File<F>) -> Result<u32>
    where
        Self: AllocImpl<Driver = D>,
-        D: drm::Driver<Object = Self, File = F>,
+        D: drm::Driver<Object<Registered> = Self, File = F>,
        F: drm::file::DriverFile<Driver = D>,
    {
        let mut handle: u32 = 0;

rust/kernel/drm/gem/mod.rs +0 -0
@@ -137,7 +154,7 @@ fn create_handle<D, F>(&self, file:

&drm::File<F>) -> Result<u32>
    fn lookup_handle<D, F>(file: &drm::File<F>, handle: u32) -> Result<ARef<Self>>
    where
        Self: AllocImpl<Driver = D>,
-        D: drm::Driver<Object = Self, File = F>,
+        D: drm::Driver<Object<Registered> = Self, File = F>,
        F: drm::file::DriverFile<Driver = D>,
    {
        // SAFETY: The arguments are all valid per the type invariants.

rust/kernel/drm/gem/mod.rs +2 -1
@@ -177,16 +194,18 @@ impl<T: IntoGEMObject> BaseObject for T {}
 ///
 /// # Invariants
 ///
-/// - `self.obj` is a valid instance of a `struct drm_gem_object`.
+/// * `self.obj` is a valid instance of a `struct drm_gem_object`.
+/// * Any type invariants of `Ctx` apply to the parent DRM device

for this GEM object.
#[repr(C)]
#[pin_data]

rust/kernel/drm/gem/mod.rs +1 -1
-pub struct Object<T: DriverObject + Send + Sync> {
+pub struct Object<T: DriverObject + Send + Sync, Ctx:

DeviceContext = Registered> {
    obj: Opaque<bindings::drm_gem_object>,
    #[pin]
    data: T,
+    _ctx: PhantomData<Ctx>,
}

rust/kernel/drm/gem/mod.rs +1 -1
-impl<T: DriverObject> Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> Object<T, Ctx> {

    const OBJECT_FUNCS: bindings::drm_gem_object_funcs = bindings::drm_gem_object_funcs {
        free: Some(Self::free_callback),
        open: Some(open_callback::<T>),

rust/kernel/drm/gem/mod.rs +1 -1
@@ -206,11 +225,12 @@ impl<T: DriverObject> Object<T> {
     };
 
     /// Create a new GEM object.
-    pub fn new(dev: &drm::Device<T::Driver>, size: usize) ->
 Result<ARef<Self>> {
+    pub fn new(dev: &drm::Device<T::Driver, Ctx>, size: usize) ->
 Result<ARef<Self>> {

        let obj: Pin<KBox<Self>> = KBox::pin_init( try_pin_init!(Self {
                obj:
Opaque::new(bindings::drm_gem_object::default()), data <- T::new(dev, size), +                _ctx: PhantomData,
            }),
            GFP_KERNEL,
        )?;

rust/kernel/drm/gem/mod.rs +0 -0
@@ -219,6 +239,8 @@ pub fn new(dev: &drm::Device<T::Driver>, size:
 usize) -> Result<ARef<Self>> {
         unsafe { (*obj.as_raw()).funcs = &Self::OBJECT_FUNCS };
 
         // SAFETY: The arguments are all valid per the type

invariants.
+        // INVARIANT: We use dev for creating the GEM object, which is known to be in state Ctx -
+        // ensuring that the GEM object's pointer to the DRM device is always in the same state.
        to_result(unsafe { bindings::drm_gem_object_init(dev.as_raw(), obj.obj.get(), size) })?;

        // SAFETY: We will never move out of Self as ARef<Self> is always treated as pinned.

rust/kernel/drm/gem/mod.rs +1 -1
@@ -232,13 +254,15 @@ pub fn new(dev: &drm::Device<T::Driver>,
 size: usize) -> Result<ARef<Self>> {
     }
 
     /// Returns the `Device` that owns this GEM object.
-    pub fn dev(&self) -> &drm::Device<T::Driver> {
+    pub fn dev(&self) -> &drm::Device<T::Driver, Ctx> {
         // SAFETY:
         // - `struct drm_gem_object.dev` is initialized and valid

for as long as the GEM
        //   object lives.
        // - The device we used for creating the gem object is passed as &drm::Device<T::Driver> to
        //   Object::<T>::new(), so we know that T::Driver is the right generic parameter to use
        //   here.
+        // - Any type invariants of Ctx are upheld by using the same Ctx for the Device we
+        //   return.
        unsafe { drm::Device::from_raw((*self.as_raw()).dev) } }

rust/kernel/drm/gem/mod.rs +1 -1
@@ -264,7 +288,7 @@ extern "C" fn free_callback(obj: *mut
 bindings::drm_gem_object) {
 }
 
 // SAFETY: Instances of `Object<T>` are always reference-counted.
-unsafe impl<T: DriverObject> crate::sync::aref::AlwaysRefCounted
 for Object<T> {
+unsafe impl<T: DriverObject, Ctx: DeviceContext> AlwaysRefCounted
 for Object<T, Ctx> {

    fn inc_ref(&self) {
        // SAFETY: The existence of a shared reference guarantees that the refcount is non-zero.
        unsafe { bindings::drm_gem_object_get(self.as_raw()) };

rust/kernel/drm/gem/mod.rs +2 -2
@@ -279,9 +303,9 @@ unsafe fn dec_ref(obj: NonNull<Self>) {
     }
 }
 
-impl<T: DriverObject> super::private::Sealed for Object<T> {}
+impl<T: DriverObject, Ctx: DeviceContext> super::private::Sealed
 for Object<T, Ctx> {}
 
-impl<T: DriverObject> Deref for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> Deref for Object<T, Ctx>
 {
     type Target = T;

    fn deref(&self) -> &Self::Target {

rust/kernel/drm/gem/mod.rs +1 -1
@@ -289,7 +313,7 @@ fn deref(&self) -> &Self::Target {
     }
 }
 
-impl<T: DriverObject> AllocImpl for Object<T> {
+impl<T: DriverObject, Ctx: DeviceContext> AllocImpl for Object<T,
 Ctx> {
     type Driver = T::Driver;
 

    const ALLOC_OPS: AllocOps = AllocOps {

Signature · 1 line
2.52.0