by Wedson Almeida Filho

[permalink] [raw]

Subject: Re: [PATCH 09/10] rust: init: update `init` module to take allocation flags

On Tue, 26 Mar 2024 at 11:08, Benno Lossin <[email protected]> wrote:
>
> On 25.03.24 20:54, Wedson Almeida Filho wrote:
> > From: Wedson Almeida Filho <[email protected]>
> >
> > This is the last component in the conversion for allocators to take
> > allocation flags as parameters.
> >
> > Signed-off-by: Wedson Almeida Filho <[email protected]>
> > ---
> > rust/kernel/init.rs | 49 ++++++++++++++++---------------
> > rust/kernel/sync/arc.rs | 17 ++++++-----
> > rust/kernel/sync/condvar.rs | 2 +-
> > rust/kernel/sync/lock/mutex.rs | 2 +-
> > rust/kernel/sync/lock/spinlock.rs | 2 +-
> > rust/kernel/workqueue.rs | 13 +++++---
> > 6 files changed, 47 insertions(+), 38 deletions(-)
>
> One formatting issue below, with that fixed:
>
> Reviewed-by: Benno Lossin <[email protected]>
>
> > diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
> > index 077200f5350b..af539c5eb4bc 100644
> > --- a/rust/kernel/sync/arc.rs
> > +++ b/rust/kernel/sync/arc.rs
> > @@ -565,13 +565,16 @@ pub fn new(value: T, flags: Flags) -> Result<Self, AllocError> {
> > }
> >
> > /// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet.
> > - pub fn new_uninit(_flags: Flags) -> Result<UniqueArc<MaybeUninit<T>>, AllocError> {
> > + pub fn new_uninit(flags: Flags) -> Result<UniqueArc<MaybeUninit<T>>, AllocError> {
> > // INVARIANT: The refcount is initialised to a non-zero value.
> > - let inner = Box::try_init::<AllocError>(try_init!(ArcInner {
> > + let inner = Box::try_init::<AllocError>(
> > + try_init!(ArcInner {
> > // SAFETY: There are no safety requirements for this FFI call.
> > refcount: Opaque::new(unsafe { bindings::REFCOUNT_INIT(1) }),
> > data <- init::uninit::<T, AllocError>(),
> > - }? AllocError))?;
> > + }? AllocError),
> > + flags,
> > + )?;
>
> The indentation looks wrong, rustfmt sadly cannot handle the pin-init
> macros. This looks better to me:
>
> let inner = Box::try_init::<AllocError>(
> try_init!(ArcInner {
> // SAFETY: There are no safety requirements for this FFI call.
> refcount: Opaque::new(unsafe { bindings::REFCOUNT_INIT(1) }),
> data <- init::uninit::<T, AllocError>(),
> }? AllocError),
> flags,
> )?;

I remember trying to rearrange this and `rustfmtcheck` not liking it
but it seems to be happy with your suggestion.

Applying it in v2.

> --
> Cheers,
> Benno
>
> > Ok(UniqueArc {
> > // INVARIANT: The newly-created object has a refcount of 1.
> > // SAFETY: The pointer from the `Box` is valid.

2024-03-25 22:39:27

by Benno Lossin

[permalink] [raw]

Subject: Re: [PATCH 06/10] rust: alloc: introduce the `BoxExt` trait

On 25.03.24 20:54, Wedson Almeida Filho wrote:
> From: Wedson Almeida Filho <[email protected]>
>
> 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: Wedson Almeida Filho <[email protected]>
> ---
> rust/kernel/alloc.rs | 1 +
> rust/kernel/alloc/allocator.rs | 6 +++-
> rust/kernel/alloc/boxext.rs | 61 ++++++++++++++++++++++++++++++++++
> rust/kernel/init.rs | 13 ++++----
> rust/kernel/prelude.rs | 2 +-
> rust/kernel/sync/arc.rs | 3 +-
> 6 files changed, 77 insertions(+), 9 deletions(-)
> create mode 100644 rust/kernel/alloc/boxext.rs
>
> diff --git a/rust/kernel/alloc.rs b/rust/kernel/alloc.rs
> index ad48ac8dc13d..5712c81b1308 100644
> --- a/rust/kernel/alloc.rs
> +++ b/rust/kernel/alloc.rs
> @@ -5,6 +5,7 @@
> #[cfg(not(test))]
> #[cfg(not(testlib))]
> mod allocator;
> +pub mod boxext;
> pub mod vecext;
>
> /// Flags to be used when allocating memory.
> diff --git a/rust/kernel/alloc/allocator.rs b/rust/kernel/alloc/allocatorrs
> index 01ad139e19bc..fc0439455faa 100644
> --- a/rust/kernel/alloc/allocator.rs
> +++ b/rust/kernel/alloc/allocator.rs
> @@ -15,7 +15,11 @@
> ///
> /// - `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: bindings::gfp_t) -> *mut u8 {
> +pub(crate) unsafe fn krealloc_aligned(
> + ptr: *mut u8,
> + new_layout: Layout,
> + flags: bindings::gfp_t,
> +) -> *mut u8 {
> // Customized layouts from `Layout::from_size_align()` can have size < align, so pad first.
> let layout = new_layout.pad_to_align();
>
> diff --git a/rust/kernel/alloc/boxext.rs b/rust/kernel/alloc/boxext.rs
> new file mode 100644
> index 000000000000..26a918df7acf
> --- /dev/null
> +++ b/rust/kernel/alloc/boxext.rs
> @@ -0,0 +1,61 @@
> +// 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> {
> + #[cfg(any(test, testlib))]
> + fn new(x: T, _flags: Flags) -> Result<Self, AllocError> {
> + Ok(Box::new(x))
> + }

When running under `cfg(test)`, are we using the normal standard
library? Or why is this needed?

> +
> + #[cfg(not(any(test, testlib)))]
> + fn new(x: T, flags: Flags) -> Result<Self, AllocError> {
> + let ptr = if core::mem::size_of::<T>() == 0 {
> + core::ptr::NonNull::<T>::dangling().as_ptr()
> + } else {
> + let layout = core::alloc::Layout::new::<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.

The `krealloc_aligned` function states:

/// # Safety
///
/// - `ptr` can be either null or a pointer which has been allocated by this allocator.
/// - `new_layout` must have a non-zero size.

So it should also mention that you checked for `layout.size() > 0`
above.

> + let ptr = unsafe {
> + super::allocator::krealloc_aligned(core::ptr::null_mut(), layout, flags.0)
> + };
> + if ptr.is_null() {
> + return Err(AllocError);
> + }
> +
> + let ptr = ptr.cast::<T>();
> +
> + // SAFETY: We just allocated the memory above, it is valid for write.
> + unsafe { ptr.write(x) };
> + ptr
> + };
> +
> + // 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) })
> + }
> +
> + fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError> {
> + <Box<_> as BoxExt<_>>::new(MaybeUninit::<T>::uninit(), flags)

Why do you use the extended syntax? I tried to use `Box::new` and it
compiled.

--
Cheers,
Benno