Introduce DeviceContext
Subsystems (5)
v2 cover Introduce DeviceContext
Previous version of this patch series:
https://lists.freedesktop.org/archives/dri-devel/2025-November/535387.html
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.
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 | 231 +++++++++++++++++++++++++-------- rust/kernel/drm/driver.rs | 56 ++++++-- rust/kernel/drm/gem/mod.rs | 66 ++++++---- rust/kernel/drm/mod.rs | 4 + 8 files changed, 292 insertions(+), 101 deletions(-)
base-commit: 086714bbb96f63785da251e1f8d1ce3e716a6e42
Signature · 1 line
2.52.0
PATCH v2 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
drivers/gpu/drm/nova/driver.rs | 8 +- drivers/gpu/drm/tyr/driver.rs | 10 +- rust/kernel/drm/device.rs | 172 +++++++++++++++++++++++++++------ rust/kernel/drm/driver.rs | 35 +++++-- rust/kernel/drm/mod.rs | 4 + 5 files changed, 182 insertions(+), 47 deletions(-)
drivers/gpu/drm/nova/driver.rs +4 -4
@@ -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
@@ -29,7 +29,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 {
@@ -139,10 +139,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 +142 -30
262 lines not on this page · raw message
rust/kernel/drm/driver.rs +26 -9
@@ -10,6 +10,7 @@ prelude::*, sync::aref::ARef, }; +use core::{mem, ptr::NonNull };use macros::vtable;/// Driver use the GEM memory manager. This should be set for all modern drivers.
@@ -122,30 +123,46 @@ pub trait Driver {impl <T :Driver >Registration <T > {/// Creates a new [`Registration`] and registers it. -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)) } -/// Same as [`Registration::new`}, but transfers ownership of the [`Registration`] to +/// Same as [`Registration::new`], but transfers ownership of the [`Registration`] 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
@@ -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
Danilo Krummrich
maintainerRe: [PATCH v2 1/3] rust/drm: Introduce DeviceContext
rust/kernel/drm/device.rs line 10
Quoted 10 lines · Lyude Paul
rust/kernel/drm/device.rs +1
-1@@ -7,14 +7,20 @@use crate ::{ alloc::allocator::Kmalloc , bindings, device, drm, - drm::driver::AllocImpl , + drm::{driver::AllocImpl , private::Sealed },
Please use kernel vertical style [1] when making changes.
(If you want you can also add an additional patch converting the whole DRM module first for consistency.)
[1] https://docs.kernel.org/rust/coding-guidelines.html#imports
Quoted 30 lines
rust/kernel/drm/device.rs +15
-3error::from_err_ptr, error::Result, prelude::*, sync::aref::{ARef, AlwaysRefCounted}, - types::Opaque, + types::{NotThreadSafe, Opaque}, +}; +use core::{ + alloc::Layout , + marker::PhantomData , + mem::{self}, + ops::Deref , + ptr::{self,NonNull }, }; -use core::{alloc::Layout , mem, ops::Deref , ptr, ptr::NonNull };#[cfg( CONFIG_DRM_LEGACY )] macro_rules! drm_legacy_fields {@@ -47,26 +53,88 @@ macro_rules! drm_legacy_fields { } } -/// A typed DRM device with a specific `drm::Driver` implementation. +macro_rules! drm_dev_ctx { + ( + $( #[$attrs:meta] )* + $name:ident + ) => { + $(#[$attrs] )* +pub struct $name;
rust/kernel/drm/device.rs macro_rules! drm_legacy_fields { · line 72
Quoted 10 lines
rust/kernel/drm/device.rs +10
-0+ +impl DeviceContext for $name {} +impl Sealed for $name {} + +// SAFETY: All registration states are free of side-effects (e.g. no Drop) and are ZSTs, +// thus they are always thread-safe. +unsafe impl Send for $name {} +// SAFETY: All registration states are free of side-effects (e.g. no Drop) and are ZSTs, +// thus they are always thread-safe. +unsafe impl Sync for $name {}
They are all ZSTs and should be Send + Sync by default, hence the impls are not needed.
Also, I don't think this macro adds a lot of value when the Send and Sync impls are removed. In the driver core it looks like this:
mod private {
pub trait Sealed {}
impl Sealed for super::Bound {}
impl Sealed for super::Core {}
impl Sealed for super::CoreInternal {}
impl Sealed for super::Normal {}
}
impl DeviceContext for Bound {}
impl DeviceContext for Core {}
impl DeviceContext for CoreInternal {}
impl DeviceContext for Normal {}I think that's compact enough.
rust/kernel/drm/device.rs macro_rules! drm_legacy_fields { · line 76
Quoted 4 lines
rust/kernel/drm/device.rs +4
-0+ }; +} + +/// A trait implemented by all possible contexts a [`Device`] can be used in.
I think this documentation should provide a rough overview of the different states a DRM device can have.
Quoted 6 lines
rust/kernel/drm/device.rs +6
-0+pub trait DeviceContext :Sealed +Send +Sync {} + +drm_dev_ctx! { +/// The [`DeviceContext`] of a [`Device`] that was registered with userspace at some point. +/// +/// This represents a [`Device`] which is guaranteed to have been registered with userspace at
rust/kernel/drm/device.rs macro_rules! drm_legacy_fields { · line 92
Quoted 10 lines
rust/kernel/drm/device.rs +10
-0+/// some point in time. Such a DRM device is guaranteed to have been fully-initialized. +/// +/// Note: A device in this context is not guaranteed to remain registered with userspace for its +/// entire lifetime, as this is impossible to guarantee at compile-time. However, any +/// userspace-dependent operations performed with an unregistered device in this [`DeviceContext`] +/// are guaranteed to be no-ops. +/// +/// # Invariants +/// +/// A [`Device`] in this [`DeviceContext`] is guaranteed to have called `drm_dev_register` once.
I'm not sure it makes sense for user facing documentation to menthion the corresponding C function here. I'd just say that it has been registered with the DRM core.
rust/kernel/drm/device.rs pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<A · line 207
Quoted 11 lines
rust/kernel/drm/device.rs +6
-1+Registered +} +@@ -132,9 +202,40 @@ pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<A// SAFETY: The reference count is one, and now we take ownership of that reference as a // `drm::Device`. -Ok (unsafe {ARef ::from_raw (raw_drm) }) +// INVARIANT: We just created the device above, but have yet to call `drm_dev_register`. +// `Self` cannot be copied or sent to another thread - ensuring that `drm_dev_register` +// won't be called during its lifetime and that the device is unregistered
Please end with a period.
rust/kernel/drm/device.rs pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<A · line 220
Quoted 13 lines
rust/kernel/drm/device.rs +11
-0+Ok (Self (unsafe {ARef ::from_raw (raw_drm) },NotThreadSafe )) } +} +/// 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
I don't think those are necessarily no-ops, in hot-unplug cases drivers might still receive DRM callbacks from userspace. But they won't be able to access bus device resources anymore. In contrast to the DRM C implementation the corresponding synchronization happens at driver core level in Rust, whereas on the C side there is drm_dev_enter() / drm_dev_exit() for this.
Quoted 27 lines
rust/kernel/drm/device.rs +18
-2+/// 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 >, +} + +impl <T : drm::Driver ,C :DeviceContext >Device <T ,C > {pub (crate )fn as_raw (&self) -> *mut bindings::drm_device { self.dev.get () }@@ -160,13 +261,13 @@ unsafe fn into_drm_device(ptr: NonNull<Self>) -> *mut bindings::drm_device {/// /// # Safety /// -/// Callers must ensure that `ptr` is valid, non-null, and has a non-zero reference count, -/// i.e. it must be ensured that the reference count of the C `struct drm_device` `ptr` points
rust/kernel/drm/device.rs unsafe fn into_drm_device(ptr: NonNull<Self>) -> *mut bindings::drm_device { · line 268
Quoted 10 lines
rust/kernel/drm/device.rs +5
-5-/// to can't drop to zero, for the duration of this function call and the entire duration when -/// the returned reference exists. -/// -/// Additionally, callers must ensure that the `struct device`, `ptr` is pointing to, is -/// embedded in `Self`. +/// * Callers must ensure that `ptr` is valid, non-null, and has a non-zero reference count, +/// i.e. it must be ensured that the reference count of the C `struct drm_device` `ptr` points +/// to can't drop to zero, for the duration of this function call and the entire duration when +/// the returned reference exists. +/// * Additionally, callers must ensure that the `struct device`, `ptr` is pointing to, is
I'd drop "additionally", it is a listing anyways.
rust/kernel/drm/device.rs unsafe fn into_drm_device(ptr: NonNull<Self>) -> *mut bindings::drm_device { · line 270
Quoted 2 lines
rust/kernel/drm/device.rs +2
-0+/// embedded in `Self`. +/// * Callers promise that any type invariants of `C` will be upheld.
What do you mean by "type invariants of C"?
Quoted 29 lines
rust/kernel/drm/device.rs +1
-1impl <T :Driver >Registration <T > {/// Creates a new [`Registration`] and registers it. -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) })?;rust/kernel/drm/device.rs +14
-5-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)) } -/// Same as [`Registration::new`}, but transfers ownership of the [`Registration`] to +/// Same as [`Registration::new`], but transfers ownership of the [`Registration`] 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>,
rust/kernel/drm/device.rs
Quoted 10 lines
rust/kernel/drm/device.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 () {
this_dev is misleading, since it actually is the parent device. Besides that, the change seems unnecessary, no?
Quoted 13 lines
return Err(EINVAL); } let reg = Registration::<T>::new(drm, flags)?;rust/kernel/drm/device.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 () }) }
PATCH v2 2/3 rust/drm: Don't setup private driver data until registration
In reply to Lyude PaulNow 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 | 59 +++++++++++++++++++++------------- rust/kernel/drm/driver.rs | 23 +++++++++++-- 4 files changed, 60 insertions(+), 30 deletions(-)
drivers/gpu/drm/nova/driver.rs +2 -2
@@ -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
@@ -139,8 +139,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 +36 -23
106 lines not on this page · raw message
rust/kernel/drm/driver.rs +20 -3
@@ -10,7 +10,12 @@ prelude::*, sync::aref::ARef, }; -use core::{mem, ptr::NonNull }; +use core::{ + mem, + ptr::NonNull , + sync::atomic::*, +// +};use macros::vtable;/// Driver use the GEM memory manager. This should be set for all modern drivers.
@@ -123,7 +128,18 @@ pub trait Driver {impl <T :Driver >Registration <T > {/// Creates a new [`Registration`] and registers it. -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) })?;
@@ -145,6 +161,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
@@ -155,7 +172,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
Danilo Krummrich
maintainerRe: [PATCH v2 2/3] rust/drm: Don't setup private driver data until registration
Quoted 42 lines · Lyude Paul
rust/kernel/drm/device.rs +2
-18@@ -118,7 +120,7 @@ pub trait DeviceContext: Sealed + Send + Sync {}/// /// 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 >;@@ -165,7 +167,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 >());@@ -184,22 +186,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 222
Quoted 7 lines
rust/kernel/drm/device.rs +3
-1@@ -231,7 +217,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 ,
Please use a kernel atomic, i.e. kernel::sync::atomic::Atomic<bool>. See also [1].
rust/kernel/drm/device.rs pub fn new(dev: &device::Device, data: impl PinInit<T::Data, Error>) -> Result<S · line 227
Quoted 4 lines
rust/kernel/drm/device.rs +4
-0+/// The Driver's private data. +/// +/// This must only be written to from [`drm::Registration::new`]. + pub(crate) data: UnsafeCell<MaybeUninit<T::Data>>,
Why not just Opaque<T::Data>?
Quoted 3 lines
rust/kernel/drm/device.rs +1
-0+ _ctx: PhantomData<C>, }
PATCH v2 3/3 rust/drm/gem: Use DeviceContext with GEM objects
In reply to Lyude PaulNow 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 | 66 ++++++++++++++++++++++------------ 7 files changed, 63 insertions(+), 37 deletions(-)
drivers/gpu/drm/nova/driver.rs +1 -1
@@ -67,7 +67,7 @@ fn probe(adev: &auxiliary::Device<Core>, _info: &Self::IdInfo) -> impl PinInit<Simpl 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
@@ -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
@@ -183,7 +183,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
@@ -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
@@ -140,13 +140,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
@@ -109,7 +109,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 -22
189 lines not on this page · raw message
Signature · 1 line
2.52.0