Commit 2009a2d5 authored by Alexandre Courbot's avatar Alexandre Courbot Committed by Miguel Ojeda
Browse files

rust: sync: implement `Borrow` and `BorrowMut` for `Arc` types 



Implement `Borrow<T>` and `BorrowMut<T>` for `UniqueArc<T>`, and
`Borrow<T>` for `Arc<T>`. This allows these containers to be used in
generic APIs asking for types implementing those traits. `T` and `&mut
T` also implement those traits allowing users to use either owned,
shared or borrowed values.

`ForeignOwnable` makes a call to its own `borrow` method which must be
disambiguated.

Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarBenno Lossin <lossin@kernel.org>
Signed-off-by: default avatarAlexandre Courbot <acourbot@nvidia.com>
Link: https://lore.kernel.org/r/20250616-borrow_impls-v4-2-36f9beb3fe6a@nvidia.com


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

rust/kernel/sync/arc.rs

+77 −1
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
};

use core::{

    alloc::Layout,

    borrow::{Borrow, BorrowMut},

    fmt,

    marker::PhantomData,

    mem::{ManuallyDrop, MaybeUninit},
@@ -406,7 +407,7 @@ unsafe fn borrow<'a>(ptr: *mut Self::PointedTo) -> ArcBorrow<'a, T> { 
    unsafe fn borrow_mut<'a>(ptr: *mut Self::PointedTo) -> ArcBorrow<'a, T> {

        // SAFETY: The safety requirements for `borrow_mut` are a superset of the safety

        // requirements for `borrow`.

        unsafe { Self::borrow(ptr) }

        unsafe { <Self as ForeignOwnable>::borrow(ptr) }

    }

}
@@ -426,6 +427,31 @@ fn as_ref(&self) -> &T { 
    }

}



/// # Examples

///

/// ```

/// # use core::borrow::Borrow;

/// # use kernel::sync::Arc;

/// struct Foo<B: Borrow<u32>>(B);

///

/// // Owned instance.

/// let owned = Foo(1);

///

/// // Shared instance.

/// let arc = Arc::new(1, GFP_KERNEL)?;

/// let shared = Foo(arc.clone());

///

/// let i = 1;

/// // Borrowed from `i`.

/// let borrowed = Foo(&i);

/// # Ok::<(), Error>(())

/// ```

impl<T: ?Sized> Borrow<T> for Arc<T> {

    fn borrow(&self) -> &T {

        self.deref()

    }

}



impl<T: ?Sized> Clone for Arc<T> {

    fn clone(&self) -> Self {

        // SAFETY: By the type invariant, there is necessarily a reference to the object, so it is
@@ -834,6 +860,56 @@ fn deref_mut(&mut self) -> &mut Self::Target { 
    }

}



/// # Examples

///

/// ```

/// # use core::borrow::Borrow;

/// # use kernel::sync::UniqueArc;

/// struct Foo<B: Borrow<u32>>(B);

///

/// // Owned instance.

/// let owned = Foo(1);

///

/// // Owned instance using `UniqueArc`.

/// let arc = UniqueArc::new(1, GFP_KERNEL)?;

/// let shared = Foo(arc);

///

/// let i = 1;

/// // Borrowed from `i`.

/// let borrowed = Foo(&i);

/// # Ok::<(), Error>(())

/// ```

impl<T: ?Sized> Borrow<T> for UniqueArc<T> {

    fn borrow(&self) -> &T {

        self.deref()

    }

}



/// # Examples

///

/// ```

/// # use core::borrow::BorrowMut;

/// # use kernel::sync::UniqueArc;

/// struct Foo<B: BorrowMut<u32>>(B);

///

/// // Owned instance.

/// let owned = Foo(1);

///

/// // Owned instance using `UniqueArc`.

/// let arc = UniqueArc::new(1, GFP_KERNEL)?;

/// let shared = Foo(arc);

///

/// let mut i = 1;

/// // Borrowed from `i`.

/// let borrowed = Foo(&mut i);

/// # Ok::<(), Error>(())

/// ```

impl<T: ?Sized> BorrowMut<T> for UniqueArc<T> {

    fn borrow_mut(&mut self) -> &mut T {

        self.deref_mut()

    }

}



impl<T: fmt::Display + ?Sized> fmt::Display for UniqueArc<T> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        fmt::Display::fmt(self.deref(), f)