Commit 51f6af86 authored by Alice Ryhl's avatar Alice Ryhl Committed by Miguel Ojeda
Browse files

rust: sync: add `ArcBorrow::from_raw` 



Allows access to a value in an `Arc` that is currently held as a raw
pointer due to use of `Arc::into_raw`, without destroying or otherwise
consuming that raw pointer.

This is a dependency of the linked list that Rust Binder uses. The
linked list uses this method when iterating over the linked list [1].

Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Link: https://lore.kernel.org/r/20240402-linked-list-v1-6-b1c59ba7ae3b@google.com

 [1]
Signed-off-by: default avatarAlice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20240402-arc-for-list-v4-1-54db6440a9a9@google.com


Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent be2ca1e0

rust/kernel/sync/arc.rs

+58 −18
Original line number Diff line number Diff line
@@ -138,6 +138,39 @@ struct ArcInner<T: ?Sized> { 
    data: T,

}



impl<T: ?Sized> ArcInner<T> {

    /// Converts a pointer to the contents of an [`Arc`] into a pointer to the [`ArcInner`].

    ///

    /// # Safety

    ///

    /// `ptr` must have been returned by a previous call to [`Arc::into_raw`], and the `Arc` must

    /// not yet have been destroyed.

    unsafe fn container_of(ptr: *const T) -> NonNull<ArcInner<T>> {

        let refcount_layout = Layout::new::<bindings::refcount_t>();

        // SAFETY: The caller guarantees that the pointer is valid.

        let val_layout = Layout::for_value(unsafe { &*ptr });

        // SAFETY: We're computing the layout of a real struct that existed when compiling this

        // binary, so its layout is not so large that it can trigger arithmetic overflow.

        let val_offset = unsafe { refcount_layout.extend(val_layout).unwrap_unchecked().1 };



        // Pointer casts leave the metadata unchanged. This is okay because the metadata of `T` and

        // `ArcInner<T>` is the same since `ArcInner` is a struct with `T` as its last field.

        //

        // This is documented at:

        // <https://doc.rust-lang.org/std/ptr/trait.Pointee.html>.

        let ptr = ptr as *const ArcInner<T>;



        // SAFETY: The pointer is in-bounds of an allocation both before and after offsetting the

        // pointer, since it originates from a previous call to `Arc::into_raw` on an `Arc` that is

        // still valid.

        let ptr = unsafe { ptr.byte_sub(val_offset) };



        // SAFETY: The pointer can't be null since you can't have an `ArcInner<T>` value at the null

        // address.

        unsafe { NonNull::new_unchecked(ptr.cast_mut()) }

    }

}



// This is to allow [`Arc`] (and variants) to be used as the type of `self`.

impl<T: ?Sized> core::ops::Receiver for Arc<T> {}
@@ -233,27 +266,13 @@ pub fn into_raw(self) -> *const T { 
    /// `ptr` must have been returned by a previous call to [`Arc::into_raw`]. Additionally, it

    /// must not be called more than once for each previous call to [`Arc::into_raw`].

    pub unsafe fn from_raw(ptr: *const T) -> Self {

        let refcount_layout = Layout::new::<bindings::refcount_t>();

        // SAFETY: The caller guarantees that the pointer is valid.

        let val_layout = Layout::for_value(unsafe { &*ptr });

        // SAFETY: We're computing the layout of a real struct that existed when compiling this

        // binary, so its layout is not so large that it can trigger arithmetic overflow.

        let val_offset = unsafe { refcount_layout.extend(val_layout).unwrap_unchecked().1 };



        // Pointer casts leave the metadata unchanged. This is okay because the metadata of `T` and

        // `ArcInner<T>` is the same since `ArcInner` is a struct with `T` as its last field.

        //

        // This is documented at:

        // <https://doc.rust-lang.org/std/ptr/trait.Pointee.html>.

        let ptr = ptr as *const ArcInner<T>;



        // SAFETY: The pointer is in-bounds of an allocation both before and after offsetting the

        // pointer, since it originates from a previous call to `Arc::into_raw` and is still valid.

        let ptr = unsafe { ptr.byte_sub(val_offset) };

        // SAFETY: The caller promises that this pointer originates from a call to `into_raw` on an

        // `Arc` that is still valid.

        let ptr = unsafe { ArcInner::container_of(ptr) };



        // SAFETY: By the safety requirements we know that `ptr` came from `Arc::into_raw`, so the

        // reference count held then will be owned by the new `Arc` object.

        unsafe { Self::from_inner(NonNull::new_unchecked(ptr.cast_mut())) }

        unsafe { Self::from_inner(ptr) }

    }



    /// Returns an [`ArcBorrow`] from the given [`Arc`].
@@ -454,6 +473,27 @@ unsafe fn new(inner: NonNull<ArcInner<T>>) -> Self { 
            _p: PhantomData,

        }

    }



    /// Creates an [`ArcBorrow`] to an [`Arc`] that has previously been deconstructed with

    /// [`Arc::into_raw`].

    ///

    /// # Safety

    ///

    /// * The provided pointer must originate from a call to [`Arc::into_raw`].

    /// * For the duration of the lifetime annotated on this `ArcBorrow`, the reference count must

    ///   not hit zero.

    /// * For the duration of the lifetime annotated on this `ArcBorrow`, there must not be a

    ///   [`UniqueArc`] reference to this value.

    pub unsafe fn from_raw(ptr: *const T) -> Self {

        // SAFETY: The caller promises that this pointer originates from a call to `into_raw` on an

        // `Arc` that is still valid.

        let ptr = unsafe { ArcInner::container_of(ptr) };



        // SAFETY: The caller promises that the value remains valid since the reference count must

        // not hit zero, and no mutable reference will be created since that would involve a

        // `UniqueArc`.

        unsafe { Self::new(ptr) }

    }

}



impl<T: ?Sized> From<ArcBorrow<'_, T>> for Arc<T> {