Commit fde578c8 authored by Danilo Krummrich's avatar Danilo Krummrich
Browse files

rust: alloc: replace aligned_size() with Kmalloc::aligned_layout() 



aligned_size() dates back to when Rust did support kmalloc() only, but
is now used in ReallocFunc::call() and hence for all allocators.

However, the additional padding applied by aligned_size() is only
required by the kmalloc() allocator backend.

Hence, replace aligned_size() with Kmalloc::aligned_layout() and use it
for the affected allocators, i.e. kmalloc() and kvmalloc(), only.

While at it, make Kmalloc::aligned_layout() public, such that Rust
abstractions, which have to call subsystem specific kmalloc() based
allocation primitives directly, can make use of it.

Fixes: 8a799831 ("rust: alloc: implement `ReallocFunc`")
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20250731154919.4132-2-dakr@kernel.org


[ Remove `const` from Kmalloc::aligned_layout(). - Danilo ]
Signed-off-by: default avatarDanilo Krummrich <dakr@kernel.org>
parent f87d597e

rust/kernel/alloc/allocator.rs

+18 −12
Original line number Diff line number Diff line
@@ -43,17 +43,6 @@ 
/// For more details see [self].

pub struct KVmalloc;



/// Returns a proper size to alloc a new object aligned to `new_layout`'s alignment.

fn aligned_size(new_layout: Layout) -> usize {

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

    let layout = new_layout.pad_to_align();



    // Note that `layout.size()` (after padding) is guaranteed to be a multiple of `layout.align()`

    // which together with the slab guarantees means the `krealloc` will return a properly aligned

    // object (see comments in `kmalloc()` for more information).

    layout.size()

}



/// # Invariants

///

/// One of the following: `krealloc`, `vrealloc`, `kvrealloc`.
@@ -88,7 +77,7 @@ unsafe fn call( 
        old_layout: Layout,

        flags: Flags,

    ) -> Result<NonNull<[u8]>, AllocError> {

        let size = aligned_size(layout);

        let size = layout.size();

        let ptr = match ptr {

            Some(ptr) => {

                if old_layout.size() == 0 {
@@ -123,6 +112,17 @@ unsafe fn call( 
    }

}



impl Kmalloc {

    /// Returns a [`Layout`] that makes [`Kmalloc`] fulfill the requested size and alignment of

    /// `layout`.

    pub fn aligned_layout(layout: Layout) -> Layout {

        // Note that `layout.size()` (after padding) is guaranteed to be a multiple of

        // `layout.align()` which together with the slab guarantees means that `Kmalloc` will return

        // a properly aligned object (see comments in `kmalloc()` for more information).

        layout.pad_to_align()

    }

}



// SAFETY: `realloc` delegates to `ReallocFunc::call`, which guarantees that

// - memory remains valid until it is explicitly freed,

// - passing a pointer to a valid memory allocation is OK,
@@ -135,6 +135,8 @@ unsafe fn realloc( 
        old_layout: Layout,

        flags: Flags,

    ) -> Result<NonNull<[u8]>, AllocError> {

        let layout = Kmalloc::aligned_layout(layout);



        // SAFETY: `ReallocFunc::call` has the same safety requirements as `Allocator::realloc`.

        unsafe { ReallocFunc::KREALLOC.call(ptr, layout, old_layout, flags) }

    }
@@ -176,6 +178,10 @@ unsafe fn realloc( 
        old_layout: Layout,

        flags: Flags,

    ) -> Result<NonNull<[u8]>, AllocError> {

        // `KVmalloc` may use the `Kmalloc` backend, hence we have to enforce a `Kmalloc`

        // compatible layout.

        let layout = Kmalloc::aligned_layout(layout);



        // TODO: Support alignments larger than PAGE_SIZE.

        if layout.align() > bindings::PAGE_SIZE {

            pr_warn!("KVmalloc does not support alignments larger than PAGE_SIZE yet.\n");