Commit f86c0036 authored by Alexandre Courbot's avatar Alexandre Courbot Committed by Danilo Krummrich
Browse files

rust: alloc: implement `Borrow` and `BorrowMut` for `KBox` 



Implement `Borrow<T>` and `BorrowMut<T>` for `KBox<T>`. This allows
`KBox<T>` 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, borrowed and heap-owned values.

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-3-36f9beb3fe6a@nvidia.com


Signed-off-by: default avatarDanilo Krummrich <dakr@kernel.org>
parent c09a8ac1

rust/kernel/alloc/kbox.rs

+57 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
use super::allocator::{KVmalloc, Kmalloc, Vmalloc};

use super::{AllocError, Allocator, Flags};

use core::alloc::Layout;

use core::borrow::{Borrow, BorrowMut};

use core::fmt;

use core::marker::PhantomData;

use core::mem::ManuallyDrop;
@@ -499,6 +500,62 @@ fn deref_mut(&mut self) -> &mut T { 
    }

}



/// # Examples

///

/// ```

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

/// # use kernel::alloc::KBox;

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

///

/// // Owned instance.

/// let owned = Foo(1);

///

/// // Owned instance using `KBox`.

/// let owned_kbox = Foo(KBox::new(1, GFP_KERNEL)?);

///

/// let i = 1;

/// // Borrowed from `i`.

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

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

/// ```

impl<T, A> Borrow<T> for Box<T, A>

where

    T: ?Sized,

    A: Allocator,

{

    fn borrow(&self) -> &T {

        self.deref()

    }

}



/// # Examples

///

/// ```

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

/// # use kernel::alloc::KBox;

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

///

/// // Owned instance.

/// let owned = Foo(1);

///

/// // Owned instance using `KBox`.

/// let owned_kbox = Foo(KBox::new(1, GFP_KERNEL)?);

///

/// let mut i = 1;

/// // Borrowed from `i`.

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

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

/// ```

impl<T, A> BorrowMut<T> for Box<T, A>

where

    T: ?Sized,

    A: Allocator,

{

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

        self.deref_mut()

    }

}



impl<T, A> fmt::Display for Box<T, A>

where

    T: ?Sized + fmt::Display,