rust: sync: reduce stack usage of `UniqueArc::try_new_uninit`
PATCH v3 12/13 rust: sync: reduce stack usage of `UniqueArc::try_new_uninit`
From: Benno Lossin <[email protected]>
UniqueArc::try_new_uninit calls Arc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the generic T and thus could cause a stack overflow for large types.
Change the implementation to use the pin-init API which enables in-place initialization. In particular it avoids having to first construct and then move the uninitialized memory from the stack into the final location.
--- rust/kernel/lib.rs | 1 - rust/kernel/sync/arc.rs | 14 ++++++++++++-- 2 files changed, 12 insertions(+), 3 deletions(-)
rust/kernel/lib.rs +0 -1
@@ -27,7 +27,6 @@#[cfg(not( CONFIG_RUST ))] compile_error! ("Missing kernel configuration for conditional compilation" ); -#[allow(unused_extern_crates)] // Allow proc-macros to refer to `::kernel` inside the `kernel` crate (this crate). extern crate selfas kernel;
rust/kernel/sync/arc.rs +12 -2
@@ -18,6 +18,7 @@use crate ::{ bindings, error::{Error ,Result }, + init, init::{InPlaceInit ,Init ,PinInit }, types::{ForeignOwnable ,Opaque }, };
@@ -29,6 +30,7 @@ use core::{ pin::Pin, ptr::NonNull, }; +use macros::pin_data;/// A reference-counted pointer to an instance of `T`. ///
@@ -121,6 +123,7 @@ pub struct Arc<T: ?Sized> { _p: PhantomData<ArcInner<T>>, } +#[pin_data] #[repr( C )] struct ArcInner <T : ?Sized > { refcount:Opaque <bindings::refcount_t >,
@@ -501,9 +504,16 @@ impl<T> UniqueArc<T> {/// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet. pub fn try_new_uninit () ->Result <UniqueArc <MaybeUninit <T >>> { -Ok (UniqueArc ::<MaybeUninit <T >> { +// INVARIANT: The refcount is initialised to a non-zero value. +let inner =Box ::init (init! (ArcInner { +// SAFETY: There are no safety requirements for this FFI call. + refcount:Opaque ::new (unsafe { bindings::REFCOUNT_INIT (1 ) }), + data <- init::uninit (), + }))?; +Ok (UniqueArc {// INVARIANT: The newly-created object has a ref-count of 1. - inner:Arc ::try_new (MaybeUninit ::uninit ())?, +// SAFETY: The pointer from the `Box` is valid. + inner:unsafe {Arc ::from_inner (Box ::leak (inner).into ()) }, }) } }
--
2.39.2
Quoted 7 lines · On Wed, 29 Mar 2023 22:33:49 +0000 [email protected] wrote:
From: Benno Lossin <[email protected]>
UniqueArc::try_new_uninitcallsArc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the genericTand thus could cause a stack overflow for large types.
Quoted 5 lines
Change the implementation to use the pin-init API which enables in-place initialization. In particular it avoids having to first construct and then move the uninitialized memory from the stack into the final location.
Signed-off-by Benno Lossin <[email protected]>
Quoted 68 lines
--- rust/kernel/lib.rs | 1 - rust/kernel/sync/arc.rs | 14 ++++++++++++-- 2 files changed, 12 insertions(+), 3 deletions(-)rust/kernel/lib.rs +0
-1@@ -27,7 +27,6 @@#[cfg(not( CONFIG_RUST ))] compile_error! ("Missing kernel configuration for conditional compilation" ); -#[allow(unused_extern_crates)] // Allow proc-macros to refer to `::kernel` inside the `kernel` crate (this crate). extern crate selfas kernel;rust/kernel/sync/arc.rs +12
-3@@ -18,6 +18,7 @@use crate ::{ bindings, error::{Error ,Result }, + init, init::{InPlaceInit ,Init ,PinInit }, types::{ForeignOwnable ,Opaque }, };@@ -29,6 +30,7 @@ use core::{ pin::Pin, ptr::NonNull, }; +use macros::pin_data;/// A reference-counted pointer to an instance of `T`. /// @@ -121,6 +123,7 @@ pub struct Arc<T: ?Sized> { _p: PhantomData<ArcInner<T>>, } +#[pin_data] #[repr( C )] struct ArcInner <T : ?Sized > { refcount:Opaque <bindings::refcount_t >,@@ -501,9 +504,16 @@ impl<T> UniqueArc<T> {/// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet. pub fn try_new_uninit () ->Result <UniqueArc <MaybeUninit <T >>> { -Ok (UniqueArc ::<MaybeUninit <T >> { +// INVARIANT: The refcount is initialised to a non-zero value. +let inner =Box ::init (init! (ArcInner { +// SAFETY: There are no safety requirements for this FFI call. + refcount:Opaque ::new (unsafe { bindings::REFCOUNT_INIT (1 ) }), + data <- init::uninit (), + }))?; +Ok (UniqueArc {// INVARIANT: The newly-created object has a ref-count of 1. - inner:Arc ::try_new (MaybeUninit ::uninit ())?, +// SAFETY: The pointer from the `Box` is valid. + inner:unsafe {Arc ::from_inner (Box ::leak (inner).into ()) }, }) } } --2.39.2
From: [email protected]
Quoted 6 lines
Sent: 29 March 2023 23:34
UniqueArc::try_new_uninitcallsArc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the genericTand thus could cause a stack overflow for large types.
Does that mean rust is using (the equivalent of) alloca() ?
That is banned for C code in the kernel for any sizes.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Quoted 9 lines · David Laight
From: [email protected]
Quoted 6 lines
Sent: 29 March 2023 23:34
UniqueArc::try_new_uninitcallsArc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the genericTand thus could cause a stack overflow for large types.Does that mean rust is using (the equivalent of)
alloca()?
No, the compiler knows the size of T statically (this is a requirement for calling MaybeUninit::uninit()). It would simply reserve stack space for a stack variable (like the C compiler would also do) and since the type is generic and user-specified, it could be larger than the stack size. The problem is that the Rust compiler does not optimize the stack variable away. This fix avoids creating a stack variable in the first place.
--
Cheers,
Benno
Quoted 8 lines
That is banned for C code in the kernel for any sizes.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Quoted 7 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
UniqueArc::try_new_uninitcallsArc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the genericTand thus could cause a stack overflow for large types.
Quoted 5 lines
Change the implementation to use the pin-init API which enables in-place initialization. In particular it avoids having to first construct and then move the uninitialized memory from the stack into the final location.
Signed-off-by Benno Lossin <[email protected]>
Quoted 7 lines · [email protected] writes:
From: Benno Lossin <[email protected]>
UniqueArc::try_new_uninitcallsArc::try_new(MaybeUninit::uninit()). This results in the uninitialized memory being placed on the stack, which may be arbitrarily large due to the genericTand thus could cause a stack overflow for large types.
Quoted 6 lines
Change the implementation to use the pin-init API which enables in-place initialization. In particular it avoids having to first construct and then move the uninitialized memory from the stack into the final location.
Signed-off-by Benno Lossin <[email protected]>---
Reviewed-by Andreas Hindborg <[email protected]>
Quoted 63 lines
rust/kernel/lib.rs | 1 - rust/kernel/sync/arc.rs | 14 ++++++++++++-- 2 files changed, 12 insertions(+), 3 deletions(-)rust/kernel/lib.rs +0
-1@@ -27,7 +27,6 @@#[cfg(not( CONFIG_RUST ))] compile_error! ("Missing kernel configuration for conditional compilation" ); -#[allow(unused_extern_crates)] // Allow proc-macros to refer to `::kernel` inside the `kernel` crate (this crate). extern crate selfas kernel;rust/kernel/sync/arc.rs +12
-2@@ -18,6 +18,7 @@use crate ::{ bindings, error::{Error ,Result }, + init, init::{InPlaceInit ,Init ,PinInit }, types::{ForeignOwnable ,Opaque }, };@@ -29,6 +30,7 @@ use core::{ pin::Pin, ptr::NonNull, }; +use macros::pin_data;/// A reference-counted pointer to an instance of `T`. /// @@ -121,6 +123,7 @@ pub struct Arc<T: ?Sized> { _p: PhantomData<ArcInner<T>>, } +#[pin_data] #[repr( C )] struct ArcInner <T : ?Sized > { refcount:Opaque <bindings::refcount_t >,@@ -501,9 +504,16 @@ impl<T> UniqueArc<T> {/// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet. pub fn try_new_uninit () ->Result <UniqueArc <MaybeUninit <T >>> { -Ok (UniqueArc ::<MaybeUninit <T >> { +// INVARIANT: The refcount is initialised to a non-zero value. +let inner =Box ::init (init! (ArcInner { +// SAFETY: There are no safety requirements for this FFI call. + refcount:Opaque ::new (unsafe { bindings::REFCOUNT_INIT (1 ) }), + data <- init::uninit (), + }))?; +Ok (UniqueArc {// INVARIANT: The newly-created object has a ref-count of 1. - inner:Arc ::try_new (MaybeUninit ::uninit ())?, +// SAFETY: The pointer from the `Box` is valid. + inner:unsafe {Arc ::from_inner (Box ::leak (inner).into ()) }, }) } }