rust: Added pinned-init API

This API is used to initialize pinned structs.

TODO: describe the purpose and functionality of the API better.

Also added `pin_init` to `Arc`.

Also added `pin_data` attribute macro

Also added `pin_init`, `init` and `pin_data` to the prelude.

This is a convenience attribute macro that can be used instead of
```
pin_data! {
    Struct {
        field: u8,
        // ...
    }
}
```

Signed-off-by: Benno Lossin <[email protected]>

Author: y86-dev

rust/kernel/init.rs

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Workaround for specialization
+
+use super::*;
+
+mod sealed {
+    use super::*;
+    pub trait Sealed {}
+
+    impl Sealed for Direct {}
+    impl Sealed for Closure {}
+}
+
+pub trait InitWay: sealed::Sealed {}
+
+impl InitWay for Direct {}
+impl InitWay for Closure {}
+
+pub struct Direct;
+pub struct Closure;
+
+/// # Safety
+/// Same as [`PinInit`]
+pub unsafe trait __PinInitImpl<T: ?Sized, E, W: InitWay> {
+    /// # Safety
+    /// Same as [`PinInit::__pinned_init`]
+    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E>;
+}
+
+/// # Safety
+/// Same as [`Init`]
+pub unsafe trait __InitImpl<T: ?Sized, E, W: InitWay>: __PinInitImpl<T, E, W> {
+    /// # Safety
+    /// Same as [`Init::__init`]
+    unsafe fn __init(self, slot: *mut T) -> Result<(), E>;
+}
+
+/// # Safety
+/// Only implemented by pin_data!
+pub unsafe trait __PinData {
+    type __PinData;
+}
+
+unsafe impl<T> __PinInitImpl<T, Infallible, Direct> for T {
+    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), Infallible> {
+        // SAFETY: pointer valid as per function contract
+        unsafe { slot.write(self) };
+        Ok(())
+    }
+}
+
+unsafe impl<T> __InitImpl<T, Infallible, Direct> for T {
+    unsafe fn __init(self, slot: *mut T) -> Result<(), Infallible> {
+        // SAFETY: pointer valid as per function contract
+        unsafe { slot.write(self) };
+        Ok(())
+    }
+}
+
+unsafe impl<I, T, E> __InitImpl<T, E, Closure> for I
+where
+    I: Init<T, E>,
+{
+    unsafe fn __init(self, slot: *mut T) -> Result<(), E> {
+        unsafe { Init::__init(self, slot) }
+    }
+}
+
+unsafe impl<I, T, E> __PinInitImpl<T, E, Closure> for I
+where
+    I: PinInit<T, E>,
+{
+    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {
+        unsafe { PinInit::__pinned_init(self, slot) }
+    }
+}
+
+/// When a value of this type is dropped, it drops something else.
+pub struct DropGuard<T: ?Sized>(*mut T);
+
+impl<T: ?Sized> DropGuard<T> {
+    /// Creates a new [`DropGuard<T>`]. It will [`ptr::drop_in_place`] `ptr` when it gets dropped.
+    ///
+    /// # Safety
+    /// `ptr` must be a valid poiner.
+    ///
+    /// It is the callers responsibility that `self` will only get dropped if the pointee of `ptr`:
+    /// - has not been dropped,
+    /// - is not accesible by any other means,
+    /// - will not be dropped by any other means.
+    pub unsafe fn new(ptr: *mut T) -> Self {
+        Self(ptr)
+    }
+}
+
+impl<T: ?Sized> Drop for DropGuard<T> {
+    fn drop(&mut self) {
+        // SAFETY: safe as a `DropGuard` can only be constructed using the unsafe new function.
+        unsafe { ptr::drop_in_place(self.0) }
+    }
+}
+
+/// Stack initializer helper type. See [`stack_init`].
+pub struct StackInit<T>(MaybeUninit<T>, bool);
+
+impl<T> Drop for StackInit<T> {
+    fn drop(&mut self) {
+        if self.1 {
+            unsafe { self.0.assume_init_drop() };
+        }
+    }
+}
+impl<T> StackInit<T> {
+    pub fn uninit() -> Self {
+        Self(MaybeUninit::uninit(), false)
+    }
+
+    /// # Safety
+    /// The caller ensures that `self` is on the stack and not accesible to **any** other code.
+    pub unsafe fn init<E>(&mut self, init: impl PinInit<T, E>) -> Result<Pin<&mut T>, E> {
+        unsafe { init.__pinned_init(self.0.as_mut_ptr()) }?;
+        self.1 = true;
+        Ok(unsafe { Pin::new_unchecked(self.0.assume_init_mut()) })
+    }
+}