Re: [PATCH v4 1/3] rust: implement `Wrapper<T>` for `Opaque<T>`

[Christian Schrefl <chrisi.schrefl@gmail.com>]

On 30.05.25 10:46 PM, Christian Schrefl wrote:
> 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: Gerald Wisböck <gerald.wisboeck@feather.ink>
> Reviewed-by: Alice Ryhl <aliceryhl@google.com>
> Reviewed-by: Benno Lossin <lossin@kernel.org>
> Signed-off-by: Christian Schrefl <chrisi.schrefl@gmail.com>
> ---

Danilo, FYI this is basically a patch from my `UnsafePinned`
series [0] that I've used instead of your patch [1] that does something similar.
(I've only dropped `the call is infallible` from the safety
comment like in your patch since I missed that before).

Let me know if you want me to handle this any different.

[0]: https://lore.kernel.org/rust-for-linux/20250511-rust_unsafe_pinned-v4-2-a86c32e47e3d@gmail.com/
[1]: https://lore.kernel.org/rust-for-linux/20250530142447.166524-2-dakr@kernel.org/

Cheers
Christian

>  rust/kernel/revocable.rs |  2 ++
>  rust/kernel/types.rs     | 25 +++++++++++++------------
>  2 files changed, 15 insertions(+), 12 deletions(-)
> 
> diff --git a/rust/kernel/revocable.rs b/rust/kernel/revocable.rs
> index 1e5a9d25c21b279b01f90b02997492aa4880d84f..4db68ea2207ebafcc09d082fdc1e281f31846a38 100644
> --- a/rust/kernel/revocable.rs
> +++ b/rust/kernel/revocable.rs
> @@ -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,
> diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs
> index 86562e738eac85480a048041e979335b81c5e3c9..7ab70d5f76099c3442dce5b02c6b226fc74c851e 100644
> --- a/rust/kernel/types.rs
> +++ b/rust/kernel/types.rs
> @@ -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.
>  ///
> @@ -345,17 +345,6 @@ pub const fn uninit() -> 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
> @@ -406,6 +395,18 @@ pub const fn raw_get(this: *const Self) -> *mut T {
>          UnsafeCell::raw_get(this.cast::<UnsafeCell<MaybeUninit<T>>>()).cast::<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.
>  ///
>