Commit 8362c260 authored by Danilo Krummrich's avatar Danilo Krummrich Committed by Miguel Ojeda
Browse files

rust: alloc: implement `KVmalloc` allocator 



Implement `Allocator` for `KVmalloc`, an `Allocator` that tries to
allocate memory with `kmalloc` first and, on failure, falls back to
`vmalloc`.

All memory allocations made with `KVmalloc` end up in
`kvrealloc_noprof()`; all frees in `kvfree()`.

Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarGary Guo <gary@garyguo.net>
Signed-off-by: default avatarDanilo Krummrich <dakr@kernel.org>
Link: https://lore.kernel.org/r/20241004154149.93856-10-dakr@kernel.org


[ Reworded typo. - Miguel ]
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 61c00478

rust/helpers/slab.c

+6 −0
Original line number Diff line number Diff line
@@ -7,3 +7,9 @@ rust_helper_krealloc(const void *objp, size_t new_size, gfp_t flags) 
{

	return krealloc(objp, new_size, flags);

}



void * __must_check __realloc_size(2)

rust_helper_kvrealloc(const void *p, size_t size, gfp_t flags)

{

	return kvrealloc(p, size, flags);

}

rust/kernel/alloc/allocator.rs

+36 −0
Original line number Diff line number Diff line
@@ -34,6 +34,15 @@ 
/// For more details see [self].

pub struct Vmalloc;



/// The kvmalloc kernel allocator.

///

/// `KVmalloc` attempts to allocate memory with `Kmalloc` first, but falls back to `Vmalloc` upon

/// failure. This allocator is typically used when the size for the requested allocation is not

/// known and may exceed the capabilities of `Kmalloc`.

///

/// 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.
@@ -76,6 +85,9 @@ impl ReallocFunc { 
    // INVARIANT: `vrealloc` satisfies the type invariants.

    const VREALLOC: Self = Self(bindings::vrealloc);



    // INVARIANT: `kvrealloc` satisfies the type invariants.

    const KVREALLOC: Self = Self(bindings::kvrealloc);



    /// # Safety

    ///

    /// This method has the same safety requirements as [`Allocator::realloc`].
@@ -205,6 +217,30 @@ unsafe fn realloc( 
    }

}



// 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,

// - `realloc` satisfies the guarantees, since `ReallocFunc::call` has the same.

unsafe impl Allocator for KVmalloc {

    #[inline]

    unsafe fn realloc(

        ptr: Option<NonNull<u8>>,

        layout: Layout,

        old_layout: Layout,

        flags: Flags,

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

        // 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");

            return Err(AllocError);

        }



        // SAFETY: If not `None`, `ptr` is guaranteed to point to valid memory, which was previously

        // allocated with this `Allocator`.

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

    }

}



#[global_allocator]

static ALLOCATOR: Kmalloc = Kmalloc;

rust/kernel/alloc/allocator_test.rs

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 


pub struct Kmalloc;

pub type Vmalloc = Kmalloc;

pub type KVmalloc = Kmalloc;



unsafe impl Allocator for Kmalloc {

    unsafe fn realloc(