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

[Qingsong Chen]

- 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!()
+    }
+
+    /// 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