chore: appear rustfmt, clippy and rustc

roypat · roypat · commit a9c504d64455 · 2025-08-27T13:14:31.000+01:00
Lots of new warnings and lints

Signed-off-by: Patrick Roy &lt;roypat@amazon.co.uk&gt;
diff --git a/src/firecracker/src/api_server/mod.rs b/src/firecracker/src/api_server/mod.rs
@@ -174,12 +174,12 @@ impl ApiServer {
         let vmm_outcome = *(self.vmm_response_receiver.recv().expect("VMM disconnected"));
         let response = ParsedRequest::convert_to_response(&vmm_outcome);
 
-        if vmm_outcome.is_ok() {
-            if let Some((metric, action)) = metric_with_action {
-                let elapsed_time_us =
-                    update_metric_with_elapsed_time(metric, request_processing_start_us);
-                info!("'{}' API request took {} us.", action, elapsed_time_us);
-            }
+        if vmm_outcome.is_ok()
+            && let Some((metric, action)) = metric_with_action
+        {
+            let elapsed_time_us =
+                update_metric_with_elapsed_time(metric, request_processing_start_us);
+            info!("'{}' API request took {} us.", action, elapsed_time_us);
         }
         response
     }
diff --git a/src/utils/src/arg_parser.rs b/src/utils/src/arg_parser.rs
@@ -77,7 +77,7 @@ impl<'a> ArgParser<'a> {
     }
 
     /// Return a reference to `arguments` field.
-    pub fn arguments(&self) -> &Arguments {
+    pub fn arguments(&self) -> &Arguments<'_> {
         &self.arguments
     }
 
@@ -368,10 +368,10 @@ impl<'a> Arguments<'a> {
             if argument.user_value.is_some() {
                 // For the arguments that require a specific argument to be also present in the list
                 // of arguments provided by user, search for that argument.
-                if let Some(arg_name) = argument.requires {
-                    if !args.contains(&(format!("--{}", arg_name))) {
-                        return Err(UtilsArgParserError::MissingArgument(arg_name.to_string()));
-                    }
+                if let Some(arg_name) = argument.requires
+                    && !args.contains(&(format!("--{}", arg_name)))
+                {
+                    return Err(UtilsArgParserError::MissingArgument(arg_name.to_string()));
                 }
                 // Check the user-provided list for potential forbidden arguments.
                 for arg_name in argument.forbids.iter() {
diff --git a/src/vmm/src/arch/x86_64/mod.rs b/src/vmm/src/arch/x86_64/mod.rs
@@ -132,19 +132,19 @@ pub fn arch_memory_regions(size: usize) -> Vec<(GuestAddress, usize)> {
         dram_size,
         u64_to_usize(MMIO32_MEM_START),
         u64_to_usize(MMIO32_MEM_SIZE),
-    ) {
-        if let Some((start_past_64bit_gap, remaining_past_64bit_gap)) = arch_memory_regions_with_gap(
+    ) && let Some((start_past_64bit_gap, remaining_past_64bit_gap)) =
+        arch_memory_regions_with_gap(
             &mut regions,
             start_past_32bit_gap,
             remaining_past_32bit_gap,
             u64_to_usize(MMIO64_MEM_START),
             u64_to_usize(MMIO64_MEM_SIZE),
-        ) {
-            regions.push((
-                GuestAddress(start_past_64bit_gap as u64),
-                remaining_past_64bit_gap,
-            ));
-        }
+        )
+    {
+        regions.push((
+            GuestAddress(start_past_64bit_gap as u64),
+            remaining_past_64bit_gap,
+        ));
     }
 
     regions
diff --git a/src/vmm/src/cpu_config/templates.rs b/src/vmm/src/cpu_config/templates.rs
@@ -49,7 +49,7 @@ pub enum GetCpuTemplateError {
 /// custom CPU templates and handle static CPU template and custom CPU template in a same manner.
 pub trait GetCpuTemplate {
     /// Get CPU template
-    fn get_cpu_template(&self) -> Result<Cow<CustomCpuTemplate>, GetCpuTemplateError>;
+    fn get_cpu_template(&self) -> Result<Cow<'_, CustomCpuTemplate>, GetCpuTemplateError>;
 }
 
 /// Enum that represents types of cpu templates available.
diff --git a/src/vmm/src/cpu_config/x86_64/custom_cpu_template.rs b/src/vmm/src/cpu_config/x86_64/custom_cpu_template.rs
@@ -19,7 +19,7 @@ use crate::cpu_config::x86_64::static_cpu_templates::{StaticCpuTemplate, c3, t2,
 use crate::logger::warn;
 
 impl GetCpuTemplate for Option<CpuTemplateType> {
-    fn get_cpu_template(&self) -> Result<Cow<CustomCpuTemplate>, GetCpuTemplateError> {
+    fn get_cpu_template(&self) -> Result<Cow<'_, CustomCpuTemplate>, GetCpuTemplateError> {
         use GetCpuTemplateError::*;
 
         match self {
diff --git a/src/vmm/src/devices/legacy/i8042.rs b/src/vmm/src/devices/legacy/i8042.rs
@@ -230,11 +230,10 @@ impl vm_device::BusDevice for I8042Device {
                 // Check if we still have data in the internal buffer. If so, we need to trigger
                 // another interrupt, to let the guest know they need to issue another read from
                 // port 0x60.
-                if (self.status & SB_OUT_DATA_AVAIL) != 0 {
-                    if let Err(I8042Error::KbdInterruptFailure(err)) = self.trigger_kbd_interrupt()
-                    {
-                        warn!("Failed to trigger i8042 kbd interrupt {:?}", err);
-                    }
+                if (self.status & SB_OUT_DATA_AVAIL) != 0
+                    && let Err(I8042Error::KbdInterruptFailure(err)) = self.trigger_kbd_interrupt()
+                {
+                    warn!("Failed to trigger i8042 kbd interrupt {:?}", err);
                 }
             }
             _ => read_ok = false,
diff --git a/src/vmm/src/devices/legacy/serial.rs b/src/vmm/src/devices/legacy/serial.rs
@@ -333,10 +333,10 @@ impl<I: Read + AsRawFd + Send + Debug> MutEventSubscriber
             // Therefore, only try to register stdin to epoll if it is a terminal or a FIFO pipe.
             // SAFETY: isatty has no invariants that need to be upheld. If serial_fd is an invalid
             // argument, it will return 0 and set errno to EBADF.
-            if unsafe { libc::isatty(serial_fd) } == 1 || is_fifo(serial_fd) {
-                if let Err(err) = ops.add(Events::new(&serial_fd, EventSet::IN)) {
-                    warn!("Failed to register serial input fd: {}", err);
-                }
+            if (unsafe { libc::isatty(serial_fd) } == 1 || is_fifo(serial_fd))
+                && let Err(err) = ops.add(Events::new(&serial_fd, EventSet::IN))
+            {
+                warn!("Failed to register serial input fd: {}", err);
             }
             if let Err(err) = ops.add(Events::new(&buf_ready_evt, EventSet::IN)) {
                 warn!("Failed to register serial buffer ready event: {}", err);
diff --git a/src/vmm/src/devices/virtio/block/device.rs b/src/vmm/src/devices/virtio/block/device.rs
@@ -41,7 +41,7 @@ impl Block {
                 VhostUserBlock::new(config).map_err(BlockError::VhostUserBackend)?,
             ))
         } else {
-            return Err(BlockError::InvalidBlockConfig);
+            Err(BlockError::InvalidBlockConfig)
         }
     }
 
diff --git a/src/vmm/src/devices/virtio/block/virtio/device.rs b/src/vmm/src/devices/virtio/block/virtio/device.rs
@@ -455,10 +455,10 @@ impl VirtioBlock {
                 });
         }
 
-        if let FileEngine::Async(ref mut engine) = self.disk.file_engine {
-            if let Err(err) = engine.kick_submission_queue() {
-                error!("BlockError submitting pending block requests: {:?}", err);
-            }
+        if let FileEngine::Async(ref mut engine) = self.disk.file_engine
+            && let Err(err) = engine.kick_submission_queue()
+        {
+            error!("BlockError submitting pending block requests: {:?}", err);
         }
 
         if !used_any {
diff --git a/src/vmm/src/devices/virtio/block/virtio/event_handler.rs b/src/vmm/src/devices/virtio/block/virtio/event_handler.rs
@@ -29,14 +29,14 @@ impl VirtioBlock {
         )) {
             error!("Failed to register ratelimiter event: {}", err);
         }
-        if let FileEngine::Async(ref engine) = self.disk.file_engine {
-            if let Err(err) = ops.add(Events::with_data(
+        if let FileEngine::Async(ref engine) = self.disk.file_engine
+            && let Err(err) = ops.add(Events::with_data(
                 engine.completion_evt(),
                 Self::PROCESS_ASYNC_COMPLETION,
                 EventSet::IN,
-            )) {
-                error!("Failed to register IO engine completion event: {}", err);
-            }
+            ))
+        {
+            error!("Failed to register IO engine completion event: {}", err);
         }
     }
 
diff --git a/src/vmm/src/devices/virtio/iovec.rs b/src/vmm/src/devices/virtio/iovec.rs
@@ -569,7 +569,7 @@ mod tests {
         ])
     }
 
-    fn chain(m: &GuestMemoryMmap, is_write_only: bool) -> (Queue, VirtQueue) {
+    fn chain(m: &GuestMemoryMmap, is_write_only: bool) -> (Queue, VirtQueue<'_>) {
         let vq = VirtQueue::new(GuestAddress(0), m, 16);
 
         let mut q = vq.create_queue();
@@ -593,14 +593,14 @@ mod tests {
         (q, vq)
     }
 
-    fn read_only_chain(mem: &GuestMemoryMmap) -> (Queue, VirtQueue) {
+    fn read_only_chain(mem: &GuestMemoryMmap) -> (Queue, VirtQueue<'_>) {
         let v: Vec<u8> = (0..=255).collect();
         mem.write_slice(&v, GuestAddress(0x20000)).unwrap();
 
         chain(mem, false)
     }
 
-    fn write_only_chain(mem: &GuestMemoryMmap) -> (Queue, VirtQueue) {
+    fn write_only_chain(mem: &GuestMemoryMmap) -> (Queue, VirtQueue<'_>) {
         let v = vec![0; 256];
         mem.write_slice(&v, GuestAddress(0x20000)).unwrap();
 
diff --git a/src/vmm/src/devices/virtio/net/device.rs b/src/vmm/src/devices/virtio/net/device.rs
@@ -525,23 +525,23 @@ impl Net {
             net_metrics.tx_malformed_frames.inc();
         })?;
 
-        if let Some(ns) = mmds_ns {
-            if ns.is_mmds_frame(headers) {
-                let mut frame = vec![0u8; frame_iovec.len() as usize - vnet_hdr_len()];
-                // Ok to unwrap here, because we are passing a buffer that has the exact size
-                // of the `IoVecBuffer` minus the VNET headers.
-                frame_iovec
-                    .read_exact_volatile_at(&mut frame, vnet_hdr_len())
-                    .unwrap();
-                let _ = ns.detour_frame(&frame);
-                METRICS.mmds.rx_accepted.inc();
+        if let Some(ns) = mmds_ns
+            && ns.is_mmds_frame(headers)
+        {
+            let mut frame = vec![0u8; frame_iovec.len() as usize - vnet_hdr_len()];
+            // Ok to unwrap here, because we are passing a buffer that has the exact size
+            // of the `IoVecBuffer` minus the VNET headers.
+            frame_iovec
+                .read_exact_volatile_at(&mut frame, vnet_hdr_len())
+                .unwrap();
+            let _ = ns.detour_frame(&frame);
+            METRICS.mmds.rx_accepted.inc();
 
-                // MMDS frames are not accounted by the rate limiter.
-                Self::rate_limiter_replenish_op(rate_limiter, u64::from(frame_iovec.len()));
+            // MMDS frames are not accounted by the rate limiter.
+            Self::rate_limiter_replenish_op(rate_limiter, u64::from(frame_iovec.len()));
 
-                // MMDS consumed the frame.
-                return Ok(true);
-            }
+            // MMDS consumed the frame.
+            return Ok(true);
         }
 
         // This frame goes to the TAP.
@@ -588,31 +588,30 @@ impl Net {
             }
         }
 
-        if let Some(ns) = self.mmds_ns.as_mut() {
-            if let Some(len) =
+        if let Some(ns) = self.mmds_ns.as_mut()
+            && let Some(len) =
                 ns.write_next_frame(frame_bytes_from_buf_mut(&mut self.rx_frame_buf)?)
-            {
-                let len = len.get();
-                METRICS.mmds.tx_frames.inc();
-                METRICS.mmds.tx_bytes.add(len as u64);
-                init_vnet_hdr(&mut self.rx_frame_buf);
-                self.rx_buffer
-                    .iovec
-                    .write_all_volatile_at(&self.rx_frame_buf[..vnet_hdr_len() + len], 0)?;
-                // SAFETY:
-                // * len will never be bigger that u32::MAX because mmds is bound
-                // by the size of `self.rx_frame_buf` which is MAX_BUFFER_SIZE size.
-                let len: u32 = (vnet_hdr_len() + len).try_into().unwrap();
-
-                // SAFETY:
-                // * We checked that `rx_buffer` includes at least one `DescriptorChain`
-                // * `rx_frame_buf` has size of `MAX_BUFFER_SIZE` and all `DescriptorChain` objects
-                //   are at least that big.
-                unsafe {
-                    self.rx_buffer.mark_used(len, &mut self.queues[RX_INDEX]);
-                }
-                return Ok(Some(len));
+        {
+            let len = len.get();
+            METRICS.mmds.tx_frames.inc();
+            METRICS.mmds.tx_bytes.add(len as u64);
+            init_vnet_hdr(&mut self.rx_frame_buf);
+            self.rx_buffer
+                .iovec
+                .write_all_volatile_at(&self.rx_frame_buf[..vnet_hdr_len() + len], 0)?;
+            // SAFETY:
+            // * len will never be bigger that u32::MAX because mmds is bound
+            // by the size of `self.rx_frame_buf` which is MAX_BUFFER_SIZE size.
+            let len: u32 = (vnet_hdr_len() + len).try_into().unwrap();
+
+            // SAFETY:
+            // * We checked that `rx_buffer` includes at least one `DescriptorChain`
+            // * `rx_frame_buf` has size of `MAX_BUFFER_SIZE` and all `DescriptorChain` objects are
+            //   at least that big.
+            unsafe {
+                self.rx_buffer.mark_used(len, &mut self.queues[RX_INDEX]);
             }
+            return Ok(Some(len));
         }
 
         // SAFETY:
diff --git a/src/vmm/src/devices/virtio/net/test_utils.rs b/src/vmm/src/devices/virtio/net/test_utils.rs
@@ -199,7 +199,7 @@ pub fn create_socket() -> File {
 }
 
 // Returns handles to virtio queues creation/activation and manipulation.
-pub fn virtqueues(mem: &GuestMemoryMmap) -> (VirtQueue, VirtQueue) {
+pub fn virtqueues(mem: &GuestMemoryMmap) -> (VirtQueue<'_>, VirtQueue<'_>) {
     let rxq = VirtQueue::new(GuestAddress(0), mem, 16);
     let txq = VirtQueue::new(GuestAddress(0x1000), mem, 16);
     assert!(rxq.end().0 < txq.start().0);
@@ -355,7 +355,7 @@ pub mod test {
             }
         }
 
-        pub fn net(&mut self) -> MutexGuard<Net> {
+        pub fn net(&mut self) -> MutexGuard<'_, Net> {
             self.net.lock().unwrap()
         }
 
diff --git a/src/vmm/src/devices/virtio/test_utils.rs b/src/vmm/src/devices/virtio/test_utils.rs
@@ -416,7 +416,7 @@ pub(crate) mod test {
         }
 
         /// Get a (locked) reference to the device
-        pub fn device(&mut self) -> MutexGuard<T> {
+        pub fn device(&mut self) -> MutexGuard<'_, T> {
             self.device.lock().unwrap()
         }
 
diff --git a/src/vmm/src/devices/virtio/transport/mmio.rs b/src/vmm/src/devices/virtio/transport/mmio.rs
@@ -84,7 +84,7 @@ impl MmioTransport {
     }
 
     /// Gets the encapsulated locked VirtioDevice.
-    pub fn locked_device(&self) -> MutexGuard<dyn VirtioDevice + 'static> {
+    pub fn locked_device(&self) -> MutexGuard<'_, dyn VirtioDevice + 'static> {
         self.device.lock().expect("Poisoned lock")
     }
 
diff --git a/src/vmm/src/devices/virtio/vhost_user.rs b/src/vmm/src/devices/virtio/vhost_user.rs
@@ -307,17 +307,16 @@ impl<T: VhostUserHandleBackend> VhostUserHandleImpl<T> {
         acked_features: u64,
         acked_protocol_features: u64,
     ) -> Result<(), VhostUserError> {
-        if acked_features & VhostUserVirtioFeatures::PROTOCOL_FEATURES.bits() != 0 {
-            if let Some(acked_protocol_features) =
+        if acked_features & VhostUserVirtioFeatures::PROTOCOL_FEATURES.bits() != 0
+            && let Some(acked_protocol_features) =
                 VhostUserProtocolFeatures::from_bits(acked_protocol_features)
-            {
-                self.vu
-                    .set_protocol_features(acked_protocol_features)
-                    .map_err(VhostUserError::VhostUserSetProtocolFeatures)?;
+        {
+            self.vu
+                .set_protocol_features(acked_protocol_features)
+                .map_err(VhostUserError::VhostUserSetProtocolFeatures)?;
 
-                if acked_protocol_features.contains(VhostUserProtocolFeatures::REPLY_ACK) {
-                    self.vu.set_hdr_flags(VhostUserHeaderFlag::NEED_REPLY);
-                }
+            if acked_protocol_features.contains(VhostUserProtocolFeatures::REPLY_ACK) {
+                self.vu.set_hdr_flags(VhostUserHeaderFlag::NEED_REPLY);
             }
         }
 
@@ -861,22 +860,22 @@ pub(crate) mod tests {
                 queue_index: usize,
                 config_data: &VringConfigData,
             ) -> Result<(), vhost::Error> {
-                unsafe { (*self.vrings.get())[queue_index].config = *config_data };
+                unsafe { (&mut (*self.vrings.get()))[queue_index].config = *config_data };
                 Ok(())
             }
 
             fn set_vring_base(&self, queue_index: usize, base: u16) -> Result<(), vhost::Error> {
-                unsafe { (*self.vrings.get())[queue_index].base = base };
+                unsafe { (&mut (*self.vrings.get()))[queue_index].base = base };
                 Ok(())
             }
 
             fn set_vring_call(&self, queue_index: usize, fd: &EventFd) -> Result<(), vhost::Error> {
-                unsafe { (*self.vrings.get())[queue_index].call = fd.as_raw_fd() };
+                unsafe { (&mut (*self.vrings.get()))[queue_index].call = fd.as_raw_fd() };
                 Ok(())
             }
 
             fn set_vring_kick(&self, queue_index: usize, fd: &EventFd) -> Result<(), vhost::Error> {
-                unsafe { (*self.vrings.get())[queue_index].kick = fd.as_raw_fd() };
+                unsafe { (&mut (*self.vrings.get()))[queue_index].kick = fd.as_raw_fd() };
                 Ok(())
             }
 
diff --git a/src/vmm/src/devices/virtio/vsock/test_utils.rs b/src/vmm/src/devices/virtio/vsock/test_utils.rs
@@ -143,7 +143,7 @@ impl TestContext {
         }
     }
 
-    pub fn create_event_handler_context(&self) -> EventHandlerContext {
+    pub fn create_event_handler_context(&self) -> EventHandlerContext<'_> {
         const QSIZE: u16 = 256;
 
         let guest_rxvq = GuestQ::new(GuestAddress(0x0010_0000), &self.mem, QSIZE);
diff --git a/src/vmm/src/devices/virtio/vsock/unix/muxer_killq.rs b/src/vmm/src/devices/virtio/vsock/unix/muxer_killq.rs
@@ -104,10 +104,10 @@ impl MuxerKillQ {
     /// This will succeed and return a connection key, only if the connection at the front of
     /// the queue has expired. Otherwise, `None` is returned.
     pub fn pop(&mut self) -> Option<ConnMapKey> {
-        if let Some(item) = self.q.front() {
-            if Instant::now() > item.kill_time {
-                return self.q.pop_front().map(|entry| entry.key);
-            }
+        if let Some(item) = self.q.front()
+            && Instant::now() > item.kill_time
+        {
+            return self.q.pop_front().map(|entry| entry.key);
         }
         None
     }
diff --git a/src/vmm/src/dumbo/pdu/ipv4.rs b/src/vmm/src/dumbo/pdu/ipv4.rs
diff --git a/src/vmm/src/dumbo/pdu/tcp.rs b/src/vmm/src/dumbo/pdu/tcp.rs
diff --git a/src/vmm/src/dumbo/tcp/connection.rs b/src/vmm/src/dumbo/tcp/connection.rs
diff --git a/src/vmm/src/dumbo/tcp/handler.rs b/src/vmm/src/dumbo/tcp/handler.rs
diff --git a/src/vmm/src/logger/metrics.rs b/src/vmm/src/logger/metrics.rs
diff --git a/src/vmm/src/mmds/ns.rs b/src/vmm/src/mmds/ns.rs
diff --git a/src/vmm/src/resources.rs b/src/vmm/src/resources.rs
diff --git a/src/vmm/src/vmm_config/net.rs b/src/vmm/src/vmm_config/net.rs
diff --git a/src/vmm/src/vstate/vm.rs b/src/vmm/src/vstate/vm.rs

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ pub enum GetCpuTemplateError {`
`49`	`49`	`/// custom CPU templates and handle static CPU template and custom CPU template in a same manner.`
`50`	`50`	`pub trait GetCpuTemplate {`
`51`	`51`	`/// Get CPU template`
`52`		`- fn get_cpu_template(&self) -> Result<Cow<CustomCpuTemplate>, GetCpuTemplateError>;`
	`52`	`+ fn get_cpu_template(&self) -> Result<Cow<'_, CustomCpuTemplate>, GetCpuTemplateError>;`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`/// Enum that represents types of cpu templates available.`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ impl Block {`
`41`	`41`	`VhostUserBlock::new(config).map_err(BlockError::VhostUserBackend)?,`
`42`	`42`	`))`
`43`	`43`	`} else {`
`44`		`- return Err(BlockError::InvalidBlockConfig);`
	`44`	`+ Err(BlockError::InvalidBlockConfig)`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -455,10 +455,10 @@ impl VirtioBlock {`
`455`	`455`	`});`
`456`	`456`	`}`
`457`	`457`
`458`		`- if let FileEngine::Async(ref mut engine) = self.disk.file_engine {`
`459`		`- if let Err(err) = engine.kick_submission_queue() {`
`460`		`- error!("BlockError submitting pending block requests: {:?}", err);`
`461`		`- }`
	`458`	`+ if let FileEngine::Async(ref mut engine) = self.disk.file_engine`
	`459`	`+ && let Err(err) = engine.kick_submission_queue()`
	`460`	`+ {`
	`461`	`+ error!("BlockError submitting pending block requests: {:?}", err);`
`462`	`462`	`}`
`463`	`463`
`464`	`464`	`if !used_any {`
Original file line number	Diff line number	Diff line change
`@@ -29,14 +29,14 @@ impl VirtioBlock {`
`29`	`29`	`)) {`
`30`	`30`	`error!("Failed to register ratelimiter event: {}", err);`
`31`	`31`	`}`
`32`		`- if let FileEngine::Async(ref engine) = self.disk.file_engine {`
`33`		`- if let Err(err) = ops.add(Events::with_data(`
	`32`	`+ if let FileEngine::Async(ref engine) = self.disk.file_engine`
	`33`	`+ && let Err(err) = ops.add(Events::with_data(`
`34`	`34`	`engine.completion_evt(),`
`35`	`35`	`Self::PROCESS_ASYNC_COMPLETION,`
`36`	`36`	`EventSet::IN,`
`37`		`- )) {`
`38`		`- error!("Failed to register IO engine completion event: {}", err);`
`39`		`- }`
	`37`	`+ ))`
	`38`	`+ {`
	`39`	`+ error!("Failed to register IO engine completion event: {}", err);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`