Skip to contentSkip to conversation

Fix alignment issue and prepare for rust 1.71

PATCH Applied Boqun Feng 6 participants 14 messages Jul 30, 2023 – Jul 31, 2023

Subsystems (3)
lore
Share & tools
lore

Boqun Feng

author
#0 lore raw

cover Fix alignment issue and prepare for rust 1.71

Hi Miguel,

I end up with this series:

(background: https://lore.kernel.org/rust-for-linux/CANiq72=pb18B6NOcXF03d0ctOP8kv2dqnUeNyEuSvuDb=vs-0g@mail.gmail.com/)

Patch #1: introduces the core helper function that help calculate the correct size for krealloc(), and also use the helper function to fix __rust_* ones, this should be backported to stable kernels hence the Cc.

Patch #2: use the helper function in KernelAllocator

Patch #3: Bjorn's patch with correct use of the helper function.

I have to add a few more SAFETY comments in these __rust_* functions, which may cause conflict with your 1.71 series.

Since all previous patches get refactored a bit, I dropped all the Reviewed-bys, appreciate anyone to take a look, thanks!

Regards,
Boqun

Björn Roy Baron (1):
rust: alloc: Add realloc and alloc_zeroed to the GlobalAlloc impl

Boqun Feng (2):
rust: allocator: Prevent mis-aligned allocation
rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc

 rust/bindings/bindings_helper.h |   1 +
 rust/kernel/allocator.rs        | 107 ++++++++++++++++++++++++++------
 2 files changed, 90 insertions(+), 18 deletions(-)
Signature · 1 line
2.41.0
author
#1 lore raw

PATCH 1/3 rust: allocator: Prevent mis-aligned allocation

Currently the rust allocator simply passes the size of the type Layout to krealloc(), and in theory the alignment requirement from the type Layout may be larger than the guarantee provided by SLAB, which means the allocated object is mis-aligned.

Fix this by adjusting the allocation size to the nearest power of two, which SLAB always guarantees a size-aligned allocation. And because Rust guarantees that the original size must be a multiple of alignment and the alignment must be a power of two, then the alignment requirement is satisfied.

---
 rust/bindings/bindings_helper.h |  1 +
 rust/kernel/allocator.rs        | 74 ++++++++++++++++++++++++++-------
 2 files changed, 60 insertions(+), 15 deletions(-)
rust/bindings/bindings_helper.h +1 -0
index 3e601ce2548d..058954961bfc 100644
@@ -13,5 +13,6 @@
 #include <linux/sched.h>
 
 /* `bindgen` gets confused at certain things. */
+const size_t BINDINGS_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;
 const gfp_t BINDINGS_GFP_KERNEL = GFP_KERNEL;
 const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
rust/kernel/allocator.rs +59 -15

98 lines not on this page · raw message

Signature · 1 line
2.41.0
#2 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

rust/kernel/allocator.rs unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { · line 66

Quoted 5 lines · Boqun Feng
rust/kernel/allocator.rs +4 -0
+// Note: Although these are *safe* functions, but they are only generated at
+// `GlobalAlloc` callsites, hence we assume the parameters obey the same
+// `GlobalAlloc` function safety requirements: size and align should form a
+// valid layout, and size is greater than 0.

Thanks for adding all the // SAFETY comments here Boqun!

Björn, do they look good to you? (since you fixed the issue in the compiler)

On this comment in particular, "generated at GlobalAlloc callsites" sounds a bit confusing to me. Would "... called by the compiler with parameters that obey ..." make sense? Or does the sentence refer to the normal case (i.e. when the functions are generated)? Anyway, it is not a big deal.

Cheers,
Miguel

#3 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

Quoted 10 lines · Miguel Ojeda

rust/kernel/allocator.rs unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { · line 66

Quoted 5 lines · On Sun, Jul 30, 2023 at 3:29 AM Boqun > Feng <[email protected]> wrote:
rust/kernel/allocator.rs +4 -0
+// Note: Although these are *safe* functions, but they are only generated at
+// `GlobalAlloc` callsites, hence we assume the parameters obey the same
+// `GlobalAlloc` function safety requirements: size and align should form a
+// valid layout, and size is greater than 0.

Thanks for adding all the // SAFETY comments here Boqun!

Björn, do they look good to you? (since you fixed the issue in the compiler)

Based on a quick look, yes. The __rust_* methods that are normally generated by the compiled directly jump to the respective global allocator method, so they have the same safety requirements.

Quoted 2 lines

On this comment in particular, "generated at GlobalAlloc callsites"

sounds a bit confusing to me. Would "... called by the compiler with parameters that obey ..." make sense? Or does the sentence refer to the normal case (i.e. when the functions are generated)? Anyway, it is not a big deal.

Quoted 3 lines

Cheers,
Miguel

Cheers,
Björn

#4 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

In reply to Miguel Ojeda
Quoted 10 lines · Miguel Ojeda

rust/kernel/allocator.rs unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { · line 66

Quoted 5 lines · On Sun, Jul 30, 2023 at 3:29 AM Boqun > Feng <[email protected]> wrote:
rust/kernel/allocator.rs +4 -0
+// Note: Although these are *safe* functions, but they are only generated at
+// `GlobalAlloc` callsites, hence we assume the parameters obey the same
+// `GlobalAlloc` function safety requirements: size and align should form a
+// valid layout, and size is greater than 0.

Thanks for adding all the // SAFETY comments here Boqun!

Björn, do they look good to you? (since you fixed the issue in the compiler)

Based on a quick look, yes. The __rust_* methods that are normally generated by the compiled directly jump to the respective global allocator method, so they have the same safety requirements.

Quoted 2 lines

On this comment in particular, "generated at GlobalAlloc callsites"

sounds a bit confusing to me. Would "... called by the compiler with parameters that obey ..." make sense? Or does the sentence refer to the normal case (i.e. when the functions are generated)? Anyway, it is not a big deal.

Quoted 3 lines

Cheers,
Miguel

Cheers,
Björn

(resent as I accidentally sent html instead of plain text)

author
#5 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

Quoted 10 lines · Björn Roy Baron
Quoted 9 lines · Miguel Ojeda

rust/kernel/allocator.rs unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { · line 66

Quoted 5 lines · On Sun, Jul 30, 2023 at 3:29 AM Boqun > Feng <[email protected]> wrote:
rust/kernel/allocator.rs +4 -0
+// Note: Although these are *safe* functions, but they are only generated at
+// `GlobalAlloc` callsites, hence we assume the parameters obey the same
+// `GlobalAlloc` function safety requirements: size and align should form a
+// valid layout, and size is greater than 0.

Thanks for adding all the // SAFETY comments here Boqun!

Quoted 4 lines
Quoted 1 line

Björn, do they look good to you? (since you fixed the issue in the compiler)

Based on a quick look, yes. The __rust_* methods that are normally generated by the compiled directly jump to the respective global allocator method, so they have the same safety requirements.

Good to know, thanks!

Quoted 4 lines
Quoted 2 lines

On this comment in particular, "generated at GlobalAlloc callsites"

sounds a bit confusing to me. Would "... called by the compiler with parameters that obey ..." make sense? Or does the sentence refer to

Agreed. It's better. So reword as below:

// Note: Although these are *safe* functions, but they are called by the // compiler with the parameters that obey the same GlobalAlloc // function safety requirements: size and align should form a valid // layout, and size is greater than 0.

Regards,
Boqun

Quoted 10 lines

the normal case (i.e. when the functions are generated)? Anyway, it is not a big deal.

Quoted 3 lines

Cheers,
Miguel

Cheers,
Björn

(resent as I accidentally sent html instead of plain text)

Applied
#6 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

Quoted 2 lines · Boqun Feng

Good to know, thanks!

Yeah, thanks Björn!

Quoted 6 lines

Agreed. It's better. So reword as below:

// Note: Although these are *safe* functions, but they are called by the // compiler with the parameters that obey the same GlobalAlloc // function safety requirements: size and align should form a valid // layout, and size is greater than 0.

+1, thanks!

Applied to rust-fixes, but please feel free to send Reviewed-bys.

Cheers,
Miguel

Acked-by on v1 1/3
#7 lore raw

Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation

In reply to Boqun Feng
Quoted 11 lines · Boqun Feng

Currently the rust allocator simply passes the size of the type Layout to krealloc(), and in theory the alignment requirement from the type Layout may be larger than the guarantee provided by SLAB, which means the allocated object is mis-aligned.

Fix this by adjusting the allocation size to the nearest power of two, which SLAB always guarantees a size-aligned allocation. And because Rust guarantees that the original size must be a multiple of alignment and the alignment must be a power of two, then the alignment requirement is satisfied.

Quoted 5 lines
author
#8 lore raw

PATCH 2/3 rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc

In reply to Boqun Feng

This fixes the potential issue that when KernelAllocator is used, the allocation may be mis-aligned due to SLAB's alignment guarantee.

---
 rust/kernel/allocator.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
rust/kernel/allocator.rs +3 -3
index fae11d1fdba7..1aec688cf0e0 100644
@@ -41,9 +41,9 @@ unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: bindings::gf
 
 unsafe impl GlobalAlloc for KernelAllocator {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // `krealloc()` is used instead of `kmalloc()` because the latter is
-        // an inline function and cannot be bound to as a result.
-        unsafe { bindings::krealloc(ptr::null(), layout.size(), bindings::GFP_KERNEL) as *mut u8 }
+        // SAFETY: `ptr::null_mut()` is null and `layout` has a non-zero size by the function safety
+        // requirement.
+        unsafe { krealloc_aligned(ptr::null_mut(), layout, bindings::GFP_KERNEL) }
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
Signature · 1 line
2.41.0
#9 lore raw

Re: [PATCH 2/3] rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc

FYI: kernel test robot notices the stable kernel rule is not satisfied.

Hi,

Thanks for your patch.

FYI: kernel test robot notices the stable kernel rule is not satisfied.

Rule: 'Cc: [email protected]' or 'commit <sha1> upstream.'
Subject: [PATCH 2/3] rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc

The check is based on https://www.kernel.org/doc/html/latest/process/stable-kernel-rules.html

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
Reviewed-by Andreas Hindborg on v1 2/3
#10 lore raw

Re: [PATCH 2/3] rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc

In reply to Boqun Feng
Quoted 15 lines · Boqun Feng

This fixes the potential issue that when KernelAllocator is used, the allocation may be mis-aligned due to SLAB's alignment guarantee.

---
 rust/kernel/allocator.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
rust/kernel/allocator.rs +0 -0
index fae11d1fdba7..1aec688cf0e0 100644
@@ -41,9 +41,9 @@ unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: bindings::gf
 
 unsafe impl GlobalAlloc for KernelAllocator {

rust/kernel/allocator.rs unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: bindings::gf · line 49

Quoted 10 lines
rust/kernel/allocator.rs +3 -3
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // `krealloc()` is used instead of `kmalloc()` because the latter is
-        // an inline function and cannot be bound to as a result.
-        unsafe { bindings::krealloc(ptr::null(), layout.size(), bindings::GFP_KERNEL) as *mut u8 }
+        // SAFETY: `ptr::null_mut()` is null and `layout` has a non-zero size by the function safety
+        // requirement.
+        unsafe { krealloc_aligned(ptr::null_mut(), layout, bindings::GFP_KERNEL) }
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
author
#11 lore raw

PATCH 3/3 rust: alloc: Add realloc and alloc_zeroed to the GlobalAlloc impl

In reply to Boqun Feng

From: Björn Roy Baron <[email protected]>

While there are default impls for these methods, using the respective C api's is faster. Currently neither the existing nor these new GlobalAlloc method implementations are actually called. Instead the __rust_* function defined below the GlobalAlloc impl are used. With rustc 1.71 these functions will be gone and all allocation calls will go through the GlobalAlloc implementation.

[boqun: add size adjustment for alignment requirement]
---
 rust/kernel/allocator.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
rust/kernel/allocator.rs +27 -0
index 1aec688cf0e0..6f1f50465ab3 100644
@@ -51,6 +51,33 @@ unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
             bindings::kfree(ptr as *const core::ffi::c_void);
         }
     }
+
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY:
+        // - `new_size`, when rounded up to the nearest multiple of `layout.align()`, will not
+        //   overflow `isize` by the function safety requirement.
+        // - `layout.align()` is a proper alignment (i.e. not zero and must be a power of two).
+        let layout = unsafe { Layout::from_size_align_unchecked(new_size, layout.align()) };
+
+        // SAFETY:
+        // - `ptr` is either null or a pointer allocated by this allocator by the function safety
+        //   requirement.
+        // - the size of `layout` is not zero because `new_size` is not zero by the function safety
+        //   requirement.
+        unsafe { krealloc_aligned(ptr, layout, bindings::GFP_KERNEL) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: `ptr::null_mut()` is null and `layout` has a non-zero size by the function safety
+        // requirement.
+        unsafe {
+            krealloc_aligned(
+                ptr::null_mut(),
+                layout,
+                bindings::GFP_KERNEL | bindings::__GFP_ZERO,
+            )
+        }
+    }
 }
 
 #[global_allocator]
Signature · 1 line
2.41.0
Reviewed-by Andreas Hindborg on v1 3/3
#12 lore raw

Re: [PATCH 3/3] rust: alloc: Add realloc and alloc_zeroed to the GlobalAlloc impl

Quoted 9 lines · Boqun Feng

From: Björn Roy Baron <[email protected]>

While there are default impls for these methods, using the respective C api's is faster. Currently neither the existing nor these new GlobalAlloc method implementations are actually called. Instead the __rust_* function defined below the GlobalAlloc impl are used. With rustc 1.71 these functions will be gone and all allocation calls will go through the GlobalAlloc implementation.

Quoted 5 lines
[boqun: add size adjustment for alignment requirement]

---

Quoted 41 lines
 rust/kernel/allocator.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
rust/kernel/allocator.rs +27 -0
index 1aec688cf0e0..6f1f50465ab3 100644
@@ -51,6 +51,33 @@ unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
             bindings::kfree(ptr as *const core::ffi::c_void);
         }
     }
+
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY:
+        // - `new_size`, when rounded up to the nearest multiple of `layout.align()`, will not
+        //   overflow `isize` by the function safety requirement.
+        // - `layout.align()` is a proper alignment (i.e. not zero and must be a power of two).
+        let layout = unsafe { Layout::from_size_align_unchecked(new_size, layout.align()) };
+
+        // SAFETY:
+        // - `ptr` is either null or a pointer allocated by this allocator by the function safety
+        //   requirement.
+        // - the size of `layout` is not zero because `new_size` is not zero by the function safety
+        //   requirement.
+        unsafe { krealloc_aligned(ptr, layout, bindings::GFP_KERNEL) }
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: `ptr::null_mut()` is null and `layout` has a non-zero size by the function safety
+        // requirement.
+        unsafe {
+            krealloc_aligned(
+                ptr::null_mut(),
+                layout,
+                bindings::GFP_KERNEL | bindings::__GFP_ZERO,
+            )
+        }
+    }
 }
 
 #[global_allocator]
#13 lore raw
In reply to Boqun Feng
Quoted 9 lines · Boqun Feng

Patch #1: introduces the core helper function that help calculate the correct size for krealloc(), and also use the helper function to fix __rust_* ones, this should be backported to stable kernels hence the Cc.

Patch #2: use the helper function in KernelAllocator

Patch #3: Bjorn's patch with correct use of the helper function.

Looks good to me, thanks a lot!

Quoted 2 lines

I have to add a few more SAFETY comments in these __rust_* functions, which may cause conflict with your 1.71 series.

No worries.

Quoted 2 lines

Since all previous patches get refactored a bit, I dropped all the Reviewed-bys, appreciate anyone to take a look, thanks!

Thanks Boqun!

Cheers,
Miguel