Commit 6d1c22d0 authored by Benno Lossin's avatar Benno Lossin Committed by Miguel Ojeda
Browse files

rust: init: add `write_[pin_]init` functions 

Sometimes it is necessary to split allocation and initialization into
two steps. One such situation is when reusing existing allocations
obtained via `Box::drop_contents`. See [1] for an example.

In order to support this use case add `write_[pin_]init` functions to the
pin-init API. These functions operate on already allocated smart
pointers that wrap `MaybeUninit<T>`.

Link: https://lore.kernel.org/rust-for-linux/f026532f-8594-4f18-9aa5-57ad3f5bc592@proton.me/

 [1]
Signed-off-by: default avatarBenno Lossin <benno.lossin@proton.me>
Reviewed-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Reviewed-by: default avatarGary Guo <gary@garyguo.net>
Link: https://lore.kernel.org/r/20240819112415.99810-2-benno.lossin@proton.me


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

rust/kernel/init.rs

+60 −24
Original line number Diff line number Diff line
@@ -1183,13 +1183,7 @@ fn try_pin_init<E>(init: impl PinInit<T, E>, flags: Flags) -> Result<Self::Pinne 
    where

        E: From<AllocError>,

    {

        let mut this = <Box<_> as BoxExt<_>>::new_uninit(flags)?;

        let slot = this.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid and will not be moved, because we pin it later.

        unsafe { init.__pinned_init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { this.assume_init() }.into())

        <Box<_> as BoxExt<_>>::new_uninit(flags)?.write_pin_init(init)

    }



    #[inline]
@@ -1197,13 +1191,7 @@ fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> 
    where

        E: From<AllocError>,

    {

        let mut this = <Box<_> as BoxExt<_>>::new_uninit(flags)?;

        let slot = this.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid.

        unsafe { init.__init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { this.assume_init() })

        <Box<_> as BoxExt<_>>::new_uninit(flags)?.write_init(init)

    }

}
@@ -1215,13 +1203,7 @@ fn try_pin_init<E>(init: impl PinInit<T, E>, flags: Flags) -> Result<Self::Pinne 
    where

        E: From<AllocError>,

    {

        let mut this = UniqueArc::new_uninit(flags)?;

        let slot = this.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid and will not be moved, because we pin it later.

        unsafe { init.__pinned_init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { this.assume_init() }.into())

        UniqueArc::new_uninit(flags)?.write_pin_init(init)

    }



    #[inline]
@@ -1229,13 +1211,67 @@ fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E> 
    where

        E: From<AllocError>,

    {

        let mut this = UniqueArc::new_uninit(flags)?;

        let slot = this.as_mut_ptr();

        UniqueArc::new_uninit(flags)?.write_init(init)

    }

}



/// Smart pointer containing uninitialized memory and that can write a value.

pub trait InPlaceWrite<T> {

    /// The type `Self` turns into when the contents are initialized.

    type Initialized;



    /// Use the given initializer to write a value into `self`.

    ///

    /// Does not drop the current value and considers it as uninitialized memory.

    fn write_init<E>(self, init: impl Init<T, E>) -> Result<Self::Initialized, E>;



    /// Use the given pin-initializer to write a value into `self`.

    ///

    /// Does not drop the current value and considers it as uninitialized memory.

    fn write_pin_init<E>(self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E>;

}



impl<T> InPlaceWrite<T> for Box<MaybeUninit<T>> {

    type Initialized = Box<T>;



    fn write_init<E>(mut self, init: impl Init<T, E>) -> Result<Self::Initialized, E> {

        let slot = self.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid.

        unsafe { init.__init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { this.assume_init() })

        Ok(unsafe { self.assume_init() })

    }



    fn write_pin_init<E>(mut self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E> {

        let slot = self.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid and will not be moved, because we pin it later.

        unsafe { init.__pinned_init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { self.assume_init() }.into())

    }

}



impl<T> InPlaceWrite<T> for UniqueArc<MaybeUninit<T>> {

    type Initialized = UniqueArc<T>;



    fn write_init<E>(mut self, init: impl Init<T, E>) -> Result<Self::Initialized, E> {

        let slot = self.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid.

        unsafe { init.__init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { self.assume_init() })

    }



    fn write_pin_init<E>(mut self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E> {

        let slot = self.as_mut_ptr();

        // SAFETY: When init errors/panics, slot will get deallocated but not dropped,

        // slot is valid and will not be moved, because we pin it later.

        unsafe { init.__pinned_init(slot)? };

        // SAFETY: All fields have been initialized.

        Ok(unsafe { self.assume_init() }.into())

    }

}

rust/kernel/prelude.rs

+1 −1
Original line number Diff line number Diff line
@@ -37,6 +37,6 @@ 


pub use super::{str::CStr, ThisModule};



pub use super::init::{InPlaceInit, Init, PinInit};

pub use super::init::{InPlaceInit, InPlaceWrite, Init, PinInit};



pub use super::current;