Commit 31547c98 authored by Benno Lossin's avatar Benno Lossin Committed by Miguel Ojeda
Browse files

rust: pin-init: remove kernel-crate dependency 



In order to make pin-init a standalone crate, remove dependencies on
kernel-specific code such as `ScopeGuard` and `KBox`.

`ScopeGuard` is only used in the `[pin_]init_array_from_fn` functions
and can easily be replaced by a primitive construct.

`KBox` is only used for type variance of unsized types and can also
easily be replaced.

Signed-off-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarFiona Behrens <me@kloenk.dev>
Reviewed-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Tested-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Link: https://lore.kernel.org/r/20250308110339.2997091-13-benno.lossin@proton.me


Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 129e97be

rust/pin-init/src/__internal.rs

+4 −1
Original line number Diff line number Diff line
@@ -11,6 +11,9 @@ 


/// See the [nomicon] for what subtyping is. See also [this table].

///

/// The reason for not using `PhantomData<*mut T>` is that that type never implements [`Send`] and

/// [`Sync`]. Hence `fn(*mut T) -> *mut T` is used, as that type always implements them.

///

/// [nomicon]: https://doc.rust-lang.org/nomicon/subtyping.html

/// [this table]: https://doc.rust-lang.org/nomicon/phantom-data.html#table-of-phantomdata-patterns

pub(super) type Invariant<T> = PhantomData<fn(*mut T) -> *mut T>;
@@ -105,7 +108,7 @@ fn make_closure<F, O, E>(self, f: F) -> F 
    }

}



pub struct AllData<T: ?Sized>(PhantomData<fn(KBox<T>) -> KBox<T>>);

pub struct AllData<T: ?Sized>(Invariant<T>);



impl<T: ?Sized> Clone for AllData<T> {

    fn clone(&self) -> Self {

rust/pin-init/src/lib.rs

+14 −27
Original line number Diff line number Diff line
@@ -212,7 +212,6 @@ 
//! [`pin_data`]: ::macros::pin_data

//! [`pin_init!`]: crate::pin_init!



use crate::{alloc::KBox, types::ScopeGuard};

use core::{

    cell::UnsafeCell,

    convert::Infallible,
@@ -944,7 +943,7 @@ fn pin_chain<F>(self, f: F) -> ChainPinInit<Self, F, T, E> 
}



/// An initializer returned by [`PinInit::pin_chain`].

pub struct ChainPinInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, KBox<T>)>);

pub struct ChainPinInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, T)>);



// SAFETY: The `__pinned_init` function is implemented such that it

// - returns `Ok(())` on successful initialization,
@@ -1043,7 +1042,7 @@ fn chain<F>(self, f: F) -> ChainInit<Self, F, T, E> 
}



/// An initializer returned by [`Init::chain`].

pub struct ChainInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, KBox<T>)>);

pub struct ChainInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, T)>);



// SAFETY: The `__init` function is implemented such that it

// - returns `Ok(())` on successful initialization,
@@ -1140,25 +1139,19 @@ pub fn init_array_from_fn<I, const N: usize, T, E>( 
{

    let init = move |slot: *mut [T; N]| {

        let slot = slot.cast::<T>();

        // Counts the number of initialized elements and when dropped drops that many elements from

        // `slot`.

        let mut init_count = ScopeGuard::new_with_data(0, |i| {

            // We now free every element that has been initialized before.

            // SAFETY: The loop initialized exactly the values from 0..i and since we

            // return `Err` below, the caller will consider the memory at `slot` as

            // uninitialized.

            unsafe { ptr::drop_in_place(ptr::slice_from_raw_parts_mut(slot, i)) };

        });

        for i in 0..N {

            let init = make_init(i);

            // SAFETY: Since 0 <= `i` < N, it is still in bounds of `[T; N]`.

            let ptr = unsafe { slot.add(i) };

            // SAFETY: The pointer is derived from `slot` and thus satisfies the `__init`

            // requirements.

            unsafe { init.__init(ptr) }?;

            *init_count += 1;

            if let Err(e) = unsafe { init.__init(ptr) } {

                // SAFETY: The loop has initialized the elements `slot[0..i]` and since we return

                // `Err` below, `slot` will be considered uninitialized memory.

                unsafe { ptr::drop_in_place(ptr::slice_from_raw_parts_mut(slot, i)) };

                return Err(e);

            }

        }

        init_count.dismiss();

        Ok(())

    };

    // SAFETY: The initializer above initializes every element of the array. On failure it drops
@@ -1189,25 +1182,19 @@ pub fn pin_init_array_from_fn<I, const N: usize, T, E>( 
{

    let init = move |slot: *mut [T; N]| {

        let slot = slot.cast::<T>();

        // Counts the number of initialized elements and when dropped drops that many elements from

        // `slot`.

        let mut init_count = ScopeGuard::new_with_data(0, |i| {

            // We now free every element that has been initialized before.

            // SAFETY: The loop initialized exactly the values from 0..i and since we

            // return `Err` below, the caller will consider the memory at `slot` as

            // uninitialized.

            unsafe { ptr::drop_in_place(ptr::slice_from_raw_parts_mut(slot, i)) };

        });

        for i in 0..N {

            let init = make_init(i);

            // SAFETY: Since 0 <= `i` < N, it is still in bounds of `[T; N]`.

            let ptr = unsafe { slot.add(i) };

            // SAFETY: The pointer is derived from `slot` and thus satisfies the `__init`

            // requirements.

            unsafe { init.__pinned_init(ptr) }?;

            *init_count += 1;

            if let Err(e) = unsafe { init.__pinned_init(ptr) } {

                // SAFETY: The loop has initialized the elements `slot[0..i]` and since we return

                // `Err` below, `slot` will be considered uninitialized memory.

                unsafe { ptr::drop_in_place(ptr::slice_from_raw_parts_mut(slot, i)) };

                return Err(e);

            }

        }

        init_count.dismiss();

        Ok(())

    };

    // SAFETY: The initializer above initializes every element of the array. On failure it drops