Commit 08d3f549 authored by Wedson Almeida Filho's avatar Wedson Almeida Filho Committed by Miguel Ojeda
Browse files

rust: alloc: introduce the `BoxExt` trait 



Make fallible versions of `new` and `new_uninit` methods available in
`Box` even though it doesn't implement them because we build `alloc`
with the `no_global_oom_handling` config.

They also have an extra `flags` parameter that allows callers to pass
flags to the allocator.

Signed-off-by: default avatarWedson Almeida Filho <walmeida@microsoft.com>
Reviewed-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Link: https://lore.kernel.org/r/20240328013603.206764-7-wedsonaf@gmail.com


[ Used `Box::write()` to avoid one `unsafe` block as suggested by Boqun. ]
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent b6a006e2

rust/kernel/alloc.rs

+1 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#[cfg(not(test))]

#[cfg(not(testlib))]

mod allocator;

pub mod box_ext;

pub mod vec_ext;



/// Flags to be used when allocating memory.

rust/kernel/alloc/allocator.rs

+1 −1
Original line number Diff line number Diff line
@@ -16,7 +16,7 @@ 
///

/// - `ptr` can be either null or a pointer which has been allocated by this allocator.

/// - `new_layout` must have a non-zero size.

unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: Flags) -> *mut u8 {

pub(crate) unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: Flags) -> *mut u8 {

    // Customized layouts from `Layout::from_size_align()` can have size < align, so pad first.

    let layout = new_layout.pad_to_align();

rust/kernel/alloc/box_ext.rs

0 → 100644
+58 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



//! Extensions to [`Box`] for fallible allocations.



use super::Flags;

use alloc::boxed::Box;

use core::alloc::AllocError;

use core::mem::MaybeUninit;

use core::result::Result;



/// Extensions to [`Box`].

pub trait BoxExt<T>: Sized {

    /// Allocates a new box.

    ///

    /// The allocation may fail, in which case an error is returned.

    fn new(x: T, flags: Flags) -> Result<Self, AllocError>;



    /// Allocates a new uninitialised box.

    ///

    /// The allocation may fail, in which case an error is returned.

    fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError>;

}



impl<T> BoxExt<T> for Box<T> {

    fn new(x: T, flags: Flags) -> Result<Self, AllocError> {

        let b = <Self as BoxExt<_>>::new_uninit(flags)?;

        Ok(Box::write(b, x))

    }



    #[cfg(any(test, testlib))]

    fn new_uninit(_flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError> {

        Ok(Box::new_uninit())

    }



    #[cfg(not(any(test, testlib)))]

    fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError> {

        let ptr = if core::mem::size_of::<MaybeUninit<T>>() == 0 {

            core::ptr::NonNull::<_>::dangling().as_ptr()

        } else {

            let layout = core::alloc::Layout::new::<MaybeUninit<T>>();



            // SAFETY: Memory is being allocated (first arg is null). The only other source of

            // safety issues is sleeping on atomic context, which is addressed by klint. Lastly,

            // the type is not a SZT (checked above).

            let ptr =

                unsafe { super::allocator::krealloc_aligned(core::ptr::null_mut(), layout, flags) };

            if ptr.is_null() {

                return Err(AllocError);

            }



            ptr.cast::<MaybeUninit<T>>()

        };



        // SAFETY: For non-zero-sized types, we allocate above using the global allocator. For

        // zero-sized types, we use `NonNull::dangling`.

        Ok(unsafe { Box::from_raw(ptr) })

    }

}

rust/kernel/init.rs

+7 −6
Original line number Diff line number Diff line
@@ -210,6 +210,7 @@ 
//! [`pin_init!`]: crate::pin_init!



use crate::{

    alloc::{box_ext::BoxExt, flags::*},

    error::{self, Error},

    sync::UniqueArc,

    types::{Opaque, ScopeGuard},
@@ -305,9 +306,9 @@ macro_rules! stack_pin_init { 
///

/// stack_try_pin_init!(let foo: Result<Pin<&mut Foo>, AllocError> = pin_init!(Foo {

///     a <- new_mutex!(42),

///     b: Box::try_new(Bar {

///     b: Box::new(Bar {

///         x: 64,

///     })?,

///     }, GFP_KERNEL)?,

/// }));

/// let foo = foo.unwrap();

/// pr_info!("a: {}", &*foo.a.lock());
@@ -331,9 +332,9 @@ macro_rules! stack_pin_init { 
///

/// stack_try_pin_init!(let foo: Pin<&mut Foo> =? pin_init!(Foo {

///     a <- new_mutex!(42),

///     b: Box::try_new(Bar {

///     b: Box::new(Bar {

///         x: 64,

///     })?,

///     }, GFP_KERNEL)?,

/// }));

/// pr_info!("a: {}", &*foo.a.lock());

/// # Ok::<_, AllocError>(())
@@ -1158,7 +1159,7 @@ fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E> 
    where

        E: From<AllocError>,

    {

        let mut this = Box::try_new_uninit()?;

        let mut this = <Box<_> as BoxExt<_>>::new_uninit(GFP_KERNEL)?;

        let slot = this.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid and will not be moved, because we pin it later.
@@ -1172,7 +1173,7 @@ fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E> 
    where

        E: From<AllocError>,

    {

        let mut this = Box::try_new_uninit()?;

        let mut this = <Box<_> as BoxExt<_>>::new_uninit(GFP_KERNEL)?;

        let slot = this.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid.

rust/kernel/prelude.rs

+1 −1
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
#[doc(no_inline)]

pub use core::pin::Pin;



pub use crate::alloc::{flags::*, vec_ext::VecExt};

pub use crate::alloc::{box_ext::BoxExt, flags::*, vec_ext::VecExt};



#[doc(no_inline)]

pub use alloc::{boxed::Box, vec::Vec};