* [PATCH v3 1/3] rust: add UnsafePinned type
2025-05-10 9:32 [PATCH v3 0/3] rust: add `UnsafePinned` type Christian Schrefl
@ 2025-05-10 9:32 ` Christian Schrefl
2025-05-11 12:16 ` kernel test robot
2025-05-10 9:32 ` [PATCH v3 2/3] rust: implement `Wrapper<T>` for `Opaque<T>` Christian Schrefl
2025-05-10 9:32 ` [PATCH v3 3/3] rust: use `UnsafePinned` in the implementation of `Opaque` Christian Schrefl
2 siblings, 1 reply; 5+ messages in thread
From: Christian Schrefl @ 2025-05-10 9:32 UTC (permalink / raw)
To: Sky, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, Danilo Krummrich, Gerald Wisböck,
Nathan Chancellor, Nick Desaulniers, Bill Wendling, Justin Stitt
Cc: linux-kernel, rust-for-linux, llvm, Christian Schrefl
`UnsafePinned<T>` is useful for cases where a value might be shared with
C code but not directly used by it. In particular this is added for
storing additional data in the `MiscDeviceRegistration` which will be
shared between `fops->open` and the containing struct.
Similar to `Opaque` but guarantees that the value is always initialized
and that the inner value is dropped when `UnsafePinned` is dropped.
This was originally proposed for the IRQ abstractions [0] and is also
useful for other where the inner data may be aliased, but is always
valid and automatic `Drop` is desired.
Since then the `UnsafePinned` type was added to upstream Rust [1] by Sky
as a unstable feature, therefore this patch implements the subset of the
upstream API for the `UnsafePinned` type required for additional data in
`MiscDeviceRegistration` and in the implementation of the `Opaque` type.
Some differences to the upstream type definition are required in the
kernel implementation, because upstream type uses some compiler changes
to opt out of certain optimizations, this is documented in the
documentation and a comment on the `UnsafePinned` type.
The documentation on is based on the upstream rust documentation with
minor modifications for the kernel implementation.
Link: https://lore.kernel.org/rust-for-linux/CAH5fLgiOASgjoYKFz6kWwzLaH07DqP2ph+3YyCDh2+gYqGpABA@mail.gmail.com [0]
Link: https://github.com/rust-lang/rust/pull/137043 [1]
Suggested-by: Alice Ryhl <aliceryhl@google.com>
Reviewed-by: Gerald Wisböck <gerald.wisboeck@feather.ink>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Co-developed-by: Sky <sky@sky9.dev>
Signed-off-by: Sky <sky@sky9.dev>
Signed-off-by: Christian Schrefl <chrisi.schrefl@gmail.com>
---
rust/kernel/types.rs | 6 ++
rust/kernel/types/unsafe_pinned.rs | 113 +++++++++++++++++++++++++++++++++++++
2 files changed, 119 insertions(+)
diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs
index 9d0471afc9648f2973235488b441eb109069adb1..705f420fdfbc4a576de1c4546578f2f04cdf615e 100644
--- a/rust/kernel/types.rs
+++ b/rust/kernel/types.rs
@@ -253,6 +253,9 @@ fn drop(&mut self) {
///
/// [`Opaque<T>`] is meant to be used with FFI objects that are never interpreted by Rust code.
///
+/// In cases where the contained data is only used by Rust, is not allowed to be
+/// uninitialized and automatic [`Drop`] is desired [`UnsafePinned`] should be used instead.
+///
/// It is used to wrap structs from the C side, like for example `Opaque<bindings::mutex>`.
/// It gets rid of all the usual assumptions that Rust has for a value:
///
@@ -578,3 +581,6 @@ pub enum Either<L, R> {
/// [`NotThreadSafe`]: type@NotThreadSafe
#[allow(non_upper_case_globals)]
pub const NotThreadSafe: NotThreadSafe = PhantomData;
+
+mod unsafe_pinned;
+pub use unsafe_pinned::UnsafePinned;
diff --git a/rust/kernel/types/unsafe_pinned.rs b/rust/kernel/types/unsafe_pinned.rs
new file mode 100644
index 0000000000000000000000000000000000000000..612b67b400ff361335803c29799b6aeb375ed52c
--- /dev/null
+++ b/rust/kernel/types/unsafe_pinned.rs
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! The contents of this file partially come from the Rust standard library, hosted in
+//! the <https://github.com/rust-lang/rust> repository, licensed under
+//! "Apache-2.0 OR MIT" and adapted for kernel use. For copyright details,
+//! see <https://github.com/rust-lang/rust/blob/master/COPYRIGHT>.
+//!
+//! This file provides a implementation / polyfill of a subset of the upstream
+//! rust `UnsafePinned` type. For details on the difference to the upstream
+//! implementation see the comment on the [`UnsafePinned`] struct definition.
+
+use core::{cell::UnsafeCell, marker::PhantomPinned};
+use pin_init::{cast_pin_init, PinInit, Wrapper};
+
+/// This type provides a way to opt-out of typical aliasing rules;
+/// specifically, `&mut UnsafePinned<T>` is not guaranteed to be a unique pointer.
+///
+/// However, even if you define your type like `pub struct Wrapper(UnsafePinned<...>)`, it is still
+/// very risky to have an `&mut Wrapper` that aliases anything else. Many functions that work
+/// generically on `&mut T` assume that the memory that stores `T` is uniquely owned (such as
+/// `mem::swap`). In other words, while having aliasing with `&mut Wrapper` is not immediate
+/// Undefined Behavior, it is still unsound to expose such a mutable reference to code you do not
+/// control! Techniques such as pinning via [`Pin`](core::pin::Pin) are needed to ensure soundness.
+///
+/// Similar to [`UnsafeCell`], [`UnsafePinned`] will not usually show up in
+/// the public API of a library. It is an internal implementation detail of libraries that need to
+/// support aliasing mutable references.
+///
+/// Further note that this does *not* lift the requirement that shared references must be read-only!
+/// Use [`UnsafeCell`] for that.
+///
+/// This type blocks niches the same way [`UnsafeCell`] does.
+///
+/// # Kernel implementation notes
+///
+/// This implementation works because of the "`!Unpin` hack" in rustc, which allows (some kinds of)
+/// mutual aliasing of `!Unpin` types. This hack might be removed at some point, after which only
+/// the `core::pin::UnsafePinned` type will allow this behavior. In order to simplify the migration
+/// to future rust versions only this polyfill of this type should be used when this behavior is
+/// required.
+//
+// As opposed to the upstream Rust type this contains a `PhantomPinned` and `UnsafeCell<T>`
+// - `PhantomPinned` to ensure the struct always is `!Unpin` and thus enables the `!Unpin` hack.
+// This causes the LLVM `noalias` and `dereferenceable` attributes to be removed from
+// `&mut !Unpin` types.
+// - In order to disable niche optimizations this implementation uses `UnsafeCell` internally,
+// the upstream version however currently does not. This will most likely change in the future
+// but for now we don't expose this in the documentation, since adding the guarantee is simpler
+// than removing it. Meaning that for now the fact that `UnsafePinned` contains an `UnsafeCell`
+// must not be relied on (Other than the niche blocking).
+// See this Rust tracking issue: https://github.com/rust-lang/rust/issues/137750
+#[repr(transparent)]
+pub struct UnsafePinned<T: ?Sized> {
+ _ph: PhantomPinned,
+ value: UnsafeCell<T>,
+}
+
+impl<T> UnsafePinned<T> {
+ /// Constructs a new instance of [`UnsafePinned`] which will wrap the specified value.
+ ///
+ /// All access to the inner value through `&UnsafePinned<T>` or `&mut UnsafePinned<T>` or
+ /// `Pin<&mut UnsafePinned<T>>` requires `unsafe` code.
+ #[inline(always)]
+ #[must_use]
+ pub const fn new(value: T) -> Self {
+ UnsafePinned {
+ value: UnsafeCell::new(value),
+ _ph: PhantomPinned,
+ }
+ }
+}
+impl<T: ?Sized> UnsafePinned<T> {
+ /// Get read-only access to the contents of a shared `UnsafePinned`.
+ ///
+ /// Note that `&UnsafePinned<T>` is read-only if `&T` is read-only. This means that if there is
+ /// mutation of the `T`, future reads from the `*const T` returned here are UB! Use
+ /// [`UnsafeCell`] if you also need interior mutability.
+ ///
+ /// [`UnsafeCell`]: core::cell::UnsafeCell
+ ///
+ /// ```rust,no_build
+ /// use kernel::types::UnsafePinned;
+ ///
+ /// unsafe {
+ /// let mut x = UnsafePinned::new(0);
+ /// let ptr = x.get(); // read-only pointer, assumes immutability
+ /// x.get_mut_unchecked().write(1);
+ /// ptr.read(); // UB!
+ /// }
+ /// ```
+ ///
+ /// Note that the `get_mut_unchecked` function used by this example is
+ /// currently not implemented in the kernel implementation.
+ #[inline(always)]
+ #[must_use]
+ pub const fn get(&self) -> *const T {
+ self.value.get()
+ }
+
+ /// Gets a mutable pointer to the wrapped value.
+ #[inline(always)]
+ #[must_use]
+ pub const fn raw_get_mut(this: *mut Self) -> *mut T {
+ this as *mut T
+ }
+}
+
+impl<T> Wrapper<T> for UnsafePinned<T> {
+ fn pin_init<E>(init: impl PinInit<T, E>) -> impl PinInit<Self, E> {
+ // SAFETY: `UnsafePinned<T>` has a compatible layout to `T`.
+ unsafe { cast_pin_init(init) }
+ }
+}
--
2.49.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* Re: [PATCH v3 1/3] rust: add UnsafePinned type
2025-05-10 9:32 ` [PATCH v3 1/3] rust: add UnsafePinned type Christian Schrefl
@ 2025-05-11 12:16 ` kernel test robot
0 siblings, 0 replies; 5+ messages in thread
From: kernel test robot @ 2025-05-11 12:16 UTC (permalink / raw)
To: Christian Schrefl, Sky, Miguel Ojeda, Alex Gaynor, Boqun Feng,
Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg,
Alice Ryhl, Trevor Gross, Danilo Krummrich, Gerald Wisböck,
Nathan Chancellor, Nick Desaulniers, Bill Wendling, Justin Stitt
Cc: llvm, oe-kbuild-all, linux-kernel, rust-for-linux,
Christian Schrefl
Hi Christian,
kernel test robot noticed the following build errors:
[auto build test ERROR on 9de1a293c8ece00d226b21a35751ec178be2a9fa]
url: https://github.com/intel-lab-lkp/linux/commits/Christian-Schrefl/rust-add-UnsafePinned-type/20250510-173533
base: 9de1a293c8ece00d226b21a35751ec178be2a9fa
patch link: https://lore.kernel.org/r/20250510-rust_unsafe_pinned-v3-1-57ce151123f9%40gmail.com
patch subject: [PATCH v3 1/3] rust: add UnsafePinned type
config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20250511/202505112005.CDR6Xi0o-lkp@intel.com/config)
compiler: clang version 18.1.8 (https://github.com/llvm/llvm-project 3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff)
rustc: rustc 1.78.0 (9b00956e5 2024-04-29)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250511/202505112005.CDR6Xi0o-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202505112005.CDR6Xi0o-lkp@intel.com/
All errors (new ones prefixed by >>):
>> error[E0599]: no method named `get_mut_unchecked` found for struct `UnsafePinned` in the current scope
--> rust/doctests_kernel_generated.rs:7770:7
|
7770 | x.get_mut_unchecked().write(1);
| ^^^^^^^^^^^^^^^^^ method not found in `UnsafePinned<{integer}>`
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v3 2/3] rust: implement `Wrapper<T>` for `Opaque<T>`
2025-05-10 9:32 [PATCH v3 0/3] rust: add `UnsafePinned` type Christian Schrefl
2025-05-10 9:32 ` [PATCH v3 1/3] rust: add UnsafePinned type Christian Schrefl
@ 2025-05-10 9:32 ` Christian Schrefl
2025-05-10 9:32 ` [PATCH v3 3/3] rust: use `UnsafePinned` in the implementation of `Opaque` Christian Schrefl
2 siblings, 0 replies; 5+ messages in thread
From: Christian Schrefl @ 2025-05-10 9:32 UTC (permalink / raw)
To: Sky, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, Danilo Krummrich, Gerald Wisböck,
Nathan Chancellor, Nick Desaulniers, Bill Wendling, Justin Stitt
Cc: linux-kernel, rust-for-linux, llvm, Christian Schrefl,
Benno Lossin
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.
This allows to declare functions that are generic over `Wrapper`
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 705f420fdfbc4a576de1c4546578f2f04cdf615e..f06e8720e012102e5c41e79fd97b0607e927d71c 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.
///
@@ -332,17 +332,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
@@ -393,6 +382,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; the call is infallible,
+ // - `slot` is pinned in memory.
+ unsafe { PinInit::<T, E>::__pinned_init(slot, ptr) }
+ })
+ }
+}
/// Types that are _always_ reference counted.
///
--
2.49.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH v3 3/3] rust: use `UnsafePinned` in the implementation of `Opaque`
2025-05-10 9:32 [PATCH v3 0/3] rust: add `UnsafePinned` type Christian Schrefl
2025-05-10 9:32 ` [PATCH v3 1/3] rust: add UnsafePinned type Christian Schrefl
2025-05-10 9:32 ` [PATCH v3 2/3] rust: implement `Wrapper<T>` for `Opaque<T>` Christian Schrefl
@ 2025-05-10 9:32 ` Christian Schrefl
2 siblings, 0 replies; 5+ messages in thread
From: Christian Schrefl @ 2025-05-10 9:32 UTC (permalink / raw)
To: Sky, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, Danilo Krummrich, Gerald Wisböck,
Nathan Chancellor, Nick Desaulniers, Bill Wendling, Justin Stitt
Cc: linux-kernel, rust-for-linux, llvm, Christian Schrefl,
Benno Lossin
Make the semantics of the `Opaque` implementation clearer and prepare
for the switch to the upstream rust `UnsafePinned` type in the future.
`Opaque` still uses `UnsafeCell` even though the kernel implementation
of `UnsafePinned` already includes it, since the current upstream
version does not.
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/types.rs | 32 +++++++++++++++-----------------
1 file changed, 15 insertions(+), 17 deletions(-)
diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs
index f06e8720e012102e5c41e79fd97b0607e927d71c..e32905c42453132fbea49d37a6457547d42465ce 100644
--- a/rust/kernel/types.rs
+++ b/rust/kernel/types.rs
@@ -4,12 +4,12 @@
use core::{
cell::UnsafeCell,
- marker::{PhantomData, PhantomPinned},
+ marker::PhantomData,
mem::{ManuallyDrop, MaybeUninit},
ops::{Deref, DerefMut},
ptr::NonNull,
};
-use pin_init::{PinInit, Wrapper, Zeroable};
+use pin_init::{cast_pin_init, PinInit, Wrapper, Zeroable};
/// Used to transfer ownership to and from foreign (non-Rust) languages.
///
@@ -308,8 +308,10 @@ fn drop(&mut self) {
/// ```
#[repr(transparent)]
pub struct Opaque<T> {
- value: UnsafeCell<MaybeUninit<T>>,
- _pin: PhantomPinned,
+ // The kernel implementation of `UnsafePinned` uses `UnsafeCell` internally, but the
+ // upstream rust `UnsafePinned` will not. So to make sure this is compatible with
+ // the upstream version use `UnsafeCell` here.
+ value: UnsafePinned<UnsafeCell<MaybeUninit<T>>>,
}
// SAFETY: `Opaque<T>` allows the inner value to be any bit pattern, including all zeros.
@@ -319,16 +321,14 @@ impl<T> Opaque<T> {
/// Creates a new opaque value.
pub const fn new(value: T) -> Self {
Self {
- value: UnsafeCell::new(MaybeUninit::new(value)),
- _pin: PhantomPinned,
+ value: UnsafePinned::new(UnsafeCell::new(MaybeUninit::new(value))),
}
}
/// Creates an uninitialised value.
pub const fn uninit() -> Self {
Self {
- value: UnsafeCell::new(MaybeUninit::uninit()),
- _pin: PhantomPinned,
+ value: UnsafePinned::new(UnsafeCell::new(MaybeUninit::uninit())),
}
}
@@ -371,7 +371,7 @@ pub fn try_ffi_init<E>(
/// Returns a raw pointer to the opaque data.
pub const fn get(&self) -> *mut T {
- UnsafeCell::get(&self.value).cast::<T>()
+ UnsafeCell::raw_get(self.value.get()).cast::<T>()
}
/// Gets the value behind `this`.
@@ -384,14 +384,12 @@ 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; the call is infallible,
- // - `slot` is pinned in memory.
- unsafe { PinInit::<T, E>::__pinned_init(slot, ptr) }
- })
+ fn pin_init<E>(value_init: impl PinInit<T, E>) -> impl PinInit<Self, E> {
+ let value_init =
+ UnsafePinned::pin_init(UnsafeCell::pin_init(MaybeUninit::pin_init(value_init)));
+ // SAFETY: `Opaque<T>` is a `repr(transparent)` wrapper around
+ // `UnsafePinned<UnsafeCell<MabeUninit<T>>>` so the memory representation is compatible.
+ unsafe { cast_pin_init(value_init) }
}
}
--
2.49.0
^ permalink raw reply related [flat|nested] 5+ messages in thread