rust: types: add common init-helper functions for `Opaque`
Subsystems (2)
PATCH v3 11/13 rust: types: add common init-helper functions for `Opaque`
From: Benno Lossin <[email protected]>
Add helper functions to more easily initialize Opaque<T> via FFI and rust raw initializer functions.
These functions take a function pointer to the FFI/raw initialization function and take between 0-4 other arguments. It then returns an initializer that uses the FFI/raw initialization function along with the given arguments to initialize an Opaque<T>.
--- rust/kernel/init.rs | 9 +++++++++ rust/kernel/types.rs | 47 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+)
rust/kernel/init.rs +9 -0
@@ -177,6 +177,14 @@//! } //! ``` //! +//! For the special case where initializing a field is a single FFI-function call that cannot fail, +//! there exist helper functions [`Opaque::ffi_init`]. These functions initialize a single +//! [`Opaque`] field by just delegating to the FFI-function. You can use these in combination with +//! [`pin_init!`]. +//! +//! For more information on how to use [`pin_init_from_closure()`], take a look at the uses inside +//! the `kernel` crate. The [`sync`] module is a good starting point. +//! //! [`sync`]: kernel::sync //! [pinning]: https://doc.rust-lang.org/std/pin/index.html //! [structurally pinned fields]:
@@ -187,6 +195,7 @@//! [`impl PinInit<T, E>`]: PinInit //! [`impl Init<T, E>`]: Init //! [`Opaque`]: kernel::types::Opaque +//! [`Opaque::ffi_init`]: kernel::types::Opaque::ffi_init //! [`pin_data`]: ::macros::pin_data use crate ::{
rust/kernel/types.rs +47 -0
59 lines not on this page · raw message
--
2.39.2
Quoted 10 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add helper functions to more easily initialize
Opaque<T>via FFI and rust raw initializer functions.
These functions take a function pointer to the FFI/raw initialization function and take between 0-4 other arguments. It then returns an initializer that uses the FFI/raw initialization function along with the given arguments to initialize anOpaque<T>.Signed-off-by Benno Lossin <[email protected]>
Quoted 11 lines · [email protected] writes:
From: Benno Lossin <[email protected]>
Add helper functions to more easily initialize
Opaque<T>via FFI and rust raw initializer functions.
These functions take a function pointer to the FFI/raw initialization function and take between 0-4 other arguments. It then returns an initializer that uses the FFI/raw initialization function along with the given arguments to initialize anOpaque<T>.Signed-off-by Benno Lossin <[email protected]>---
Quoted 96 lines
rust/kernel/init.rs | 9 +++++++++ rust/kernel/types.rs | 47 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+)rust/kernel/init.rs +9
-0@@ -177,6 +177,14 @@//! } //! ``` //! +//! For the special case where initializing a field is a single FFI-function call that cannot fail, +//! there exist helper functions [`Opaque::ffi_init`]. These functions initialize a single +//! [`Opaque`] field by just delegating to the FFI-function. You can use these in combination with +//! [`pin_init!`]. +//! +//! For more information on how to use [`pin_init_from_closure()`], take a look at the uses inside +//! the `kernel` crate. The [`sync`] module is a good starting point. +//! //! [`sync`]: kernel::sync //! [pinning]: https://doc.rust-lang.org/std/pin/index.html //! [structurally pinned fields]: @@ -187,6 +195,7 @@//! [`impl PinInit<T, E>`]: PinInit //! [`impl Init<T, E>`]: Init //! [`Opaque`]: kernel::types::Opaque +//! [`Opaque::ffi_init`]: kernel::types::Opaque::ffi_init //! [`pin_data`]: ::macros::pin_data use crate ::{rust/kernel/types.rs +47
-0@@ -2,6 +2,7 @@//! Kernel types. +use crate ::init::{self,PinInit };use alloc::boxed::Box ;use core::{ cell::UnsafeCell ,@@ -248,6 +249,52 @@ impl<T> Opaque<T> { } } +macro_rules! opaque_init_funcs { + ($($abi:literal $name:ident($($arg_name:ident: $arg_typ:ident),*);)*) => { +impl <T >Opaque <T > { + $( +/// Create an initializer using the given initializer function. +/// +/// # Safety +/// +/// The given function **must** under all circumstances initialize the memory +/// location to a valid `T`. If it fails to do so it results in UB. +/// +/// If any parameters are given, those need to be valid for the function. Valid +/// means that calling the function with those parameters complies with the above +/// requirement **and** every other requirement on the function itself. +pub unsafe fn $name<$($arg_typ),*>( + init_func:unsafe extern $abifn (*mut T $(, $arg_typ)*), + $($arg_name: $arg_typ,)* + ) ->impl PinInit <Self > { +// SAFETY: The safety contract of this function ensures that `init_func` fully +// initializes `slot`. +unsafe { + init::pin_init_from_closure (move |slot| { +init_func (Self ::raw_get (slot) $(, $arg_name)*); +Ok (()) + }) + } + } + )* + } + } +} + +opaque_init_funcs! { +"C" ffi_init (); +"C" ffi_init1 (arg1:A1 ); +"C" ffi_init2 (arg1:A1 , arg2:A2 ); +"C" ffi_init3 (arg1:A1 , arg2:A2 , arg3:A3 ); +"C" ffi_init4 (arg1:A1 , arg2:A2 , arg3:A3 , arg4:A4 ); + +"Rust" manual_init (); +"Rust" manual_init1 (arg1:A1 ); +"Rust" manual_init2 (arg1:A1 , arg2:A2 ); +"Rust" manual_init3 (arg1:A1 , arg2:A2 , arg3:A3 ); +"Rust" manual_init4 (arg1:A1 , arg2:A2 , arg3:A3 , arg4:A4 ); +} +/// A sum type that always holds either a value of type `L` or `R`. pub enum Either <L ,R > {/// Constructs an instance of [`Either`] containing a value of type `L`.