refactor: Improve code readability

refactor code to improve readability and use rust idiomatic
methods like avoiding getters.

Signed-off-by: Sudan Landge <[email protected]>

Author: Sudan Landge

src/vmm/src/devices/virtio/virtio_block/io/async_io.rs

@@ -150,9 +150,9 @@ impl<T: Debug> AsyncFileEngine<T> {
                 offset,
                 wrapped_user_data,
             ))
-            .map_err(|err_tuple| UserDataError {
-                user_data: err_tuple.1.user_data,
-                error: AsyncIoError::IoUring(err_tuple.0),
+            .map_err(|(io_uring_error, data)| UserDataError {
+                user_data: data.user_data,
+                error: AsyncIoError::IoUring(io_uring_error),
             })
     }
 
@@ -184,9 +184,9 @@ impl<T: Debug> AsyncFileEngine<T> {
                 offset,
                 wrapped_user_data,
             ))
-            .map_err(|err_tuple| UserDataError {
-                user_data: err_tuple.1.user_data,
-                error: AsyncIoError::IoUring(err_tuple.0),
+            .map_err(|(io_uring_error, data)| UserDataError {
+                user_data: data.user_data,
+                error: AsyncIoError::IoUring(io_uring_error),
             })
     }
 
@@ -195,9 +195,9 @@ impl<T: Debug> AsyncFileEngine<T> {
 
         self.ring
             .push(Operation::fsync(0, wrapped_user_data))
-            .map_err(|err_tuple| UserDataError {
-                user_data: err_tuple.1.user_data,
-                error: AsyncIoError::IoUring(err_tuple.0),
+            .map_err(|(io_uring_error, data)| UserDataError {
+                user_data: data.user_data,
+                error: AsyncIoError::IoUring(io_uring_error),
             })
     }
 

src/vmm/src/io_uring/mod.rs

@@ -169,11 +169,11 @@ impl<T: Debug> IoUring<T> {
         // validate that we actually did register fds
         let fd = op.fd();
         match self.registered_fds_count {
-            0 => Err((IoUringError::NoRegisteredFds, op.user_data())),
-            len if fd >= len => Err((IoUringError::InvalidFixedFd(fd), op.user_data())),
+            0 => Err((IoUringError::NoRegisteredFds, op.user_data)),
+            len if fd >= len => Err((IoUringError::InvalidFixedFd(fd), op.user_data)),
             _ => {
                 if self.num_ops >= self.cqueue.count() {
-                    return Err((IoUringError::FullCQueue, op.user_data()));
+                    return Err((IoUringError::FullCQueue, op.user_data));
                 }
                 self.squeue
                     .push(op.into_sqe(&mut self.slab))
@@ -186,14 +186,14 @@ impl<T: Debug> IoUring<T> {
                         (
                             IoUringError::SQueue(sqe_err),
                             // We don't use slab.try_remove here for 2 reasons:
-                            // 1. user_data was insertde in slab with step `op.into_sqe` just
+                            // 1. user_data was inserted in slab with step `op.into_sqe` just
                             //    before the push op so the user_data key should be valid and if
                             //    key is valid then `slab.remove()` will not fail.
                             // 2. If we use `slab.try_remove()` we'll have to find a way to return
                             //    a default value for the generic type T which is difficult because
                             //    it expands to more crates which don't make it easy to define a
                             //    default/clone type for type T.
-                            // So beleiving that `slab.remove` won't fail we don't use
+                            // So believing that `slab.remove` won't fail we don't use
                             // the `slab.try_remove` method.
                             #[allow(clippy::cast_possible_truncation)]
                             self.slab.remove(user_data_key as usize),

src/vmm/src/io_uring/operation/cqe.rs

@@ -17,8 +17,8 @@ pub struct Cqe<T> {
 }
 
 impl<T: Debug> Cqe<T> {
-    /// Construct a Cqe object from a raw `io_uring_cqe`.
-    pub(crate) fn new(res: i32, user_data: T) -> Self {
+    /// Construct a Cqe object.
+    pub fn new(res: i32, user_data: T) -> Self {
         Self { res, user_data }
     }
 

src/vmm/src/io_uring/operation/mod.rs

@@ -51,7 +51,7 @@ pub struct Operation<T> {
     pub(crate) len: Option<u32>,
     flags: u8,
     pub(crate) offset: Option<u64>,
-    user_data: T,
+    pub(crate) user_data: T,
 }
 
 // Needed for proptesting.
@@ -117,11 +117,6 @@ impl<T: Debug> Operation<T> {
         self.fd
     }
 
-    /// Consumes the operation and returns the associated `user_data`.
-    pub fn user_data(self) -> T {
-        self.user_data
-    }
-
     // Needed for proptesting.
     #[cfg(test)]
     pub(crate) fn set_linked(&mut self) {

src/vmm/src/io_uring/operation/sqe.rs

@@ -24,7 +24,7 @@ impl Sqe {
         Self(inner)
     }
 
-    /// Return the `user_data`.
+    /// Return the key to the `user_data` stored in slab.
     pub(crate) fn user_data(&self) -> u64 {
         self.0.user_data
     }