Skip to contentSkip to conversation

rust: alloc: kvec doc example and allocator unit tests

PATCH Superseded Hui Zhu 2 participants 5 messages Jul 24, 2025

Subsystems (2)
Rust Rust alloc

v3 of 8 Superseded Latest is v8 →

lore
Share & tools
lore

Hui Zhu

author
#0 lore raw

v3 cover rust: alloc: kvec doc example and allocator unit tests

From: Hui Zhu <[email protected]>

This series includes two Rust patches:

Patch 1 adds KUnit tests for Rust allocation wrappers (kmalloc, vmalloc, kvmalloc). It covers basic allocations, large alignments, and checks for expected failures. Each test verifies content integrity through byte pattern checks.

Patch 2 improves the documentation for KVec::as_slice() by adding a code example. This shows how to use the method with push operations and assertions.

Both patches are co-developed with Geliang Tang. Tested on x86_64 using KUnit.

Changelog:
v3:
According to the comments of Danilo and Boqun, move KVec test to doc example and move VBox to allocator unit tests.
v2:
According to the comments of Danilo, updated the commit to samples the usage of VBox and KVec.

Hui Zhu (2):
rust: allocator: add unit tests of kmalloc, vmalloc and kvmalloc
rust: alloc: kvec: add doc example for as_slice method

 rust/kernel/alloc/allocator.rs | 57 ++++++++++++++++++++++++++++++++++
 rust/kernel/alloc/kvec.rs      |  9 ++++++
 2 files changed, 66 insertions(+)
Signature · 1 line
2.43.0
author
#1 lore raw

PATCH v3 1/2 rust: allocator: add unit tests of kmalloc, vmalloc and kvmalloc

From: Hui Zhu <[email protected]>

Add KUnit test cases to validate the functionality of Rust allocation wrappers (kmalloc, vmalloc, kvmalloc).

The tests include:
Basic allocation tests for each allocator using a 1024-byte Blob structure initialized with a 0xfe pattern.
Large alignment (> PAGE_SIZE) allocation testing using an 8192-byte aligned LargeAlignBlob structure.
Verification of allocation constraints:
- kmalloc successfully handles large alignments.
- vmalloc and kvmalloc correctly fail for unsupported large alignments. Content verification through byte-by-byte pattern checking.

Co-developed-by Geliang Tang <[email protected]>
Signed-off-by Geliang Tang <[email protected]>
Signed-off-by Hui Zhu <[email protected]>
---
 rust/kernel/alloc/allocator.rs | 57 ++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
rust/kernel/alloc/allocator.rs +57 -0
index aa2dfa9dca4c..430d1f664fdf 100644
@@ -187,3 +187,60 @@ unsafe fn realloc(
         unsafe { ReallocFunc::KVREALLOC.call(ptr, layout, old_layout, flags) }
     }
 }
