Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409// SPDX-License-Identifier: GPL-2.0 OR MIT
//! DRM GEM API//!//! C header: [`include/drm/drm_gem.h`](srctree/include/drm/drm_gem.h)
use crate::{ bindings, drm::{ self, device::{ DeviceContext, Registered, // }, driver::{ AllocImpl, AllocOps, // }, }, error::to_result, prelude::*, sync::aref::{ ARef, AlwaysRefCounted, // }, types::Opaque,};use core::{ marker::PhantomData, ops::Deref, ptr::NonNull, //};
#[cfg(CONFIG_RUST_DRM_GEM_SHMEM_HELPER)]pub mod shmem;
/// A macro for implementing [`AlwaysRefCounted`] for any GEM object type.////// Since all GEM objects use the same refcounting scheme.#[macro_export]macro_rules! impl_aref_for_gem_obj { ( impl $( <$( $tparam_id:ident ),+> )? for $type:ty $( where $( $bind_param:path : $bind_trait:path ),+ )? ) => { // SAFETY: All GEM objects are refcounted. unsafe impl $( <$( $tparam_id ),+> )? $crate::sync::aref::AlwaysRefCounted for $type where Self: IntoGEMObject, $( $( $bind_param : $bind_trait ),+ )? { 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()) }; }
unsafe fn dec_ref(obj: core::ptr::NonNull<Self>) { // SAFETY: `obj` is a valid pointer to an `Object<T>`. let obj = unsafe { obj.as_ref() }.as_raw();
// SAFETY: The safety requirements guarantee that the refcount is non-zero. unsafe { bindings::drm_gem_object_put(obj) }; } } };}#[cfg_attr(not(CONFIG_RUST_DRM_GEM_SHMEM_HELPER), allow(unused))]pub(crate) use impl_aref_for_gem_obj;
/// A type alias for retrieving a [`Driver`]s [`DriverFile`] implementation from its/// [`DriverObject`] implementation.////// [`Driver`]: drm::Driver/// [`DriverFile`]: drm::file::DriverFilepub 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::Driverpub type DriverAllocImpl<T, Ctx = Registered> = <<T as DriverObject>::Driver as drm::Driver>::Object<Ctx>;
/// GEM object functions, which must be implemented by drivers.pub trait DriverObject: Sync + Send + Sized { /// Parent `Driver` for this object. type Driver: drm::Driver;
/// The data type to use for passing arguments to [`DriverObject::new`]. type Args;
/// Create a new driver data object for a GEM object of a given size. fn new<Ctx: DeviceContext>( dev: &drm::Device<Self::Driver, Ctx>, size: usize, args: Self::Args, ) -> impl PinInit<Self, Error>;
/// Open a new handle to an existing object, associated with a File. fn open(_obj: &DriverAllocImpl<Self>, _file: &DriverFile<Self>) -> Result { Ok(()) }
/// Close a handle to an existing object, associated with a File. fn close(_obj: &DriverAllocImpl<Self>, _file: &DriverFile<Self>) {}}
/// Trait that represents a GEM object subtypepub trait IntoGEMObject: Sized + super::private::Sealed + AlwaysRefCounted { /// Returns a reference to the raw `drm_gem_object` structure, which must be valid as long as /// this owning object is valid. fn as_raw(&self) -> *mut bindings::drm_gem_object;
/// Converts a pointer to a `struct drm_gem_object` into a reference to `Self`. /// /// # Safety /// /// - `self_ptr` must be a valid pointer to `Self`. /// - The caller promises that holding the immutable reference returned by this function does /// not violate rust's data aliasing rules and remains valid throughout the lifetime of `'a`. unsafe fn from_raw<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self;}
extern "C" fn open_callback<T: DriverObject>( raw_obj: *mut bindings::drm_gem_object, raw_file: *mut bindings::drm_file,) -> core::ffi::c_int { // 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`, 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(), Ok(()) => 0, }}
extern "C" fn close_callback<T: DriverObject>( raw_obj: *mut bindings::drm_gem_object, raw_file: *mut bindings::drm_file,) { // 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: `close_callback` is specified in the AllocOps structure for `Object<T>`, ensuring // that `raw_obj` is indeed contained within a `Object<T>`. let obj: &DriverAllocImpl<T> = unsafe { IntoGEMObject::from_raw(raw_obj) };
T::close(obj, file);}
impl<T: DriverObject, Ctx: DeviceContext> IntoGEMObject for Object<T, Ctx> { fn as_raw(&self) -> *mut bindings::drm_gem_object { self.obj.get() }
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, Ctx>, obj) } }}
/// Base operations shared by all GEM object classespub trait BaseObject: IntoGEMObject { /// Returns the size of the object in bytes. fn size(&self) -> usize { // SAFETY: `self.as_raw()` is guaranteed to be a pointer to a valid `struct drm_gem_object`. unsafe { (*self.as_raw()).size } }
/// Creates a new handle for the object associated with a given `File` /// (or returns an existing one). fn create_handle<D, F>(&self, file: &drm::File<F>) -> Result<u32> where Self: AllocImpl<Driver = D>, D: drm::Driver<Object<Registered> = Self, File = F>, F: drm::file::DriverFile<Driver = D>, { let mut handle: u32 = 0; // SAFETY: The arguments are all valid per the type invariants. to_result(unsafe { bindings::drm_gem_handle_create(file.as_raw().cast(), self.as_raw(), &mut handle) })?; Ok(handle) }
/// Looks up an object by its handle for a given `File`. fn lookup_handle<D, F>(file: &drm::File<F>, handle: u32) -> Result<ARef<Self>> where Self: AllocImpl<Driver = D>, D: drm::Driver<Object<Registered> = Self, File = F>, F: drm::file::DriverFile<Driver = D>, { // SAFETY: The arguments are all valid per the type invariants. let ptr = unsafe { bindings::drm_gem_object_lookup(file.as_raw().cast(), handle) }; if ptr.is_null() { return Err(ENOENT); }
// SAFETY: // - A `drm::Driver` can only have a single `File` implementation. // - `file` uses the same `drm::Driver` as `Self`. // - Therefore, we're guaranteed that `ptr` must be a gem object embedded within `Self`. // - And we check if the pointer is null befoe calling from_raw(), ensuring that `ptr` is a // valid pointer to an initialized `Self`. let obj = unsafe { Self::from_raw(ptr) };
// SAFETY: // - We take ownership of the reference of `drm_gem_object_lookup()`. // - Our `NonNull` comes from an immutable reference, thus ensuring it is a valid pointer to // `Self`. Ok(unsafe { ARef::from_raw(obj.into()) }) }
/// Creates an mmap offset to map the object from userspace. fn create_mmap_offset(&self) -> Result<u64> { // SAFETY: The arguments are valid per the type invariant. to_result(unsafe { bindings::drm_gem_create_mmap_offset(self.as_raw()) })?;
// SAFETY: The arguments are valid per the type invariant. Ok(unsafe { bindings::drm_vma_node_offset_addr(&raw mut (*self.as_raw()).vma_node) }) }}
impl<T: IntoGEMObject> BaseObject for T {}
/// Crate-private base operations shared by all GEM object classes.#[cfg_attr(not(CONFIG_RUST_DRM_GEM_SHMEM_HELPER), expect(unused))]pub(crate) trait BaseObjectPrivate: IntoGEMObject { /// Return a pointer to this object's dma_resv. fn raw_dma_resv(&self) -> *mut bindings::dma_resv { // SAFETY: `self.as_raw()` always returns a valid pointer to the base DRM GEM object. unsafe { (*self.as_raw()).resv } }}
impl<T: IntoGEMObject> BaseObjectPrivate for T {}
/// A base GEM object.////// # Invariants////// * `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, Ctx: DeviceContext = Registered> { obj: Opaque<bindings::drm_gem_object>, #[pin] data: T, _ctx: PhantomData<Ctx>,}
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>), close: Some(close_callback::<T>), print_info: None, export: None, pin: None, unpin: None, get_sg_table: None, vmap: None, vunmap: None, mmap: None, status: None, vm_ops: core::ptr::null_mut(), evict: None, rss: None, };
/// Create a new GEM object. pub fn new( dev: &drm::Device<T::Driver, Ctx>, size: usize, args: T::Args, ) -> 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, args), _ctx: PhantomData, }), GFP_KERNEL, )?;
// SAFETY: `obj.as_raw()` is guaranteed to be valid by the initialization above. unsafe { (*obj.as_raw()).funcs = &Self::OBJECT_FUNCS };
// INVARIANT: `dev` and the GEM object are in the same state at the moment, and upgrading // the typestate in `dev` will not carry over to the GEM object. if let Err(err) = // SAFETY: The arguments are all valid per the type invariants. to_result(unsafe { bindings::drm_gem_object_init(dev.as_raw(), obj.obj.get(), size) }) { // SAFETY: `drm_gem_object_init()` initializes the private GEM object state before // failing, so `drm_gem_private_object_fini()` is the matching cleanup. unsafe { bindings::drm_gem_private_object_fini(obj.obj.get()) }; return Err(err); }
// SAFETY: We will never move out of `Self` as `ARef<Self>` is always treated as pinned. let ptr = KBox::into_raw(unsafe { Pin::into_inner_unchecked(obj) });
// SAFETY: `ptr` comes from `KBox::into_raw` and hence can't be NULL. let ptr = unsafe { NonNull::new_unchecked(ptr) };
// SAFETY: We take over the initial reference count from `drm_gem_object_init()`. Ok(unsafe { ARef::from_raw(ptr) }) }
/// Returns the `Device` that owns this GEM object. 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) } }
fn as_raw(&self) -> *mut bindings::drm_gem_object { self.obj.get() }
extern "C" fn free_callback(obj: *mut bindings::drm_gem_object) { let ptr: *mut Opaque<bindings::drm_gem_object> = obj.cast();
// SAFETY: All of our objects are of type `Object<T>`. let this = unsafe { crate::container_of!(ptr, Self, obj) };
// SAFETY: The C code only ever calls this callback with a valid pointer to a `struct // drm_gem_object`. unsafe { bindings::drm_gem_object_release(obj) };
// SAFETY: All of our objects are allocated via `KBox`, and we're in the // free callback which guarantees this object has zero remaining references, // so we can drop it. let _ = unsafe { KBox::from_raw(this) }; }}
impl_aref_for_gem_obj! { impl<T, C> for Object<T, C> where T: DriverObject, C: DeviceContext}
impl<T: DriverObject, Ctx: DeviceContext> super::private::Sealed for Object<T, Ctx> {}
impl<T: DriverObject, Ctx: DeviceContext> Deref for Object<T, Ctx> { type Target = T;
fn deref(&self) -> &Self::Target { &self.data }}
impl<T: DriverObject, Ctx: DeviceContext> AllocImpl for Object<T, Ctx> { type Driver = T::Driver;
const ALLOC_OPS: AllocOps = AllocOps { gem_create_object: None, prime_handle_to_fd: None, prime_fd_to_handle: None, gem_prime_import: None, gem_prime_import_sg_table: None, dumb_create: None, dumb_map_offset: None, };}
pub(super) const fn create_fops() -> bindings::file_operations { let mut fops: bindings::file_operations = pin_init::zeroed();
fops.owner = core::ptr::null_mut(); fops.open = Some(bindings::drm_open); fops.release = Some(bindings::drm_release); fops.unlocked_ioctl = Some(bindings::drm_ioctl); #[cfg(CONFIG_COMPAT)] { fops.compat_ioctl = Some(bindings::drm_compat_ioctl); } fops.poll = Some(bindings::drm_poll); fops.read = Some(bindings::drm_read); fops.llseek = Some(bindings::noop_llseek); fops.mmap = Some(bindings::drm_gem_mmap); fops.fop_flags = bindings::FOP_UNSIGNED_OFFSET;
fops}