Re: [RFC PATCH 2/8] rust: kernel: add `request` related TargetOperations

[Benno Lossin]

> - Add `request` related and end_io TargetOperations.
> - Add a dummy `request` wrapper and `blk_status_t`.
> 
> Signed-off-by: Qingsong Chen <changxian.cqs@xxxxxxxxxxxx>
> ---
>  rust/kernel/device_mapper.rs | 199 +++++++++++++++++++++++++++++++++++
>  1 file changed, 199 insertions(+)
> 
> diff --git a/rust/kernel/device_mapper.rs b/rust/kernel/device_mapper.rs
> index 28286b373b59..153bae3aad79 100644
> --- a/rust/kernel/device_mapper.rs
> +++ b/rust/kernel/device_mapper.rs
> @@ -31,6 +31,39 @@ pub trait TargetOperations: Sized {
>      /// Map block IOs. Return [`MapState`] to indicate how to handle the `bio`
>      /// later (end or resubmit).
>      fn map(t: &mut Target<Self>, bio: Pin<&mut Bio>) -> MapState;
> +
> +    /// Map `request`. Return [`MapState`] and the optional cloned `request`.
> +    #[allow(unused)]
> +    fn clone_and_map_rq<'a>(
> +        t: &mut Target<Self>,
> +        rq: Pin<&mut Request>,
> +        map_ctx: &mut MapInfo,
> +    ) -> (MapState, Option<Pin<&'a mut Request>>) {
> +        unimplemented!()

Note that these should be implemented when you submit this as an actual
patch. (Not sure what you would do in this case, but throwing a panic is
not a good idea.) This also applies to all subsequent patches.
I think you might have done this, because you want the C side to choose
the default implementation. But it should also be possible to call these
from the Rust side.

--
Cheers,
Benno

> +    }
> +
> +    /// Release the cloned `request`.
> +    #[allow(unused)]
> +    fn release_clone_rq(rq: Pin<&mut Request>, map_ctx: &mut MapInfo) {
> +        unimplemented!()
> +    }
> +
> +    /// End the `bio`. Return [`EndState`] and [`BlkStatus`].
> +    #[allow(unused)]
> +    fn end_io(t: &mut Target<Self>, bio: Pin<&mut Bio>) -> (EndState, BlkStatus) {
> +        unimplemented!()
> +    }
> +
> +    /// End the `request`. Return [`EndState`].
> +    #[allow(unused)]
> +    fn rq_end_io(
> +        t: &mut Target<Self>,
> +        rq: Pin<&mut Request>,
> +        map_ctx: &mut MapInfo,
> +        err: BlkStatus,
> +    ) -> EndState {
> +        unimplemented!()
> +    }
>  }
> 
>  /// Wrap the kernel struct `target_type`.
> @@ -85,6 +118,18 @@ pub fn register<T: TargetOperations>(
>                      (HAS_CTR, ctr, dm_ctr_fn),
>                      (HAS_DTR, dtr, dm_dtr_fn),
>                      (HAS_MAP, map, dm_map_fn),
> +                    (
> +                        HAS_CLONE_AND_MAP_RQ,
> +                        clone_and_map_rq,
> +                        dm_clone_and_map_request_fn
> +                    ),
> +                    (
> +                        HAS_RELEASE_CLONE_RQ,
> +                        release_clone_rq,
> +                        dm_release_clone_request_fn
> +                    ),
> +                    (HAS_END_IO, end_io, dm_endio_fn),
> +                    (HAS_RQ_END_IO, rq_end_io, dm_request_endio_fn),
>                  );
> 
>                  to_result(bindings::dm_register_target(tt))
> @@ -148,6 +193,64 @@ impl TargetType {
>              T::map(t, bio) as _
>          }
>      }
> +    unsafe extern "C" fn dm_clone_and_map_request_fn<T: TargetOperations>(
> +        ti: *mut bindings::dm_target,
> +        rq: *mut bindings::request,
> +        map_context: *mut bindings::map_info,
> +        clone: *mut *mut bindings::request,
> +    ) -> core::ffi::c_int {
> +        // SAFETY: the kernel should pass valid `dm_target`, `request`
> +        // and `map_info` pointers.
> +        unsafe {
> +            let t = Target::borrow_mut(ti);
> +            let rq = Request::from_raw(rq);
> +            let map_ctx = MapInfo::borrow_mut(map_context);
> +            let (map_state, rq_cloned) = T::clone_and_map_rq(t, rq, map_ctx);
> +            *clone = rq_cloned.map_or(core::ptr::null_mut(), |rq| rq.opaque.get());
> +            map_state as _
> +        }
> +    }
> +    unsafe extern "C" fn dm_release_clone_request_fn<T: TargetOperations>(
> +        clone: *mut bindings::request,
> +        map_context: *mut bindings::map_info,
> +    ) {
> +        // SAFETY: the kernel should pass valid `request` and `map_info` pointers.
> +        unsafe {
> +            let rq = Request::from_raw(clone);
> +            let map_ctx = MapInfo::borrow_mut(map_context);
> +            T::release_clone_rq(rq, map_ctx);
> +        }
> +    }
> +    unsafe extern "C" fn dm_endio_fn<T: TargetOperations>(
> +        ti: *mut bindings::dm_target,
> +        bio: *mut bindings::bio,
> +        error: *mut bindings::blk_status_t,
> +    ) -> core::ffi::c_int {
> +        // SAFETY: the kernel should pass valid `dm_target`, `bio` and
> +        // `error` pointers.
> +        unsafe {
> +            let t = Target::borrow_mut(ti);
> +            let bio = Bio::from_raw(bio);
> +            let (end_state, blk_status) = T::end_io(t, bio);
> +            *error = blk_status as _;
> +            end_state as _
> +        }
> +    }
> +    unsafe extern "C" fn dm_request_endio_fn<T: TargetOperations>(
> +        ti: *mut bindings::dm_target,
> +        clone: *mut bindings::request,
> +        error: bindings::blk_status_t,
> +        map_context: *mut bindings::map_info,
> +    ) -> core::ffi::c_int {
> +        // SAFETY: the kernel should pass valid `dm_target`, `request`
> +        // and `map_info` pointers.
> +        unsafe {
> +            let t = Target::borrow_mut(ti);
> +            let rq = Request::from_raw(clone);
> +            let map_ctx = MapInfo::borrow_mut(map_context);
> +            T::rq_end_io(t, rq, map_ctx, (error as u32).into()) as _
> +        }
> +    }
>  }
> 
>  /// Wrap the kernel struct `dm_target`.
> @@ -305,6 +408,33 @@ pub enum MapState {
>      Kill = bindings::DM_MAPIO_KILL,
>  }
> 
> +/// The return values of target end_io function.
> +#[repr(u32)]
> +pub enum EndState {
> +    /// Ended successfully.
> +    Done = bindings::DM_ENDIO_DONE,
> +
> +    /// The io has still not completed (eg, multipath target might
> +    /// want to requeue a failed io).
> +    Incomplete = bindings::DM_ENDIO_INCOMPLETE,
> +
> +    /// The target wants to requeue the io.
> +    Requeue = bindings::DM_ENDIO_REQUEUE,
> +
> +    /// The target wants to requeue the io after a delay.
> +    DelayRequeue = bindings::DM_ENDIO_DELAY_REQUEUE,
> +}
> +
> +/// Wrap the c struct `map_info`.
> +pub struct MapInfo(Opaque<bindings::map_info>);
> +
> +impl MapInfo {
> +    unsafe fn borrow_mut<'a>(ptr: *mut bindings::map_info) -> &'a mut Self {
> +        // SAFETY: the caller should pass a valid `ptr`.
> +        unsafe { &mut *(ptr as *mut Self) }
> +    }
> +}
> +
>  /// Wrap the `c_char` arguments, which yields `CStr`.
>  pub struct Args {
>      argc: core::ffi::c_uint,
> @@ -380,3 +510,72 @@ pub fn is_write(&self) -> bool {
>          self.op_and_flags() & bindings::req_op_REQ_OP_WRITE != 0
>      }
>  }
> +
> +/// Wrap the kernel struct `request`.
> +///
> +/// Dummy.
> +#[pin_data]
> +pub struct Request {
> +    #[pin]
> +    opaque: Opaque<bindings::request>,
> +}
> +
> +impl Request {
> +    unsafe fn from_raw<'a>(ptr: *mut bindings::request) -> Pin<&'a mut Self> {
> +        // SAFETY: the caller should pass a valid `request` pointer.
> +        unsafe { Pin::new_unchecked(&mut *(ptr as *mut Self)) }
> +    }
> +}
> +
> +/// Wrap the block error status values (see [blk_status_t]).
> +///
> +/// [`blk_status_t`]: ../../../../include/linux/blk_types.h
> +#[repr(u32)]
> +#[allow(missing_docs)]
> +pub enum BlkStatus {
> +    Ok,
> +    NotSupp,
> +    TimeOut,
> +    NoSpc,
> +    Transport,
> +    Target,
> +    Nexus,
> +    Medium,
> +    Protection,
> +    Resource,
> +    IoErr,
> +    DmRequeue,
> +    Again,
> +    DevResource,
> +    ZoneResource,
> +    ZoneOpenResource,
> +    ZoneActiveResource,
> +    Offline,
> +    Undefined,
> +}
> +
> +impl From<u32> for BlkStatus {
> +    fn from(value: u32) -> Self {
> +        match value {
> +            0 => Self::Ok,
> +            1 => Self::NotSupp,
> +            2 => Self::TimeOut,
> +            3 => Self::NoSpc,
> +            4 => Self::Transport,
> +            5 => Self::Target,
> +            6 => Self::Nexus,
> +            7 => Self::Medium,
> +            8 => Self::Protection,
> +            9 => Self::Resource,
> +            10 => Self::IoErr,
> +            11 => Self::DmRequeue,
> +            12 => Self::Again,
> +            13 => Self::DevResource,
> +            14 => Self::ZoneResource,
> +            15 => Self::ZoneOpenResource,
> +            16 => Self::ZoneActiveResource,
> +            17 => Self::Offline,
> +            _ => Self::Undefined,
> +        }
> +    }
> +}
> --
> 2.40.1
>