thr3ads.net - Nouveau - [PATCH v3 13/14] rust: drm: gem: Add export() callback [Sep 2025]

If this information is useful, please help other people find it:
Share via:

Lyude Paul

2025-Aug-29 22:35 UTC

[PATCH v3 13/14] rust: drm: gem: Add export() callback

This introduces an optional export() callback for GEM objects, which is
used to implement the drm_gem_object_funcs->export function.

Signed-off-by: Lyude Paul <lyude at redhat.com>
---
 drivers/gpu/drm/nova/gem.rs  |  1 +
 rust/kernel/drm/gem/mod.rs   | 72 +++++++++++++++++++++++++++++++++++-
 rust/kernel/drm/gem/shmem.rs |  6 ++-
 3 files changed, 76 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/nova/gem.rs b/drivers/gpu/drm/nova/gem.rs
index 015cb56061a56..bbce6b0f4e6a4 100644
--- a/drivers/gpu/drm/nova/gem.rs
+++ b/drivers/gpu/drm/nova/gem.rs
@@ -16,6 +16,7 @@
 #[pin_data]
 pub(crate) struct NovaObject {}
 
+#[vtable]
 impl gem::DriverObject for NovaObject {
     type Driver = NovaDriver;
     type Object = gem::Object<Self>;
diff --git a/rust/kernel/drm/gem/mod.rs b/rust/kernel/drm/gem/mod.rs
index f9f9727f14e4a..1ac25fc6d527b 100644
--- a/rust/kernel/drm/gem/mod.rs
+++ b/rust/kernel/drm/gem/mod.rs
@@ -8,7 +8,7 @@
 
 use crate::{
     alloc::flags::*,
-    bindings,
+    bindings, dma_buf,
     drm::driver::{AllocImpl, AllocOps},
     drm::{self, private::Sealed},
     error::{to_result, Result},
@@ -45,6 +45,7 @@ fn as_ref(&self) ->
&kernel::drm::gem::OpaqueObject<D> {
 pub(crate) use impl_as_opaque;
 
 /// GEM object functions, which must be implemented by drivers.
+#[vtable]
 pub trait DriverObject: Sync + Send + Sized {
     /// Parent `Driver` for this object.
     type Driver: drm::Driver;
@@ -69,6 +70,11 @@ fn open(_obj: &Self::Object, _file:
&DriverFile<Self>) -> Result {
 
     /// Close a handle to an existing object, associated with a File.
     fn close(_obj: &Self::Object, _file: &DriverFile<Self>) {}
+
+    /// Optional handle for exporting a gem object.
+    fn export(_obj: &Self::Object, _flags: u32) ->
Result<DmaBuf<Self::Object>> {
+        unimplemented!()
+    }
 }
 
 /// Trait that represents a GEM object subtype
@@ -138,6 +144,21 @@ extern "C" fn close_callback<T:
DriverObject>(
     T::close(obj, file);
 }
 
+extern "C" fn export_callback<T: DriverObject>(
+    raw_obj: *mut bindings::drm_gem_object,
+    flags: i32,
+) -> *mut bindings::dma_buf {
+    // SAFETY: `export_callback` is specified in the AllocOps structure for
`Object<T>`, ensuring
+    // that `raw_obj` is contained within a `Object<T>`.
+    let obj = unsafe { T::Object::from_raw(raw_obj) };
+
+    match T::export(obj, flags as u32) {
+        // DRM takes a hold of the reference
+        Ok(buf) => buf.into_raw(),
+        Err(e) => e.to_ptr(),
+    }
+}
+
 impl<T: DriverObject> IntoGEMObject for Object<T> {
     fn as_raw(&self) -> *mut bindings::drm_gem_object {
         self.obj.get()
@@ -248,7 +269,11 @@ impl<T: DriverObject> Object<T> {
         open: Some(open_callback::<T>),
         close: Some(close_callback::<T>),
         print_info: None,
-        export: None,
+        export: if T::HAS_EXPORT {
+            Some(export_callback::<T>)
+        } else {
+            None
+        },
         pin: None,
         unpin: None,
         get_sg_table: None,
@@ -375,6 +400,49 @@ fn as_raw(&self) -> *mut bindings::drm_gem_object {
 
 impl<D: drm::Driver> Sealed for OpaqueObject<D> {}
 
+/// A [`dma_buf::DmaBuf`] which has been exported from a GEM object.
+///
+/// The [`dma_buf::DmaBuf`] will be released when this type is dropped.
+///
+/// # Invariants
+///
+/// - `self.0` points to a valid initialized [`dma_buf::DmaBuf`] for the
lifetime of this object.
+/// - The GEM object from which this [`dma_buf::DmaBuf`] was exported from is
guaranteed to be of
+///   type `T`.
+pub struct DmaBuf<T: IntoGEMObject>(NonNull<dma_buf::DmaBuf>,
PhantomData<T>);
+
+impl<T: IntoGEMObject> Deref for DmaBuf<T> {
+    type Target = dma_buf::DmaBuf;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: This pointer is guaranteed to be valid by our type
invariants.
+        unsafe { self.0.as_ref() }
+    }
+}
+
+impl<T: IntoGEMObject> Drop for DmaBuf<T> {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY:
+        // - `dma_buf::DmaBuf` is guaranteed to have an identical layout to
`struct dma_buf`
+        //   by its type invariants.
+        // - We hold the last reference to this `DmaBuf`, making it safe to
destroy.
+        unsafe { bindings::drm_gem_dmabuf_release(self.0.cast().as_ptr()) }
+    }
+}
+
+impl<T: IntoGEMObject> DmaBuf<T> {
+    /// Leak the reference for this [`DmaBuf`] and return a raw pointer to it.
+    #[inline]
+    pub(crate) fn into_raw(self) -> *mut bindings::dma_buf {
+        let dma_ptr = self.as_raw();
+
+        core::mem::forget(self);
+        dma_ptr
+    }
+}
+
 pub(super) const fn create_fops() -> bindings::file_operations {
     // SAFETY: As by the type invariant, it is safe to initialize
`bindings::file_operations`
     // zeroed.
diff --git a/rust/kernel/drm/gem/shmem.rs b/rust/kernel/drm/gem/shmem.rs
index 1437cda27a22c..b3a70e6001842 100644
--- a/rust/kernel/drm/gem/shmem.rs
+++ b/rust/kernel/drm/gem/shmem.rs
@@ -66,7 +66,11 @@ impl<T: DriverObject> Object<T> {
         open: Some(super::open_callback::<T>),
         close: Some(super::close_callback::<T>),
         print_info: Some(bindings::drm_gem_shmem_object_print_info),
-        export: None,
+        export: if T::HAS_EXPORT {
+            Some(super::export_callback::<T>)
+        } else {
+            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),
-- 
2.50.0

Daniel Almeida

2025-Sep-05 15:09 UTC

head link

[PATCH v3 13/14] rust: drm: gem: Add export() callback

> On 29 Aug 2025, at 19:35, Lyude Paul <lyude at redhat.com> wrote:
> 
> This introduces an optional export() callback for GEM objects, which is
> used to implement the drm_gem_object_funcs->export function.
> 
> Signed-off-by: Lyude Paul <lyude at redhat.com>
> ---
> drivers/gpu/drm/nova/gem.rs  |  1 +
> rust/kernel/drm/gem/mod.rs   | 72 +++++++++++++++++++++++++++++++++++-
> rust/kernel/drm/gem/shmem.rs |  6 ++-
> 3 files changed, 76 insertions(+), 3 deletions(-)
> 
> diff --git a/drivers/gpu/drm/nova/gem.rs b/drivers/gpu/drm/nova/gem.rs
> index 015cb56061a56..bbce6b0f4e6a4 100644
> --- a/drivers/gpu/drm/nova/gem.rs
> +++ b/drivers/gpu/drm/nova/gem.rs
> @@ -16,6 +16,7 @@
> #[pin_data]
> pub(crate) struct NovaObject {}
> 
> +#[vtable]
> impl gem::DriverObject for NovaObject {
>     type Driver = NovaDriver;
>     type Object = gem::Object<Self>;
> diff --git a/rust/kernel/drm/gem/mod.rs b/rust/kernel/drm/gem/mod.rs
> index f9f9727f14e4a..1ac25fc6d527b 100644
> --- a/rust/kernel/drm/gem/mod.rs
> +++ b/rust/kernel/drm/gem/mod.rs
> @@ -8,7 +8,7 @@
> 
> use crate::{
>     alloc::flags::*,
> -    bindings,
> +    bindings, dma_buf,
>     drm::driver::{AllocImpl, AllocOps},
>     drm::{self, private::Sealed},
>     error::{to_result, Result},
> @@ -45,6 +45,7 @@ fn as_ref(&self) ->
&kernel::drm::gem::OpaqueObject<D> {
> pub(crate) use impl_as_opaque;
> 
> /// GEM object functions, which must be implemented by drivers.
> +#[vtable]
> pub trait DriverObject: Sync + Send + Sized {
>     /// Parent `Driver` for this object.
>     type Driver: drm::Driver;
> @@ -69,6 +70,11 @@ fn open(_obj: &Self::Object, _file:
&DriverFile<Self>) -> Result {
> 
>     /// Close a handle to an existing object, associated with a File.
>     fn close(_obj: &Self::Object, _file: &DriverFile<Self>)
{}
> +
> +    /// Optional handle for exporting a gem object.
> +    fn export(_obj: &Self::Object, _flags: u32) ->
Result<DmaBuf<Self::Object>> {
> +        unimplemented!()
Shouldn?t this be the vtable-specific build error?
> +    }
> }
> 
> /// Trait that represents a GEM object subtype
> @@ -138,6 +144,21 @@ extern "C" fn close_callback<T:
DriverObject>(
>     T::close(obj, file);
> }
> 
> +extern "C" fn export_callback<T: DriverObject>(
> +    raw_obj: *mut bindings::drm_gem_object,
> +    flags: i32,
> +) -> *mut bindings::dma_buf {
> +    // SAFETY: `export_callback` is specified in the AllocOps structure
for `Object<T>`, ensuring
> +    // that `raw_obj` is contained within a `Object<T>`.
> +    let obj = unsafe { T::Object::from_raw(raw_obj) };
> +
> +    match T::export(obj, flags as u32) {
> +        // DRM takes a hold of the reference
> +        Ok(buf) => buf.into_raw(),
> +        Err(e) => e.to_ptr(),
> +    }
> +}
> +
> impl<T: DriverObject> IntoGEMObject for Object<T> {
>     fn as_raw(&self) -> *mut bindings::drm_gem_object {
>         self.obj.get()
> @@ -248,7 +269,11 @@ impl<T: DriverObject> Object<T> {
>         open: Some(open_callback::<T>),
>         close: Some(close_callback::<T>),
>         print_info: None,
> -        export: None,
> +        export: if T::HAS_EXPORT {
> +            Some(export_callback::<T>)
> +        } else {
> +            None
> +        },
>         pin: None,
>         unpin: None,
>         get_sg_table: None,
> @@ -375,6 +400,49 @@ fn as_raw(&self) -> *mut
bindings::drm_gem_object {
> 
> impl<D: drm::Driver> Sealed for OpaqueObject<D> {}
> 
> +/// A [`dma_buf::DmaBuf`] which has been exported from a GEM object.
> +///
> +/// The [`dma_buf::DmaBuf`] will be released when this type is dropped.
> +///
> +/// # Invariants
> +///
> +/// - `self.0` points to a valid initialized [`dma_buf::DmaBuf`] for the
lifetime of this object.
> +/// - The GEM object from which this [`dma_buf::DmaBuf`] was exported from
is guaranteed to be of
> +///   type `T`.
> +pub struct DmaBuf<T: IntoGEMObject>(NonNull<dma_buf::DmaBuf>,
PhantomData<T>);
> +
> +impl<T: IntoGEMObject> Deref for DmaBuf<T> {
> +    type Target = dma_buf::DmaBuf;
> +
> +    #[inline]
> +    fn deref(&self) -> &Self::Target {
> +        // SAFETY: This pointer is guaranteed to be valid by our type
invariants.
> +        unsafe { self.0.as_ref() }
> +    }
> +}
> +
> +impl<T: IntoGEMObject> Drop for DmaBuf<T> {
> +    #[inline]
> +    fn drop(&mut self) {
> +        // SAFETY:
> +        // - `dma_buf::DmaBuf` is guaranteed to have an identical layout
to `struct dma_buf`
> +        //   by its type invariants.
> +        // - We hold the last reference to this `DmaBuf`, making it safe
to destroy.
How can we be sure of this?
> +        unsafe { bindings::drm_gem_dmabuf_release(self.0.cast().as_ptr())
}
> +    }
> +}
> +
> +impl<T: IntoGEMObject> DmaBuf<T> {
> +    /// Leak the reference for this [`DmaBuf`] and return a raw pointer to
it.
> +    #[inline]
> +    pub(crate) fn into_raw(self) -> *mut bindings::dma_buf {
Then this should perhaps be called leak()? At least if we?re following the std
nomenclature.
> +        let dma_ptr = self.as_raw();
> +
> +        core::mem::forget(self);
> +        dma_ptr
> +    }
> +}
> +
> pub(super) const fn create_fops() -> bindings::file_operations {
>     // SAFETY: As by the type invariant, it is safe to initialize
`bindings::file_operations`
>     // zeroed.
> diff --git a/rust/kernel/drm/gem/shmem.rs b/rust/kernel/drm/gem/shmem.rs
> index 1437cda27a22c..b3a70e6001842 100644
> --- a/rust/kernel/drm/gem/shmem.rs
> +++ b/rust/kernel/drm/gem/shmem.rs
> @@ -66,7 +66,11 @@ impl<T: DriverObject> Object<T> {
>         open: Some(super::open_callback::<T>),
>         close: Some(super::close_callback::<T>),
>         print_info: Some(bindings::drm_gem_shmem_object_print_info),
> -        export: None,
> +        export: if T::HAS_EXPORT {
> +            Some(super::export_callback::<T>)
> +        } else {
> +            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),
> -- 
> 2.50.0
>

Nouveau - Sep 2025 - [PATCH v3 13/14] rust: drm: gem: Add export() callback

[PATCH v3 13/14] rust: drm: gem: Add export() callback

[PATCH v3 13/14] rust: drm: gem: Add export() callback