On Wed Feb 4, 2026 at 11:56 AM GMT, Andreas Hindborg wrote: > From: Asahi Lina <[email protected]> > > By analogy to `AlwaysRefCounted` and `ARef`, an `Ownable` type is a > (typically C FFI) type that *may* be owned by Rust, but need not be. Unlike > `AlwaysRefCounted`, this mechanism expects the reference to be unique > within Rust, and does not allow cloning. > > Conceptually, this is similar to a `KBox<T>`, except that it delegates > resource management to the `T` instead of using a generic allocator. > > This change is a derived work based on work by Asahi Lina > <[email protected]> [1] and Oliver Mangold <[email protected]>. > > Link: > https://lore.kernel.org/rust-for-linux/[email protected]/ > [1] > Signed-off-by: Andreas Hindborg <[email protected]> > --- > rust/kernel/lib.rs | 1 + > rust/kernel/owned.rs | 196 > +++++++++++++++++++++++++++++++++++++++++++++++ > rust/kernel/sync/aref.rs | 5 ++ > rust/kernel/types.rs | 11 ++- > 4 files changed, 212 insertions(+), 1 deletion(-) > > diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs > index f812cf1200428..96a3fadc3377a 100644 > --- a/rust/kernel/lib.rs > +++ b/rust/kernel/lib.rs > @@ -119,6 +119,7 @@ > pub mod of; > #[cfg(CONFIG_PM_OPP)] > pub mod opp; > +pub mod owned; > pub mod page; > #[cfg(CONFIG_PCI)] > pub mod pci; > diff --git a/rust/kernel/owned.rs b/rust/kernel/owned.rs > new file mode 100644 > index 0000000000000..fe30580331df9 > --- /dev/null > +++ b/rust/kernel/owned.rs > <snip> > + > + /// Get a pinned mutable reference to the data owned by this `Owned<T>`. > + pub fn get_pin_mut(&mut self) -> Pin<&mut T> { > + // SAFETY: The type invariants guarantee that the object is valid, > and that we can safely > + // return a mutable reference to it. > + let unpinned = unsafe { self.ptr.as_mut() }; > + > + // SAFETY: We never hand out unpinned mutable references to the data > in > + // `Self`, unless the contained type is `Unpin`. > + unsafe { Pin::new_unchecked(unpinned) } > + }
Probably should be name `as_pin_mut` instead. With name changed and SOB fixed: Reviewed-by: Gary Guo <[email protected]> Best, Gary > +} > + > +// SAFETY: It is safe to send an [`Owned<T>`] to another thread when the > underlying `T` is [`Send`], > +// because of the ownership invariant. Sending an [`Owned<T>`] is equivalent > to sending the `T`. > +unsafe impl<T: Ownable + Send> Send for Owned<T> {} > + > +// SAFETY: It is safe to send [`&Owned<T>`] to another thread when the > underlying `T` is [`Sync`], > +// because of the ownership invariant. Sending an [`&Owned<T>`] is > equivalent to sending the `&T`. > +unsafe impl<T: Ownable + Sync> Sync for Owned<T> {} > +
