chore: appease rustfmt, clippy and rustc

Lots of new warnings and lints

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

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
     }

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() {

src/vmm/src/arch/aarch64/mod.rs

@@ -169,10 +169,10 @@ fn get_fdt_addr(mem: &GuestMemoryMmap) -> u64 {
     // we return the start of the DRAM so that
     // we allow the code to try and load the FDT.
 
-    if let Some(addr) = mem.last_addr().checked_sub(layout::FDT_MAX_SIZE as u64 - 1) {
-        if mem.address_in_range(addr) {
-            return addr.raw_value();
-        }
+    if let Some(addr) = mem.last_addr().checked_sub(layout::FDT_MAX_SIZE as u64 - 1)
+        && mem.address_in_range(addr)
+    {
+        return addr.raw_value();
     }
 
     layout::DRAM_MEM_START

src/vmm/src/arch/aarch64/regs.rs

@@ -243,7 +243,7 @@ impl Aarch64RegisterVec {
     }
 
     /// Returns an iterator over stored registers.
-    pub fn iter(&self) -> impl Iterator<Item = Aarch64RegisterRef> {
+    pub fn iter(&self) -> impl Iterator<Item = Aarch64RegisterRef<'_>> {
         Aarch64RegisterVecIterator {
             index: 0,
             offset: 0,
@@ -253,7 +253,7 @@ impl Aarch64RegisterVec {
     }
 
     /// Returns an iterator over stored registers that allows register modifications.
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = Aarch64RegisterRefMut> {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = Aarch64RegisterRefMut<'_>> {
         Aarch64RegisterVecIteratorMut {
             index: 0,
             offset: 0,

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

src/vmm/src/cpu_config/aarch64/custom_cpu_template.rs

@@ -17,7 +17,7 @@ use crate::cpu_config::templates::{
 use crate::cpu_config::templates_serde::*;
 
 impl GetCpuTemplate for Option<CpuTemplateType> {
-    fn get_cpu_template(&self) -> Result<Cow<CustomCpuTemplate>, GetCpuTemplateError> {
+    fn get_cpu_template(&self) -> Result<Cow<'_, CustomCpuTemplate>, GetCpuTemplateError> {
         match self {
             Some(template_type) => match template_type {
                 CpuTemplateType::Custom(template) => Ok(Cow::Borrowed(template)),

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.

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 {

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,

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);