// SPDX-License-Identifier: GPL-2.0 //! DRM GEM shmem helper objects//!//! C header: [`include/linux/drm/drm_gem_shmem_helper.h`](srctree/include/drm/drm_gem_shmem_helper.h) // TODO:// - There are a number of spots here that manually acquire/release the DMA reservation lock using//   dma_resv_(un)lock(). In the future we should add support for ww mutex, expose a method to//   acquire a reference to the WwMutex, and then use that directly instead of the C functions here. use crate::{    container_of,    device::{        self,        Bound, //    },    devres::*,    drm::{        driver,        gem,        private::Sealed,        Device, //    },    error::{        from_err_ptr,        to_result, //    },    io::{        IoBase,        Region,        SysMem,        SysMemBackend, //    },    prelude::*,    scatterlist,    sync::{        aref::ARef,        new_mutex,        Mutex,        SetOnce, //    },    types::{        NotThreadSafe,        Opaque, //    },};use core::{    ffi::c_void,    mem::{        ManuallyDrop,        MaybeUninit, //    },    ops::{        Deref,        DerefMut, //    },    ptr::{        self,        NonNull, //    },};use gem::{    BaseObject,    BaseObjectPrivate,    DriverObject,    IntoGEMObject, //}; /// A struct for controlling the creation of shmem-backed GEM objects.////// This is used with [`Object::new()`] to control various properties that can only be set when/// initially creating a shmem-backed GEM object.pub struct ObjectConfig<'a, T: DriverObject> {    /// Whether to set the write-combine map flag.    pub map_wc: bool,     /// Reuse the DMA reservation from another GEM object.    ///    /// The newly created [`Object`] will hold an owned refcount to `parent_resv_obj` if specified.    pub parent_resv_obj: Option<&'a Object<T>>,} impl<'a, T: DriverObject> Default for ObjectConfig<'a, T> {    #[inline(always)]    fn default() -> Self {        Self {            map_wc: false,            parent_resv_obj: None,        }    }} /// A shmem-backed GEM object.////// # Invariants////// - `obj` contains a valid initialized `struct drm_gem_shmem_object` for the lifetime of this///   object.#[repr(C)]#[pin_data]pub struct Object<T: DriverObject> {    #[pin]    obj: Opaque<bindings::drm_gem_shmem_object>,    /// Parent object that owns this object's DMA reservation object.    parent_resv_obj: Option<ARef<Object<T>>>,    /// Devres object for unmapping any SGTable on driver-unbind.    sgt_res: ManuallyDrop<SetOnce<Devres<SGTableMap<T>>>>,    #[pin]    /// Lock for protecting initialization of `sgt_res`.    sgt_lock: Mutex<()>,    #[pin]    inner: T,} super::impl_aref_for_gem_obj! {    impl<T> for Object<T>    where        T: DriverObject} // SAFETY: All GEM objects are thread-safe.unsafe impl<T: DriverObject> Send for Object<T> {} // SAFETY: All GEM objects are thread-safe.unsafe impl<T: DriverObject> Sync for Object<T> {} impl<T: DriverObject> Object<T> {    /// `drm_gem_object_funcs` vtable suitable for GEM shmem objects.    const VTABLE: bindings::drm_gem_object_funcs = bindings::drm_gem_object_funcs {        free: Some(Self::free_callback),        open: Some(super::open_callback::<T>),        close: Some(super::close_callback::<T>),        print_info: Some(bindings::drm_gem_shmem_object_print_info),        export: None,        pin: Some(bindings::drm_gem_shmem_object_pin),        unpin: Some(bindings::drm_gem_shmem_object_unpin),        get_sg_table: Some(bindings::drm_gem_shmem_object_get_sg_table),        vmap: Some(bindings::drm_gem_shmem_object_vmap),        vunmap: Some(bindings::drm_gem_shmem_object_vunmap),        mmap: Some(bindings::drm_gem_shmem_object_mmap),        status: None,        rss: None,        #[allow(unused_unsafe, reason = "Safe since Rust 1.82.0")]        // SAFETY: `drm_gem_shmem_vm_ops` is a valid, static const on the C side.        vm_ops: unsafe { &raw const bindings::drm_gem_shmem_vm_ops },        evict: None,    };     /// Return a raw pointer to the embedded drm_gem_shmem_object.    fn as_raw_shmem(&self) -> *mut bindings::drm_gem_shmem_object {        self.obj.get()    }     /// Returns the `Device` that owns this GEM object.    pub fn dev(&self) -> &Device<T::Driver> {        // SAFETY: `dev` will have been initialized in `Self::new()` by `drm_gem_shmem_init()`.        unsafe { Device::from_raw((*self.as_raw()).dev) }    }     extern "C" fn free_callback(obj: *mut bindings::drm_gem_object) {        // SAFETY:        // - DRM always passes a valid gem object here        // - We used drm_gem_shmem_create() in our create_gem_object callback, so we know that        //   `obj` is contained within a drm_gem_shmem_object        let base = unsafe { container_of!(obj, bindings::drm_gem_shmem_object, base) };         // SAFETY:        // - We verified above that `obj` is valid, which makes `this` valid        // - This function is set in AllocOps, so we know that `this` is contained within an        //   `Object<T>`        let this = unsafe { container_of!(Opaque::cast_from(base), Self, obj) }.cast_mut();         // We need to drop `sgt_res` first, since doing so requires that the GEM object is still        // alive.        // SAFETY:        // - We verified above that `this` is valid.        // - We are in free_callback, guaranteeing we have exclusive access to `this` and that        //   `sgt_res` will not be used after dropping it here.        unsafe { ManuallyDrop::drop(&mut (*this).sgt_res) };         // SAFETY:        // - We're in free_callback - so this function is safe to call.        // - We won't be using the gem resources on `this` after this call.        unsafe { bindings::drm_gem_shmem_release(base) };         // SAFETY: We're recovering the Kbox<> we created in gem_create_object()        let _ = unsafe { KBox::from_raw(this) };    }     /// Attempt to create a vmap from the gem object, and confirm the size of said vmap.    fn make_vmap<'a, R, const SIZE: usize>(&'a self) -> Result<VMap<T, R, SIZE>>    where        R: Deref<Target = Self> + From<&'a Self>,    {        // INVARIANT: We check here that the gem object is at least as large as `SIZE`.        if self.size() < SIZE {            return Err(ENOSPC);        }         let mut map: MaybeUninit<bindings::iosys_map> = MaybeUninit::uninit();        let guard = DmaResvGuard::new(self);         // SAFETY: `drm_gem_shmem_vmap()` can be called with the DMA reservation lock held.        to_result(unsafe {            bindings::drm_gem_shmem_vmap_locked(self.as_raw_shmem(), map.as_mut_ptr())        })?;         // Drop the guard explicitly here, since we may need to call `raw_vunmap()` (which        // re-acquires the lock).        drop(guard);         // SAFETY: The call to `drm_gem_shmem_vmap_locked()` succeeded above, so we are guaranteed        // that map is properly initialized.        let map = unsafe { map.assume_init() };         // XXX: We don't currently support iomem allocations        if map.is_iomem {            // SAFETY: The vmap operation above succeeded, guaranteeing that `map` points to a valid            // memory mapping.            unsafe { self.raw_vunmap(map) };             Err(ENOTSUPP)        } else {            Ok(VMap {                // INVARIANT: `addr` remains valid for as long as `owner` does, which extends to the                // lifetime of `VMap` itself.                // SAFETY: We checked that this is not an iomem allocation, making it safe to read                // vaddr.                addr: unsafe { map.__bindgen_anon_1.vaddr },                owner: self.into(),            })        }    }     /// Unmap a vmap from the gem object.    ///    /// # Safety    ///    /// - The caller promises that `map` is a valid vmap on this gem object.    /// - The caller promises that the memory pointed to by map will no longer be accesed through    ///   this instance.    unsafe fn raw_vunmap(&self, mut map: bindings::iosys_map) {        let _guard = DmaResvGuard::new(self);         // SAFETY:        // - This function is safe to call with the DMA reservation lock held.        // - The caller promises that `map` is a valid vmap on this gem object.        unsafe { bindings::drm_gem_shmem_vunmap_locked(self.as_raw_shmem(), &mut map) };    }     /// Creates and returns a virtual kernel memory mapping for this object.    #[inline]    pub fn vmap<const SIZE: usize>(&self) -> Result<VMapRef<'_, T, SIZE>> {        self.make_vmap()    }     /// Creates (if necessary) and returns an immutable reference to a scatter-gather table of DMA    /// pages for this object.    ///    /// This will pin the object in memory. It is expected that `dev` should be a pointer to the    /// same [`device::Device`] which `self` belongs to, otherwise this function will return    /// `Err(EINVAL)`.    pub fn sg_table<'a>(        &'a self,        dev: &'a device::Device<Bound>,    ) -> Result<&'a scatterlist::SGTable> {        let parent = self.dev().as_ref();        if dev.as_raw() != parent.as_ref().as_raw() {            return Err(EINVAL);        }         let sgt_res = 'out: {            // Fast path: sgt_res is already initialized            if let Some(sgt_res) = self.sgt_res.as_ref() {                break 'out sgt_res;            }             // Slow path: Grab the lock and see if we need to initialize sgt_res.            let _guard = self.sgt_lock.lock();             // If someone initialized it while we were waiting, we can exit early.            if let Some(sgt_res) = self.sgt_res.as_ref() {                break 'out sgt_res;            }             // If not, finish initializing and return. `populate()` cannot return false, as            // `sgt_res` must be unpopulated, and we must hold `sgt_lock` to reach this point.            self.sgt_res                .populate(Devres::new(dev, SGTableMap::new(self))?);             // SAFETY: We just populated sgt_res above.            unsafe { self.sgt_res.as_ref().unwrap_unchecked() }        };         Ok(sgt_res.access(dev)?)    }     /// Create a new shmem-backed DRM object of the given size.    ///    /// Additional config options can be specified using `config`.    pub fn new(        dev: &Device<T::Driver>,        size: usize,        config: ObjectConfig<'_, T>,        args: T::Args,    ) -> Result<ARef<Self>> {        let new: Pin<KBox<Self>> = KBox::try_pin_init(            try_pin_init!(Self {                obj <- Opaque::init_zeroed(),                parent_resv_obj: config.parent_resv_obj.map(|p| p.into()),                sgt_res: ManuallyDrop::new(SetOnce::new()),                sgt_lock <- new_mutex!(()),                inner <- T::new(dev, size, args),            }),            GFP_KERNEL,        )?;         // SAFETY: `obj.as_raw()` is guaranteed to be valid by the initialization above.        unsafe { (*new.as_raw()).funcs = &Self::VTABLE };         // SAFETY: The arguments are all valid via the type invariants.        to_result(unsafe { bindings::drm_gem_shmem_init(dev.as_raw(), new.as_raw_shmem(), size) })?;         // SAFETY: We never move out of `self`.        let new = KBox::into_raw(unsafe { Pin::into_inner_unchecked(new) });         // SAFETY: We're taking over the owned refcount from `drm_gem_shmem_init`.        let obj = unsafe { ARef::from_raw(NonNull::new_unchecked(new)) };         // Start filling out values from `config`        if let Some(parent_resv) = config.parent_resv_obj {            // SAFETY: We have yet to expose the new gem object outside of this function, so it is            // safe to modify this field.            unsafe { (*obj.obj.get()).base.resv = parent_resv.raw_dma_resv() };        }         // SAFETY: We have yet to expose this object outside of this function, so we're guaranteed        // to have exclusive access - thus making this safe to hold a mutable reference to.        let shmem = unsafe { &mut *obj.as_raw_shmem() };        shmem.set_map_wc(config.map_wc);         Ok(obj)    }     /// Creates and returns an owned reference to a virtual kernel memory mapping for this object.    #[inline]    pub fn owned_vmap<const SIZE: usize>(&self) -> Result<VMapOwned<T, SIZE>> {        self.make_vmap()    }} impl<T: DriverObject> Deref for Object<T> {    type Target = T;     fn deref(&self) -> &Self::Target {        &self.inner    }} impl<T: DriverObject> DerefMut for Object<T> {    fn deref_mut(&mut self) -> &mut Self::Target {        &mut self.inner    }} impl<T: DriverObject> Sealed for Object<T> {} impl<T: DriverObject> gem::IntoGEMObject for Object<T> {    fn as_raw(&self) -> *mut bindings::drm_gem_object {        // SAFETY:        // - Our immutable reference is proof that this is safe to dereference.        // - `obj` is always a valid drm_gem_shmem_object via our type invariants.        unsafe { &raw mut (*self.obj.get()).base }    }     unsafe fn from_raw<'a>(obj: *mut bindings::drm_gem_object) -> &'a Self {        // SAFETY: The safety contract of from_gem_obj() guarantees that `obj` is contained within        // `Self`        unsafe {            let obj = Opaque::cast_from(container_of!(obj, bindings::drm_gem_shmem_object, base));             &*container_of!(obj, Self, obj)        }    }} impl<T: DriverObject> driver::AllocImpl for Object<T> {    type Driver = T::Driver;     const ALLOC_OPS: driver::AllocOps = driver::AllocOps {        gem_create_object: None,        prime_handle_to_fd: None,        prime_fd_to_handle: None,        gem_prime_import: None,        gem_prime_import_sg_table: Some(bindings::drm_gem_shmem_prime_import_sg_table),        dumb_create: Some(bindings::drm_gem_shmem_dumb_create),        dumb_map_offset: None,    };} /// Private helper-type for holding the `dma_resv` object for a GEM shmem object.////// When this is dropped, the `dma_resv` lock is dropped as well.///// TODO: This should be replace with a WwMutex equivalent once we have such bindings in the kernel.struct DmaResvGuard<'a, T: DriverObject>(&'a Object<T>, NotThreadSafe); impl<'a, T: DriverObject> DmaResvGuard<'a, T> {    #[inline]    fn new(obj: &'a Object<T>) -> Self {        // SAFETY: This lock is initialized throughout the lifetime of `object`.        unsafe { bindings::dma_resv_lock(obj.raw_dma_resv(), ptr::null_mut()) };         Self(obj, NotThreadSafe)    }} impl<'a, T: DriverObject> Drop for DmaResvGuard<'a, T> {    #[inline]    fn drop(&mut self) {        // SAFETY: We are releasing the lock grabbed during the creation of this object.        unsafe { bindings::dma_resv_unlock(self.0.raw_dma_resv()) };    }} /// A reference to a virtual mapping for an shmem-based GEM object in kernel address space.////// # Invariants////// - The size of `owner` is >= SIZE./// - The memory pointed to by `addr` remains valid at least until this object is dropped.pub struct VMap<D, R, const SIZE: usize = 0>where    D: DriverObject,    R: Deref<Target = Object<D>>,{    addr: *mut c_void,    owner: R,} /// An alias type for a reference to a shmem-based GEM object's VMap.pub type VMapRef<'a, D, const SIZE: usize = 0> = VMap<D, &'a Object<D>, SIZE>; /// An alias type for an owned reference to a shmem-based GEM object's VMap.pub type VMapOwned<D, const SIZE: usize = 0> = VMap<D, ARef<Object<D>>, SIZE>; impl<D, R, const SIZE: usize> VMap<D, R, SIZE>where    D: DriverObject,    R: Deref<Target = Object<D>>,{    /// Borrows a reference to the object that owns this virtual mapping.    #[inline]    pub fn owner(&self) -> &Object<D> {        &self.owner    }} impl<'a, D, R, const SIZE: usize> IoBase<'a> for &'a VMap<D, R, SIZE>where    D: DriverObject,    R: Deref<Target = Object<D>>,{    type Backend = SysMemBackend;    type Target = Region<SIZE>;     #[inline]    fn as_view(self) -> SysMem<'a, Region<SIZE>> {        let ptr = Region::ptr_from_raw_parts_mut(self.addr.cast(), self.owner.size());         // SAFETY: Per type invariants of `VMap`:        // - `addr .. addr + owner.size()` is a valid kernel accessible memory region.        // - `addr` is page-aligned, which satisfies `Region`'s 4-byte alignment requirement.        // - The memory remains valid until this `VMap` is dropped; since `self` is `&'a VMap`,        //   the borrow prevents the `VMap` from being dropped for the lifetime `'a`.        unsafe { SysMem::new(ptr) }    }} impl<D, R, const SIZE: usize> Drop for VMap<D, R, SIZE>where    D: DriverObject,    R: Deref<Target = Object<D>>,{    #[inline]    fn drop(&mut self) {        // SAFETY:        // - Our existence is proof that this map was previously created using self.owner.        // - Since we are in Drop, we are guaranteed that no one will access the memory        //   through this mapping after calling this.        unsafe {            self.owner.raw_vunmap(bindings::iosys_map {                is_iomem: false,                __bindgen_anon_1: bindings::iosys_map__bindgen_ty_1 { vaddr: self.addr },            })        };    }} 

Lines 1–500 of 721. Load more