+
+#[macros::kunit_tests(rust_allocator_kunit)]
+mod tests {
+    use super::*;
+    use kernel::prelude::*;
+
+    const TEST_SIZE: usize = 1024;
+    const LARGE_ALIGN_TEST_SIZE: usize = kernel::page::PAGE_SIZE * 4;
+    #[repr(align(128))]
+    struct Blob([u8; TEST_SIZE]);
+    // This structure is used to test the allocation of alignments larger
+    // than PAGE_SIZE.
+    // Since this is not yet supported, avoid accessing the contents of
+    // the structure for now.
+    #[allow(dead_code)]
+    #[repr(align(8192))]
+    struct LargeAlignBlob([u8; LARGE_ALIGN_TEST_SIZE]);
+
+    #[test]
+    fn test_kmalloc() -> Result<(), AllocError> {
+        let blob = KBox::new(Blob([0xfeu8; TEST_SIZE]), GFP_KERNEL)?;
+        for b in blob.0.as_slice().iter() {
+            assert_eq!(*b, 0xfeu8);
+        }
+
+        let blob = KBox::new(LargeAlignBlob([0xfdu8; LARGE_ALIGN_TEST_SIZE]), GFP_KERNEL)?;
+        for b in blob.0.as_slice().iter() {
+            assert_eq!(*b, 0xfdu8);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_vmalloc() -> Result<(), AllocError> {
+        let blob = VBox::new(Blob([0xfeu8; TEST_SIZE]), GFP_KERNEL)?;
+        for b in blob.0.as_slice().iter() {
+            assert_eq!(*b, 0xfeu8);
+        }
+
+        assert!(VBox::<LargeAlignBlob>::new_uninit(GFP_KERNEL).is_err());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_kvmalloc() -> Result<(), AllocError> {
+        let blob = KVBox::new(Blob([0xfeu8; TEST_SIZE]), GFP_KERNEL)?;
+        for b in blob.0.as_slice().iter() {
+            assert_eq!(*b, 0xfeu8);
+        }
+
+        assert!(KVBox::<LargeAlignBlob>::new_uninit(GFP_KERNEL).is_err());
+
+        Ok(())
+    }
+}
Signature · 1 line
2.43.0
author
#2 lore raw

PATCH v3 2/2 rust: alloc: kvec: add doc example for `as_slice` method

In reply to Hui Zhu

From: Hui Zhu <[email protected]>

Add a practical usage example to the documentation of KVec::as_slice() showing how to:
Create a new KVec
Push elements into it
Convert to a slice via as_slice()

Co-developed-by Geliang Tang <[email protected]>
Signed-off-by Geliang Tang <[email protected]>
Signed-off-by Hui Zhu <[email protected]>
---
 rust/kernel/alloc/kvec.rs | 9 +++++++++
 1 file changed, 9 insertions(+)
rust/kernel/alloc/kvec.rs +9 -0
index 3c72e0bdddb8..d384c34d1a5e 100644
@@ -224,6 +224,15 @@ unsafe fn dec_len(&mut self, count: usize) -> &mut [T] {
     }
 
     /// Returns a slice of the entire vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut v = KVec::new();
+    /// v.push(1, GFP_KERNEL);
+    /// v.push(2, GFP_KERNEL);
+    /// assert_eq!(v.as_slice(), &[1, 2]);
+    /// ```
     #[inline]
     pub fn as_slice(&self) -> &[T] {
         self
Signature · 1 line
2.43.0
maintainer
#3 lore raw

Re: [PATCH v3 2/2] rust: alloc: kvec: add doc example for `as_slice` method

Quoted 21 lines · Hui Zhu

From: Hui Zhu <[email protected]>

Add a practical usage example to the documentation of KVec::as_slice() showing how to:
Create a new KVec
Push elements into it
Convert to a slice via as_slice()

Co-developed-by Geliang Tang <[email protected]>
Signed-off-by Geliang Tang <[email protected]>
Signed-off-by Hui Zhu <[email protected]>
---
 rust/kernel/alloc/kvec.rs | 9 +++++++++
 1 file changed, 9 insertions(+)
rust/kernel/alloc/kvec.rs +0 -0
index 3c72e0bdddb8..d384c34d1a5e 100644

rust/kernel/alloc/kvec.rs unsafe fn dec_len(&mut self, count: usize) -> &mut [T] { · line 233

Quoted 10 lines
rust/kernel/alloc/kvec.rs +7 -0
@@ -224,6 +224,15 @@ unsafe fn dec_len(&mut self, count: usize) -> &mut [T] {
     }
 
     /// Returns a slice of the entire vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut v = KVec::new();
+    /// v.push(1, GFP_KERNEL);
+    /// v.push(2, GFP_KERNEL);

These function calls are fallible, but you are ignoring the errors. Please use the question mark operator.

Alice

author
#4 lore raw

Re: [PATCH v3 2/2] rust: alloc: kvec: add doc example for `as_slice` method

Hi Alice,

Quoted 36 lines · Alice Ryhl
Quoted 21 lines · Hui Zhu

From: Hui Zhu <[email protected]>

Add a practical usage example to the documentation of KVec::as_slice() showing how to:
Create a new KVec
Push elements into it
Convert to a slice via as_slice()

Co-developed-by Geliang Tang <[email protected]>
Signed-off-by Geliang Tang <[email protected]>
Signed-off-by Hui Zhu <[email protected]>
---
 rust/kernel/alloc/kvec.rs | 9 +++++++++
 1 file changed, 9 insertions(+)
rust/kernel/alloc/kvec.rs +0 -0
index 3c72e0bdddb8..d384c34d1a5e 100644

rust/kernel/alloc/kvec.rs unsafe fn dec_len(&mut self, count: usize) -> &mut [T] { · line 233

Quoted 10 lines
rust/kernel/alloc/kvec.rs +7 -0
@@ -224,6 +224,15 @@ unsafe fn dec_len(&mut self, count: usize) -> &mut [T] {
     }
 
     /// Returns a slice of the entire vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut v = KVec::new();
+    /// v.push(1, GFP_KERNEL);
+    /// v.push(2, GFP_KERNEL);

These function calls are fallible, but you are ignoring the errors. Please use the question mark operator.

Quoted 1 line

Alice

Just sent v4 according to your comments.

Best,
Hui