Commit 14648fc3 authored by Danilo Krummrich's avatar Danilo Krummrich
Browse files

Merge tag 'pin-init-v6.17-result-blanket' of https://github.com/Rust-for-Linux/linux.git 

pin-init blanket implementation changes for v6.17

Remove the error from the blanket implementations for `[Pin]Init` and
add implementations for `Result`.

(Subsequent Devres improvements depend on those pin-init features.)
parents 64888dfd e832374c

rust/kernel/block/mq/tag_set.rs

+7 −5
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 
use crate::{

    bindings,

    block::mq::{operations::OperationsVTable, request::RequestDataWrapper, Operations},

    error,

    error::{self, Result},

    prelude::try_pin_init,

    types::Opaque,

};
@@ -41,7 +41,7 @@ pub fn new( 
        // SAFETY: `blk_mq_tag_set` only contains integers and pointers, which

        // all are allowed to be 0.

        let tag_set: bindings::blk_mq_tag_set = unsafe { core::mem::zeroed() };

        let tag_set = core::mem::size_of::<RequestDataWrapper>()

        let tag_set: Result<_> = core::mem::size_of::<RequestDataWrapper>()

            .try_into()

            .map(|cmd_size| {

                bindings::blk_mq_tag_set {
@@ -56,12 +56,14 @@ pub fn new( 
                    nr_maps: num_maps,

                    ..tag_set

                }

            });

            })

            .map(Opaque::new)

            .map_err(|e| e.into());



        try_pin_init!(TagSet {

            inner <- PinInit::<_, error::Error>::pin_chain(Opaque::new(tag_set?), |tag_set| {

            inner <- tag_set.pin_chain(|tag_set| {

                // SAFETY: we do not move out of `tag_set`.

                let tag_set = unsafe { Pin::get_unchecked_mut(tag_set) };

                let tag_set: &mut Opaque<_> = unsafe { Pin::get_unchecked_mut(tag_set) };

                // SAFETY: `tag_set` is a reference to an initialized `blk_mq_tag_set`.

                error::to_result( unsafe { bindings::blk_mq_alloc_tag_set(tag_set.get())})

            }),

rust/pin-init/src/lib.rs

+32 −8
Original line number Diff line number Diff line
@@ -1390,20 +1390,44 @@ pub fn pin_init_array_from_fn<I, const N: usize, T, E>( 
    unsafe { pin_init_from_closure(init) }

}



// SAFETY: Every type can be initialized by-value.

unsafe impl<T, E> Init<T, E> for T {

    unsafe fn __init(self, slot: *mut T) -> Result<(), E> {

        // SAFETY: TODO.

// SAFETY: the `__init` function always returns `Ok(())` and initializes every field of `slot`.

unsafe impl<T> Init<T> for T {

    unsafe fn __init(self, slot: *mut T) -> Result<(), Infallible> {

        // SAFETY: `slot` is valid for writes by the safety requirements of this function.

        unsafe { slot.write(self) };

        Ok(())

    }

}



// SAFETY: Every type can be initialized by-value. `__pinned_init` calls `__init`.

unsafe impl<T, E> PinInit<T, E> for T {

// SAFETY: the `__pinned_init` function always returns `Ok(())` and initializes every field of

// `slot`. Additionally, all pinning invariants of `T` are upheld.

unsafe impl<T> PinInit<T> for T {

    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), Infallible> {

        // SAFETY: `slot` is valid for writes by the safety requirements of this function.

        unsafe { slot.write(self) };

        Ok(())

    }

}



// SAFETY: when the `__init` function returns with

// - `Ok(())`, `slot` was initialized and all pinned invariants of `T` are upheld.

// - `Err(err)`, slot was not written to.

unsafe impl<T, E> Init<T, E> for Result<T, E> {

    unsafe fn __init(self, slot: *mut T) -> Result<(), E> {

        // SAFETY: `slot` is valid for writes by the safety requirements of this function.

        unsafe { slot.write(self?) };

        Ok(())

    }

}



// SAFETY: when the `__pinned_init` function returns with

// - `Ok(())`, `slot` was initialized and all pinned invariants of `T` are upheld.

// - `Err(err)`, slot was not written to.

unsafe impl<T, E> PinInit<T, E> for Result<T, E> {

    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {

        // SAFETY: TODO.

        unsafe { self.__init(slot) }

        // SAFETY: `slot` is valid for writes by the safety requirements of this function.

        unsafe { slot.write(self?) };

        Ok(())

    }

}