Merge branch 'rust-vmm:main' into issue123-typed-ring-accessors

Author: wongnelson

rust-vmm-ci

@@ -62,7 +62,7 @@ impl Display for Error {
         match self {
             DescriptorChainTooShort => write!(f, "descriptor chain too short"),
             DescriptorLengthTooSmall => write!(f, "descriptor length too small"),
-            GuestMemory(ref err) => write!(f, "error accessing guest memory: {}", err),
+            GuestMemory(ref err) => write!(f, "error accessing guest memory: {err}"),
             InvalidFlushSector => write!(f, "invalid sector in flush request, it should be 0"),
             UnexpectedReadOnlyDescriptor => write!(f, "unexpected read only descriptor"),
             UnexpectedWriteOnlyDescriptor => write!(f, "unexpected write only descriptor"),
@@ -207,8 +207,8 @@ impl Request {
     /// descriptor (the chain tail) is device-writable.
     ///
     /// # Arguments
-    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the
-    ///                  buffers of a virtio block request.
+    ///
+    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the buffers of a virtio block request.
     pub fn parse<M>(desc_chain: &mut DescriptorChain<M>) -> Result<Request>
     where
         M: Deref,
@@ -269,7 +269,7 @@ mod tests {
                 (DescriptorChainTooShort, DescriptorChainTooShort) => true,
                 (DescriptorLengthTooSmall, DescriptorLengthTooSmall) => true,
                 (GuestMemory(ref e), GuestMemory(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (InvalidFlushSector, InvalidFlushSector) => true,
                 (UnexpectedReadOnlyDescriptor, UnexpectedReadOnlyDescriptor) => true,

virtio-blk/src/request.rs

@@ -129,22 +129,22 @@ impl Display for Error {
 
         match self {
             DiscardWriteZeroes(ref err) => {
-                write!(f, "discard/write zeroes execution failed: {}", err)
+                write!(f, "discard/write zeroes execution failed: {err}")
             }
-            Flush(ref err) => write!(f, "flush execution failed: {}", err),
-            GuestMemory(ref err) => write!(f, "error accessing guest memory: {}", err),
+            Flush(ref err) => write!(f, "flush execution failed: {err}"),
+            GuestMemory(ref err) => write!(f, "error accessing guest memory: {err}"),
             InvalidAccess => write!(f, "invalid file access"),
             InvalidDataLength => write!(f, "invalid data length of request"),
             InvalidFlags => write!(f, "invalid flags for discard/write zeroes request"),
             Overflow => write!(f, "overflow when computing memory address"),
-            Read(ref err, _) => write!(f, "error during read request execution: {}", err),
+            Read(ref err, _) => write!(f, "error during read request execution: {err}"),
             ReadOnly => write!(
                 f,
                 "can't execute an operation other than `read` on a read-only device"
             ),
-            Write(ref err) => write!(f, "error during write request execution: {}", err),
-            Seek(ref err) => write!(f, "file seek execution failed: {}", err),
-            Unsupported(t) => write!(f, "can't execute unsupported request {}", t),
+            Write(ref err) => write!(f, "error during write request execution: {err}"),
+            Seek(ref err) => write!(f, "file seek execution failed: {err}"),
+            Unsupported(t) => write!(f, "can't execute unsupported request {t}"),
         }
     }
 }
@@ -224,8 +224,8 @@ impl<B: Backend> StdIoBackend<B> {
     /// Sets the `device_id`.
     ///
     /// # Arguments
-    /// * `device_id` - The block device id. On Linux guests, this information can be read from
-    ///                 `/sys/block/<device>/serial`.
+    ///
+    /// * `device_id` - The block device id. On Linux guests, this information can be read from `/sys/block/<device>/serial`.
     pub fn with_device_id(mut self, device_id: [u8; VIRTIO_BLK_ID_BYTES as usize]) -> Self {
         self.device_id = Some(device_id);
         self
@@ -244,6 +244,7 @@ impl<B: Backend> StdIoBackend<B> {
     /// byte).
     ///
     /// # Arguments
+    ///
     /// * `mem` - A reference to the guest memory.
     /// * `request` - The request to execute.
     pub fn process_request<M: GuestMemory>(
@@ -506,22 +507,22 @@ mod tests {
             use self::Error::*;
             match (self, other) {
                 (DiscardWriteZeroes(ref e), DiscardWriteZeroes(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
-                (Flush(ref e), Flush(ref other_e)) => format!("{}", e).eq(&format!("{}", other_e)),
+                (Flush(ref e), Flush(ref other_e)) => format!("{e}").eq(&format!("{other_e}")),
                 (GuestMemory(ref e), GuestMemory(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (InvalidAccess, InvalidAccess) => true,
                 (InvalidDataLength, InvalidDataLength) => true,
                 (InvalidFlags, InvalidFlags) => true,
                 (Overflow, Overflow) => true,
                 (Read(ref e, bytes), Read(ref other_e, other_bytes)) => {
-                    format!("{}", e).eq(&format!("{}", other_e)) && bytes == other_bytes
+                    format!("{e}").eq(&format!("{other_e}")) && bytes == other_bytes
                 }
                 (ReadOnly, ReadOnly) => true,
-                (Write(ref e), Write(ref other_e)) => format!("{}", e).eq(&format!("{}", other_e)),
-                (Seek(ref e), Seek(ref other_e)) => format!("{}", e).eq(&format!("{}", other_e)),
+                (Write(ref e), Write(ref other_e)) => format!("{e}").eq(&format!("{other_e}")),
+                (Seek(ref e), Seek(ref other_e)) => format!("{e}").eq(&format!("{other_e}")),
                 (Unsupported(val), Unsupported(other_val)) => val == other_val,
                 _ => false,
             }

virtio-blk/src/stdio_executor.rs

@@ -46,10 +46,10 @@ impl Display for Error {
 
         match self {
             WriteToGuestFailed(ref err) => {
-                write!(f, "Console failed to write slice to guest memory: {}", err)
+                write!(f, "Console failed to write slice to guest memory: {err}")
             }
             WriteToOutputFailed(ref err) => {
-                write!(f, "Console failed to write data to output sink: {}", err)
+                write!(f, "Console failed to write data to output sink: {err}")
             }
             ChainLengthOverflow => {
                 write!(f, "Console transmitq chain length has overflown usize.")
@@ -73,7 +73,7 @@ impl Display for Error {
                 )
             }
             OutputSinkFlushFailed(ref err) => {
-                write!(f, "Output sink flush has not written all bytes: {}", err)
+                write!(f, "Output sink flush has not written all bytes: {err}")
             }
         }
     }
@@ -115,9 +115,11 @@ where
     /// Create new console object with the default `capacity`.
     ///
     /// # Arguments
-    /// * `output` - The output sink where all the data received from
-    ///              the transmitq will be written.
+    ///
+    /// * `output` - The output sink where all the data received from the transmitq will be written.
+    ///
     /// # Returns
+    ///
     /// The console object.
     pub fn new(output: T) -> Self {
         Self::new_with_capacity(DEFAULT_CAPACITY, output).unwrap()
@@ -126,10 +128,12 @@ where
     /// Create new console object with specified `capacity`.
     ///
     /// # Arguments
+    ///
     /// * `capacity` - The capacity of the input buffer.
-    /// * `output` - The output sink where all the data received from
-    ///              the transmitq will be written.
+    /// * `output` - The output sink where all the data received from the transmitq will be written.
+    ///
     /// # Returns
+    ///
     /// The console object or an `Error` if the capacity is 0 or higher than [`MAX_CAPACITY`].
     pub fn new_with_capacity(capacity: usize, output: T) -> Result<Self, Error> {
         // There is no use case for 0 capacity
@@ -150,8 +154,8 @@ where
     /// returned.
     ///
     /// # Arguments
-    /// * `data` - A mutable reference to a `Vec<u8>` containing the raw bytes that will be
-    ///            sent to the driver when the `process_receiveq_chain` method is called.
+    ///
+    /// * `data` - A mutable reference to a `Vec<u8>` containing the raw bytes that will be sent to the driver when the `process_receiveq_chain` method is called.
     pub fn enqueue_data(&self, data: &mut Vec<u8>) -> Result<(), Error> {
         let mut input_buffer = self.input_buffer.lock().unwrap();
         let total_length = input_buffer
@@ -189,8 +193,8 @@ where
     /// Read data from a `desc_chain` of the transmit queue and write it to the output sink.
     ///
     /// # Arguments
-    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the
-    ///                  buffers that the virtio console driver has sent to the device.
+    ///
+    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the buffers that the virtio console driver has sent to the device.
     pub fn process_transmitq_chain<M>(
         &mut self,
         desc_chain: &mut DescriptorChain<M>,
@@ -224,9 +228,11 @@ where
     /// add more.
     ///
     /// # Arguments
-    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the
-    ///                  empty buffers that the virtio driver has offered the device.
+    ///
+    /// * `desc_chain` - A mutable reference to the descriptor chain that should point to the empty buffers that the virtio driver has offered the device.
+    ///
     /// # Returns
+    ///
     /// The number of raw bytes written to guest memory.
     pub fn process_receiveq_chain<M>(
         &self,
@@ -291,10 +297,10 @@ mod tests {
             use self::Error::*;
             match (self, other) {
                 (WriteToGuestFailed(ref e), WriteToGuestFailed(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (WriteToOutputFailed(ref e), WriteToOutputFailed(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (ChainLengthOverflow, ChainLengthOverflow) => true,
                 (BufferCapacityExceeded, BufferCapacityExceeded) => true,

virtio-console/src/console.rs

@@ -58,7 +58,7 @@ pub fn benchmark_queue(c: &mut Criterion) {
     for indirect in [false, true].iter().copied() {
         bench_queue(
             c,
-            &format!("single chain (indirect={})", indirect),
+            &format!("single chain (indirect={indirect})"),
             || queue_with_chains(1, 128, indirect),
             |mut q| {
                 let (num_chains, num_descriptors) = walk_queue(&mut q, &mem);
@@ -69,7 +69,7 @@ pub fn benchmark_queue(c: &mut Criterion) {
 
         bench_queue(
             c,
-            &format!("multiple chains (indirect={})", indirect),
+            &format!("multiple chains (indirect={indirect})"),
             || queue_with_chains(128, 1, indirect),
             |mut q| {
                 let (num_chains, num_descriptors) = walk_queue(&mut q, &mem);

virtio-queue/benches/queue/mod.rs

@@ -60,11 +60,10 @@ where
     /// Create a new `DescriptorChain` instance.
     ///
     /// # Arguments
-    /// * `mem` - the `GuestMemory` object that can be used to access the buffers pointed to by the
-    ///           descriptor chain.
+    ///
+    /// * `mem` - the `GuestMemory` object that can be used to access the buffers pointed to by the descriptor chain.
     /// * `desc_table` - the address of the descriptor table.
-    /// * `queue_size` - the size of the queue, which is also the maximum size of a descriptor
-    ///                  chain.
+    /// * `queue_size` - the size of the queue, which is also the maximum size of a descriptor chain.
     /// * `head_index` - the descriptor index of the chain head.
     pub(crate) fn new(mem: M, desc_table: GuestAddress, queue_size: u16, head_index: u16) -> Self {
         Self::with_ttl(mem, desc_table, queue_size, queue_size, head_index)

virtio-queue/src/chain.rs

@@ -482,14 +482,14 @@ mod tests {
 
         let mut buffer = [0_u8; 64];
         if let Err(e) = reader.read_exact(&mut buffer) {
-            panic!("read_exact should not fail here: {:?}", e);
+            panic!("read_exact should not fail here: {e:?}");
         }
 
         assert_eq!(reader.available_bytes(), 42);
         assert_eq!(reader.bytes_read(), 64);
 
         match reader.read(&mut buffer) {
-            Err(e) => panic!("read should not fail here: {:?}", e),
+            Err(e) => panic!("read should not fail here: {e:?}"),
             Ok(length) => assert_eq!(length, 42),
         }
 
@@ -522,14 +522,14 @@ mod tests {
 
         let buffer = [0_u8; 64];
         if let Err(e) = writer.write_all(&buffer) {
-            panic!("write_all should not fail here: {:?}", e);
+            panic!("write_all should not fail here: {e:?}");
         }
 
         assert_eq!(writer.available_bytes(), 42);
         assert_eq!(writer.bytes_written(), 64);
 
         match writer.write(&buffer) {
-            Err(e) => panic!("write should not fail here {:?}", e),
+            Err(e) => panic!("write should not fail here {e:?}"),
             Ok(length) => assert_eq!(length, 42),
         }
 
@@ -641,7 +641,7 @@ mod tests {
         .expect("create_descriptor_chain failed");
         let mut writer = Writer::new(&memory, chain_writer).expect("failed to create Writer");
         if let Err(e) = writer.write_obj(secret) {
-            panic!("write_obj should not fail here: {:?}", e);
+            panic!("write_obj should not fail here: {e:?}");
         }
 
         // Now create new descriptor chain pointing to the same memory and try to read it.
@@ -654,7 +654,7 @@ mod tests {
         .expect("create_descriptor_chain failed");
         let mut reader = Reader::new(&memory, chain_reader).expect("failed to create Reader");
         match reader.read_obj::<Le32>() {
-            Err(e) => panic!("read_obj should not fail here: {:?}", e),
+            Err(e) => panic!("read_obj should not fail here: {e:?}"),
             Ok(read_secret) => assert_eq!(read_secret, secret),
         }
     }

virtio-queue/src/descriptor_utils.rs

@@ -49,7 +49,7 @@ impl Display for MockError {
                 f,
                 "invalid next available descriptor chain head in the queue"
             ),
-            GuestMem(e) => write!(f, "guest memory error: {}", e),
+            GuestMem(e) => write!(f, "guest memory error: {e}"),
         }
     }
 }

virtio-queue/src/mock.rs

@@ -690,11 +690,10 @@ where
     /// Create a new instance of `AvailInter`.
     ///
     /// # Arguments
+    ///
     /// * `mem` - the `GuestMemory` object that can be used to access the queue buffers.
-    /// * `idx` - the index of the available ring entry where the driver would put the next
-    ///           available descriptor chain.
-    /// * `queue` - the `Queue` object from which the needed data to create the `AvailIter` can
-    ///             be retrieved.
+    /// * `idx` - the index of the available ring entry where the driver would put the next available descriptor chain.
+    /// * `queue` - the `Queue` object from which the needed data to create the `AvailIter` can be retrieved.
     pub(crate) fn new(mem: M, idx: Wrapping<u16>, queue: &'b mut Queue) -> Result<Self, Error> {
         // The number of descriptor chain heads to process should always
         // be smaller or equal to the queue size, as the driver should
@@ -770,7 +769,7 @@ where
 // proper implementation as `GuestMemory` errors cannot implement `PartialEq`.
 impl PartialEq for Error {
     fn eq(&self, other: &Self) -> bool {
-        format!("{}", &self) == format!("{}", other)
+        format!("{}", &self) == format!("{other}")
     }
 }
 

virtio-queue/src/queue.rs

@@ -82,16 +82,16 @@ impl Display for Error {
                 "The descriptor is pointing to a buffer that has a longer length than expected."
             ),
             Error::InvalidHeaderInputSize(size) => {
-                write!(f, "Invalid header input size: {}", size)
+                write!(f, "Invalid header input size: {size}")
             }
             Error::InvalidHeaderLen(size) => {
-                write!(f, "Invalid header `len` field value: {}", size)
+                write!(f, "Invalid header `len` field value: {size}")
             }
             Error::InvalidMemoryAccess(error) => {
-                write!(f, "Invalid guest memory access: {}", error)
+                write!(f, "Invalid guest memory access: {error}")
             }
             Error::InvalidVolatileAccess(error) => {
-                write!(f, "Invalid volatile memory access: {}", error)
+                write!(f, "Invalid volatile memory access: {error}")
             }
             Error::UnexpectedReadOnlyDescriptor => {
                 write!(f, "Unexpected read-only descriptor.")
@@ -363,12 +363,10 @@ impl<'a, B: BitmapSlice> VsockPacket<'a, B> {
     /// descriptor can optionally end the chain.
     ///
     /// # Arguments
+    ///
     /// * `mem` - the `GuestMemory` object that can be used to access the queue buffers.
     /// * `desc_chain` - the descriptor chain corresponding to a packet.
-    /// * `max_data_size` - the maximum size allowed for the packet payload, that was negotiated
-    ///                     between the device and the driver. Tracking issue for defining this
-    ///                     feature in virtio-spec
-    ///                     [here](https://github.com/oasis-tcs/virtio-spec/issues/140).
+    /// * `max_data_size` - the maximum size allowed for the packet payload, that was negotiated between the device and the driver. Tracking issue for defining this feature in virtio-spec [here](https://github.com/oasis-tcs/virtio-spec/issues/140).
     ///
     /// # Example
     ///
@@ -504,12 +502,10 @@ impl<'a, B: BitmapSlice> VsockPacket<'a, B> {
     /// descriptor.
     ///
     /// # Arguments
+    ///
     /// * `mem` - the `GuestMemory` object that can be used to access the queue buffers.
     /// * `desc_chain` - the descriptor chain corresponding to a packet.
-    /// * `max_data_size` - the maximum size allowed for the packet payload, that was negotiated
-    ///                     between the device and the driver. Tracking issue for defining this
-    ///                     feature in virtio-spec
-    ///                     [here](https://github.com/oasis-tcs/virtio-spec/issues/140).
+    /// * `max_data_size` - the maximum size allowed for the packet payload, that was negotiated between the device and the driver. Tracking issue for defining this feature in virtio-spec [here](https://github.com/oasis-tcs/virtio-spec/issues/140).
     ///
     /// # Example
     ///
@@ -699,10 +695,10 @@ mod tests {
                 }
                 (InvalidHeaderLen(size), InvalidHeaderLen(other_size)) => size == other_size,
                 (InvalidMemoryAccess(ref e), InvalidMemoryAccess(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (InvalidVolatileAccess(ref e), InvalidVolatileAccess(ref other_e)) => {
-                    format!("{}", e).eq(&format!("{}", other_e))
+                    format!("{e}").eq(&format!("{other_e}"))
                 }
                 (UnexpectedReadOnlyDescriptor, UnexpectedReadOnlyDescriptor) => true,
                 (UnexpectedWriteOnlyDescriptor, UnexpectedWriteOnlyDescriptor) => true,