Commit 64888dfd authored by Christian Schrefl's avatar Christian Schrefl Committed by Danilo Krummrich
Browse files

rust: implement `Wrapper<T>` for `Opaque<T>` 



Moves the implementation for `pin-init` from an associated function
to the trait function of the `Wrapper` trait and extends the
implementation to support pin-initializers with error types.

Adds a use for the `Wrapper` trait in `revocable.rs`, to use the new
`pin-init` function. This is currently the only usage in the kernel.

Reviewed-by: default avatarGerald Wisböck <gerald.wisboeck@feather.ink>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarBenno Lossin <lossin@kernel.org>
Acked-by: default avatarMiguel Ojeda <ojeda@kernel.org>
Signed-off-by: default avatarChristian Schrefl <chrisi.schrefl@gmail.com>
Link: https://lore.kernel.org/r/20250610-b4-rust_miscdevice_registrationdata-v6-1-b03f5dfce998@gmail.com


Signed-off-by: default avatarDanilo Krummrich <dakr@kernel.org>
parent 0dab138d

rust/kernel/revocable.rs

+2 −0
Original line number Diff line number Diff line
@@ -5,6 +5,8 @@ 
//! The [`Revocable`] type wraps other types and allows access to them to be revoked. The existence

//! of a [`RevocableGuard`] ensures that objects remain valid.



use pin_init::Wrapper;



use crate::{bindings, prelude::*, sync::rcu, types::Opaque};

use core::{

    marker::PhantomData,

rust/kernel/types.rs

+14 −12
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 
    ops::{Deref, DerefMut},

    ptr::NonNull,

};

use pin_init::{PinInit, Zeroable};

use pin_init::{PinInit, Wrapper, Zeroable};



/// Used to transfer ownership to and from foreign (non-Rust) languages.

///
@@ -353,17 +353,6 @@ pub const fn zeroed() -> Self { 
        }

    }



    /// Create an opaque pin-initializer from the given pin-initializer.

    pub fn pin_init(slot: impl PinInit<T>) -> impl PinInit<Self> {

        Self::ffi_init(|ptr: *mut T| {

            // SAFETY:

            //   - `ptr` is a valid pointer to uninitialized memory,

            //   - `slot` is not accessed on error; the call is infallible,

            //   - `slot` is pinned in memory.

            let _ = unsafe { PinInit::<T>::__pinned_init(slot, ptr) };

        })

    }



    /// Creates a pin-initializer from the given initializer closure.

    ///

    /// The returned initializer calls the given closure with the pointer to the inner `T` of this
@@ -415,6 +404,19 @@ pub const fn raw_get(this: *const Self) -> *mut T { 
    }

}



impl<T> Wrapper<T> for Opaque<T> {

    /// Create an opaque pin-initializer from the given pin-initializer.

    fn pin_init<E>(slot: impl PinInit<T, E>) -> impl PinInit<Self, E> {

        Self::try_ffi_init(|ptr: *mut T| {

            // SAFETY:

            //   - `ptr` is a valid pointer to uninitialized memory,

            //   - `slot` is not accessed on error,

            //   - `slot` is pinned in memory.

            unsafe { PinInit::<T, E>::__pinned_init(slot, ptr) }

        })

    }

}



/// Types that are _always_ reference counted.

///

/// It allows such types to define their own custom ref increment and decrement functions.