Fix alignment issue and prepare for rust 1.71
Subsystems (3)
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
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
@@ -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
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
Björn Roy Baron
reviewerRe: [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
// SAFETYcomments 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
GlobalAlloccallsites"
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
Björn Roy Baron
reviewerRe: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation
In reply to Miguel OjedaQuoted 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
// SAFETYcomments 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
GlobalAlloccallsites"
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)
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
// SAFETYcomments 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
GlobalAlloccallsites"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,
MiguelCheers,
Björn(resent as I accidentally sent html instead of plain text)
Miguel Ojeda
AppliedRe: [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
Re: [PATCH 1/3] rust: allocator: Prevent mis-aligned allocation
In reply to Boqun FengQuoted 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
Suggested-by Vlastimil Babka <[email protected]>Co-developed-by Andreas Hindborg (Samsung) <[email protected]>Signed-off-by Andreas Hindborg (Samsung) <[email protected]>Signed-off-by Boqun Feng <[email protected]>Cc [email protected] # v6.1+
PATCH 2/3 rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc
In reply to Boqun FengThis 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
@@ -41,9 +41,9 @@ unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: bindings::gfunsafe 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
kernel test robot
build botRe: [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
Re: [PATCH 2/3] rust: allocator: Use krealloc_aligned() in KernelAllocator::alloc
In reply to Boqun FengQuoted 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.
Signed-off-by Boqun Feng <[email protected]>--- rust/kernel/allocator.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)rust/kernel/allocator.rs +0
-0@@ -41,9 +41,9 @@ unsafe fn krealloc_aligned(ptr: *mut u8, new_layout: Layout, flags: bindings::gfunsafe 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
-3unsafe 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 ) {
PATCH 3/3 rust: alloc: Add realloc and alloc_zeroed to the GlobalAlloc impl
In reply to Boqun FengFrom: 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.
--- rust/kernel/allocator.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
rust/kernel/allocator.rs +27 -0
@@ -51,6 +51,33 @@ unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { bindings::kfree (ptras *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
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
Signed-off-by Björn Roy Baron <[email protected]>[boqun: add size adjustment for alignment requirement]Signed-off-by Boqun Feng <[email protected]>---
Quoted 41 lines
rust/kernel/allocator.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)rust/kernel/allocator.rs +27
-0@@ -51,6 +51,33 @@ unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) { bindings::kfree (ptras *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]
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