Commit 917b10d9 authored by Alice Ryhl's avatar Alice Ryhl Committed by Danilo Krummrich
Browse files

drm: rust: rename as_ref() to from_raw() for drm constructors 

The prefix as_* should not be used for a constructor. Constructors
usually use the prefix from_* instead.

Some prior art in the stdlib: Box::from_raw, CString::from_raw,
Rc::from_raw, Arc::from_raw, Waker::from_raw, File::from_raw_fd.

There is also prior art in the kernel crate: cpufreq::Policy::from_raw,
fs::File::from_raw_file, Kuid::from_raw, ARef::from_raw,
SeqFile::from_raw, VmaNew::from_raw, Io::from_raw.

Link: https://lore.kernel.org/r/aCd8D5IA0RXZvtcv@pollux


Signed-off-by: default avatarAlice Ryhl <aliceryhl@google.com>
Signed-off-by: default avatarDanilo Krummrich <dakr@kernel.org>
Link: https://lore.kernel.org/r/20250711-device-as-ref-v2-2-1b16ab6402d7@google.com
parent 667efb34

rust/kernel/drm/device.rs

+1 −1
Original line number Diff line number Diff line
@@ -154,7 +154,7 @@ unsafe fn from_drm_device(ptr: *const bindings::drm_device) -> *mut Self { 
    /// Additionally, callers must ensure that the `struct device`, `ptr` is pointing to, is

    /// embedded in `Self`.

    #[doc(hidden)]

    pub unsafe fn as_ref<'a>(ptr: *const bindings::drm_device) -> &'a Self {

    pub unsafe fn from_raw<'a>(ptr: *const bindings::drm_device) -> &'a Self {

        // SAFETY: By the safety requirements of this function `ptr` is a valid pointer to a

        // `struct drm_device` embedded in `Self`.

        let ptr = unsafe { Self::from_drm_device(ptr) };

rust/kernel/drm/file.rs

+4 −4
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ impl<T: DriverFile> File<T> { 
    /// # Safety

    ///

    /// `raw_file` must be a valid pointer to an open `struct drm_file`, opened through `T::open`.

    pub unsafe fn as_ref<'a>(ptr: *mut bindings::drm_file) -> &'a File<T> {

    pub unsafe fn from_raw<'a>(ptr: *mut bindings::drm_file) -> &'a File<T> {

        // SAFETY: `raw_file` is valid by the safety requirements of this function.

        unsafe { &*ptr.cast() }

    }
@@ -61,10 +61,10 @@ pub(crate) extern "C" fn open_callback( 
        // SAFETY: A callback from `struct drm_driver::open` guarantees that

        // - `raw_dev` is valid pointer to a `struct drm_device`,

        // - the corresponding `struct drm_device` has been registered.

        let drm = unsafe { drm::Device::as_ref(raw_dev) };

        let drm = unsafe { drm::Device::from_raw(raw_dev) };



        // SAFETY: `raw_file` is a valid pointer to a `struct drm_file`.

        let file = unsafe { File::<T>::as_ref(raw_file) };

        let file = unsafe { File::<T>::from_raw(raw_file) };



        let inner = match T::open(drm) {

            Err(e) => {
@@ -89,7 +89,7 @@ pub(crate) extern "C" fn postclose_callback( 
        raw_file: *mut bindings::drm_file,

    ) {

        // SAFETY: This reference won't escape this function

        let file = unsafe { File::<T>::as_ref(raw_file) };

        let file = unsafe { File::<T>::from_raw(raw_file) };



        // SAFETY: `file.driver_priv` has been created in `open_callback` through `KBox::into_raw`.

        let _ = unsafe { KBox::from_raw(file.driver_priv()) };

rust/kernel/drm/gem/mod.rs

+8 −8
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ pub trait IntoGEMObject: Sized + super::private::Sealed + AlwaysRefCounted { 
    /// - `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 as_ref<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self;

    unsafe fn from_raw<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self;

}



// SAFETY: All gem objects are refcounted.
@@ -86,12 +86,12 @@ extern "C" fn open_callback<T: BaseDriverObject<U>, U: BaseObject>( 
) -> core::ffi::c_int {

    // SAFETY: `open_callback` is only ever called with a valid pointer to a `struct drm_file`.

    let file = unsafe {

        drm::File::<<<U as IntoGEMObject>::Driver as drm::Driver>::File>::as_ref(raw_file)

        drm::File::<<<U as IntoGEMObject>::Driver as drm::Driver>::File>::from_raw(raw_file)

    };

    // SAFETY: `open_callback` is specified in the AllocOps structure for `Object<T>`, ensuring that

    // `raw_obj` is indeed contained within a `Object<T>`.

    let obj = unsafe {

        <<<U as IntoGEMObject>::Driver as drm::Driver>::Object as IntoGEMObject>::as_ref(raw_obj)

        <<<U as IntoGEMObject>::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj)

    };



    match T::open(obj, file) {
@@ -106,12 +106,12 @@ extern "C" fn close_callback<T: BaseDriverObject<U>, U: BaseObject>( 
) {

    // SAFETY: `open_callback` is only ever called with a valid pointer to a `struct drm_file`.

    let file = unsafe {

        drm::File::<<<U as IntoGEMObject>::Driver as drm::Driver>::File>::as_ref(raw_file)

        drm::File::<<<U as IntoGEMObject>::Driver as drm::Driver>::File>::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 = unsafe {

        <<<U as IntoGEMObject>::Driver as drm::Driver>::Object as IntoGEMObject>::as_ref(raw_obj)

        <<<U as IntoGEMObject>::Driver as drm::Driver>::Object as IntoGEMObject>::from_raw(raw_obj)

    };



    T::close(obj, file);
@@ -124,7 +124,7 @@ fn as_raw(&self) -> *mut bindings::drm_gem_object { 
        self.obj.get()

    }



    unsafe fn as_ref<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self {

    unsafe fn from_raw<'a>(self_ptr: *mut bindings::drm_gem_object) -> &'a Self {

        let self_ptr: *mut Opaque<bindings::drm_gem_object> = self_ptr.cast();



        // SAFETY: `obj` is guaranteed to be in an `Object<T>` via the safety contract of this
@@ -170,9 +170,9 @@ fn lookup_handle( 
        // - 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 as_ref(), ensuring that `ptr` is a

        // - 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::as_ref(ptr) };

        let obj = unsafe { Self::from_raw(ptr) };



        // SAFETY:

        // - We take ownership of the reference of `drm_gem_object_lookup()`.

rust/kernel/drm/ioctl.rs

+2 −2
Original line number Diff line number Diff line
@@ -134,7 +134,7 @@ macro_rules! declare_drm_ioctls { 
                            // FIXME: Currently there is nothing enforcing that the types of the

                            // dev/file match the current driver these ioctls are being declared

                            // for, and it's not clear how to enforce this within the type system.

                            let dev = $crate::drm::device::Device::as_ref(raw_dev);

                            let dev = $crate::drm::device::Device::from_raw(raw_dev);

                            // SAFETY: The ioctl argument has size `_IOC_SIZE(cmd)`, which we

                            // asserted above matches the size of this type, and all bit patterns of

                            // UAPI structs must be valid.
@@ -142,7 +142,7 @@ macro_rules! declare_drm_ioctls { 
                                &*(raw_data as *const $crate::types::Opaque<$crate::uapi::$struct>)

                            };

                            // SAFETY: This is just the DRM file structure

                            let file = unsafe { $crate::drm::File::as_ref(raw_file) };

                            let file = unsafe { $crate::drm::File::from_raw(raw_file) };



                            match $func(dev, data, file) {

                                Err(e) => e.to_errno(),