bianbu-repo-mirror/bianbu-linux-6.6
1
0
Fork 0
mirror of https://gitee.com/bianbu-linux/linux-6.6 synced 2025-04-24 14:07:52 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

rust: types: add Opaque::ffi_init

Browse source 
This function allows to easily initialize `Opaque` with the pin-init
API. `Opaque::ffi_init` takes a closure and returns a pin-initializer.
This pin-initiailizer calls the given closure with a pointer to the
inner `T`.

Co-developed-by: Gary Guo <gary@garyguo.net>
Signed-off-by: Gary Guo <gary@garyguo.net>
Signed-off-by: Benno Lossin <benno.lossin@proton.me>
Reviewed-by: Andreas Hindborg <a.hindborg@samsung.com>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20230408122429.1103522-14-y86-dev@protonmail.com
[ Fixed typo. ]
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
This commit is contained in:
Benno Lossin 2023-04-08 12:26:22 +00:00 • committed by Miguel Ojeda
parent 8586f1acd3
commit 692e8935e2
2 changed files with 29 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

9
rust/kernel/init.rs
View file

@ -177,6 +177,14 @@
//! } //! }
//! ``` //! ```
//! //!
//! For the special case where initializing a field is a single FFI-function call that cannot fail,
//! there exist the helper function [`Opaque::ffi_init`]. This function initialize a single
//! [`Opaque`] field by just delegating to the supplied closure. 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 //! [`sync`]: kernel::sync
//! [pinning]: https://doc.rust-lang.org/std/pin/index.html //! [pinning]: https://doc.rust-lang.org/std/pin/index.html
//! [structurally pinned fields]: //! [structurally pinned fields]:
@ -187,6 +195,7 @@
//! [`impl PinInit<T, E>`]: PinInit //! [`impl PinInit<T, E>`]: PinInit
//! [`impl Init<T, E>`]: Init //! [`impl Init<T, E>`]: Init
//! [`Opaque`]: kernel::types::Opaque //! [`Opaque`]: kernel::types::Opaque
//! [`Opaque::ffi_init`]: kernel::types::Opaque::ffi_init
//! [`pin_data`]: ::macros::pin_data //! [`pin_data`]: ::macros::pin_data
use crate::{ use crate::{

20
rust/kernel/types.rs
View file

@ -2,6 +2,7 @@
//! Kernel types. //! Kernel types.
use crate::init::{self, PinInit};
use alloc::boxed::Box; use alloc::boxed::Box;
use core::{ use core::{
cell::UnsafeCell, cell::UnsafeCell,
@ -234,6 +235,25 @@ impl<T> Opaque<T> {
Self(MaybeUninit::uninit()) Self(MaybeUninit::uninit())
} }
/// Creates a pin-initializer from the given initializer closure.
///
/// The returned initializer calls the given closure with the pointer to the inner `T` of this
/// `Opaque`. Since this memory is uninitialized, the closure is not allowed to read from it.
///
/// This function is safe, because the `T` inside of an `Opaque` is allowed to be
/// uninitialized. Additionally, access to the inner `T` requires `unsafe`, so the caller needs
/// to verify at that point that the inner value is valid.
pub fn ffi_init(init_func: impl FnOnce(*mut T)) -> impl PinInit<Self> {
// SAFETY: We contain a `MaybeUninit`, so it is OK for the `init_func` to not fully
// initialize the `T`.
unsafe {
init::pin_init_from_closure::<_, ::core::convert::Infallible>(move |slot| {
init_func(Self::raw_get(slot));
Ok(())
})
}
}
/// Returns a raw pointer to the opaque data. /// Returns a raw pointer to the opaque data.
pub fn get(&self) -> *mut T { pub fn get(&self) -> *mut T {
UnsafeCell::raw_get(self.0.as_ptr()) UnsafeCell::raw_get(self.0.as_ptr())