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>
---
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.
///
--
2.49.0
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.
> ///
>
On Fri, May 30, 2025 at 10:53:21PM +0200, Christian Schrefl wrote: > 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. No, that's fine, I wasn't aware of this patch, let's go with this one then. Reviewed-by: Danilo Krummrich <dakr@kernel.org> > [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/
© 2016 - 2025 Red Hat, Inc.