rust: sync: add functions for initializing `UniqueArc<MaybeUninit<T>>`
PATCH v3 13/13 rust: sync: add functions for initializing `UniqueArc<MaybeUninit<T>>`
From: Benno Lossin <[email protected]>
Add two functions init_with and pin_init_with to UniqueArc<MaybeUninit<T>> to initialize the memory of already allocated UniqueArcs. This is useful when you want to allocate memory check some condition inside of a context where allocation is forbidden and then conditionally initialize an object.
--- rust/kernel/sync/arc.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
rust/kernel/sync/arc.rs +24 -0
@@ -540,6 +540,30 @@ impl<T> UniqueArc<MaybeUninit<T>> { inner: unsafe { Arc::from_inner(inner.cast()) }, } } + +/// Initialize `self` using the given initializer. +pub fn init_with <E >(mut self, init:impl Init <T ,E >) -> core::result::Result <UniqueArc <T >,E > { +// SAFETY: The supplied pointer is valid for initialization. +match unsafe { init.__init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }), +Err (err) =>Err (err), + } + } + +/// Pin-initialize `self` using the given pin-initializer. +pub fn pin_init_with <E >( +mut self, + init:impl PinInit <T ,E >, + ) -> core::result::Result <Pin <UniqueArc <T >>,E > { +// SAFETY: The supplied pointer is valid for initialization and we will later pin the value +// to ensure it does not move. +match unsafe { init.__pinned_init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }.into ()), +Err (err) =>Err (err), + } + } }impl <T : ?Sized >From <UniqueArc <T >>for Pin <UniqueArc <T >> {
--
2.39.2
Quoted 9 lines · On Wed, 29 Mar 2023 22:33:53 +0000 [email protected] wrote:
From: Benno Lossin <[email protected]>
Add two functions
init_withandpin_init_withtoUniqueArc<MaybeUninit<T>>to initialize the memory of already allocatedUniqueArcs. This is useful when you want to allocate memory check some condition inside of a context where allocation is forbidden and then conditionally initialize an object.Signed-off-by Benno Lossin <[email protected]>
Quoted 43 lines
--- rust/kernel/sync/arc.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)rust/kernel/sync/arc.rs +24
-1@@ -540,6 +540,30 @@ impl<T> UniqueArc<MaybeUninit<T>> { inner: unsafe { Arc::from_inner(inner.cast()) }, } } + +/// Initialize `self` using the given initializer. +pub fn init_with <E >(mut self, init:impl Init <T ,E >) -> core::result::Result <UniqueArc <T >,E > { +// SAFETY: The supplied pointer is valid for initialization. +match unsafe { init.__init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }), +Err (err) =>Err (err), + } + } + +/// Pin-initialize `self` using the given pin-initializer. +pub fn pin_init_with <E >( +mut self, + init:impl PinInit <T ,E >, + ) -> core::result::Result <Pin <UniqueArc <T >>,E > { +// SAFETY: The supplied pointer is valid for initialization and we will later pin the value +// to ensure it does not move. +match unsafe { init.__pinned_init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }.into ()), +Err (err) =>Err (err), + } + } }impl <T : ?Sized >From <UniqueArc <T >>for Pin <UniqueArc <T >> { --2.39.2
Quoted 9 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add two functions
init_withandpin_init_withtoUniqueArc<MaybeUninit<T>>to initialize the memory of already allocatedUniqueArcs. This is useful when you want to allocate memory check some condition inside of a context where allocation is forbidden and then conditionally initialize an object.Signed-off-by Benno Lossin <[email protected]>
I asked for this one because we will need it in the binder driver.
Quoted 10 lines · [email protected] writes:
From: Benno Lossin <[email protected]>
Add two functions
init_withandpin_init_withtoUniqueArc<MaybeUninit<T>>to initialize the memory of already allocatedUniqueArcs. This is useful when you want to allocate memory check some condition inside of a context where allocation is forbidden and then conditionally initialize an object.Signed-off-by Benno Lossin <[email protected]>---
Quoted 38 lines
rust/kernel/sync/arc.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)rust/kernel/sync/arc.rs +24
-0@@ -540,6 +540,30 @@ impl<T> UniqueArc<MaybeUninit<T>> { inner: unsafe { Arc::from_inner(inner.cast()) }, } } + +/// Initialize `self` using the given initializer. +pub fn init_with <E >(mut self, init:impl Init <T ,E >) -> core::result::Result <UniqueArc <T >,E > { +// SAFETY: The supplied pointer is valid for initialization. +match unsafe { init.__init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }), +Err (err) =>Err (err), + } + } + +/// Pin-initialize `self` using the given pin-initializer. +pub fn pin_init_with <E >( +mut self, + init:impl PinInit <T ,E >, + ) -> core::result::Result <Pin <UniqueArc <T >>,E > { +// SAFETY: The supplied pointer is valid for initialization and we will later pin the value +// to ensure it does not move. +match unsafe { init.__pinned_init (self.as_mut_ptr ()) } { +// SAFETY: Initialization completed successfully. +Ok (()) =>Ok (unsafe { self.assume_init () }.into ()), +Err (err) =>Err (err), + } + } }impl <T : ?Sized >From <UniqueArc <T >>for Pin <UniqueArc <T >> {