chore(clippy): update code with new lints

With a new Rust version, new Clippy entered our repository.
This commit aligns our codebase with guidance provided by
new lints.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

Cargo.toml

@@ -9,6 +9,7 @@ resolver = "2"
 
 [workspace.lints.rust]
 missing_debug_implementations = "warn"
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(kani)'] }
 
 [workspace.lints.clippy]
 ptr_as_ptr = "warn"

src/firecracker/src/api_server/request/actions.rs

@@ -30,9 +30,8 @@ struct ActionBody {
 
 pub(crate) fn parse_put_actions(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.actions_count.inc();
-    let action_body = serde_json::from_slice::<ActionBody>(body.raw()).map_err(|err| {
+    let action_body = serde_json::from_slice::<ActionBody>(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.actions_fails.inc();
-        err
     })?;
 
     match action_body.action_type {

src/firecracker/src/api_server/request/boot_source.rs

@@ -11,9 +11,8 @@ use super::Body;
 pub(crate) fn parse_put_boot_source(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.boot_source_count.inc();
     Ok(ParsedRequest::new_sync(VmmAction::ConfigureBootSource(
-        serde_json::from_slice::<BootSourceConfig>(body.raw()).map_err(|err| {
+        serde_json::from_slice::<BootSourceConfig>(body.raw()).inspect_err(|_| {
             METRICS.put_api_requests.boot_source_fails.inc();
-            err
         })?,
     )))
 }

src/firecracker/src/api_server/request/drive.rs

@@ -20,9 +20,8 @@ pub(crate) fn parse_put_drive(
         return Err(RequestError::EmptyID);
     };
 
-    let device_cfg = serde_json::from_slice::<BlockDeviceConfig>(body.raw()).map_err(|err| {
+    let device_cfg = serde_json::from_slice::<BlockDeviceConfig>(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.drive_fails.inc();
-        err
     })?;
 
     if id != device_cfg.drive_id {
@@ -51,9 +50,8 @@ pub(crate) fn parse_patch_drive(
     };
 
     let block_device_update_cfg: BlockDeviceUpdateConfig =
-        serde_json::from_slice::<BlockDeviceUpdateConfig>(body.raw()).map_err(|err| {
+        serde_json::from_slice::<BlockDeviceUpdateConfig>(body.raw()).inspect_err(|_| {
             METRICS.patch_api_requests.drive_fails.inc();
-            err
         })?;
 
     if id != block_device_update_cfg.drive_id {

src/firecracker/src/api_server/request/logger.rs

@@ -10,9 +10,8 @@ use super::Body;
 pub(crate) fn parse_put_logger(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.logger_count.inc();
     let res = serde_json::from_slice::<vmm::logger::LoggerConfig>(body.raw());
-    let config = res.map_err(|err| {
+    let config = res.inspect_err(|_| {
         METRICS.put_api_requests.logger_fails.inc();
-        err
     })?;
     Ok(ParsedRequest::new_sync(VmmAction::ConfigureLogger(config)))
 }

src/firecracker/src/api_server/request/machine_configuration.rs

@@ -15,9 +15,8 @@ pub(crate) fn parse_get_machine_config() -> Result<ParsedRequest, RequestError>
 
 pub(crate) fn parse_put_machine_config(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.machine_cfg_count.inc();
-    let config = serde_json::from_slice::<MachineConfig>(body.raw()).map_err(|err| {
+    let config = serde_json::from_slice::<MachineConfig>(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.machine_cfg_fails.inc();
-        err
     })?;
 
     // Check for the presence of deprecated `cpu_template` field.
@@ -44,9 +43,8 @@ pub(crate) fn parse_put_machine_config(body: &Body) -> Result<ParsedRequest, Req
 pub(crate) fn parse_patch_machine_config(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.patch_api_requests.machine_cfg_count.inc();
     let config_update =
-        serde_json::from_slice::<MachineConfigUpdate>(body.raw()).map_err(|err| {
+        serde_json::from_slice::<MachineConfigUpdate>(body.raw()).inspect_err(|_| {
             METRICS.patch_api_requests.machine_cfg_fails.inc();
-            err
         })?;
 
     if config_update.is_empty() {

src/firecracker/src/api_server/request/metrics.rs

@@ -11,9 +11,8 @@ use super::Body;
 pub(crate) fn parse_put_metrics(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.metrics_count.inc();
     Ok(ParsedRequest::new_sync(VmmAction::ConfigureMetrics(
-        serde_json::from_slice::<MetricsConfig>(body.raw()).map_err(|err| {
+        serde_json::from_slice::<MetricsConfig>(body.raw()).inspect_err(|_| {
             METRICS.put_api_requests.metrics_fails.inc();
-            err
         })?,
     )))
 }

src/firecracker/src/api_server/request/mmds.rs

@@ -16,9 +16,8 @@ pub(crate) fn parse_get_mmds() -> Result<ParsedRequest, RequestError> {
 }
 
 fn parse_put_mmds_config(body: &Body) -> Result<ParsedRequest, RequestError> {
-    let config: MmdsConfig = serde_json::from_slice(body.raw()).map_err(|err| {
+    let config: MmdsConfig = serde_json::from_slice(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.mmds_fails.inc();
-        err
     })?;
     // Construct the `ParsedRequest` object.
     let version = config.version;
@@ -42,9 +41,8 @@ pub(crate) fn parse_put_mmds(
     METRICS.put_api_requests.mmds_count.inc();
     match path_second_token {
         None => Ok(ParsedRequest::new_sync(VmmAction::PutMMDS(
-            serde_json::from_slice(body.raw()).map_err(|err| {
+            serde_json::from_slice(body.raw()).inspect_err(|_| {
                 METRICS.put_api_requests.mmds_fails.inc();
-                err
             })?,
         ))),
         Some("config") => parse_put_mmds_config(body),
@@ -61,9 +59,8 @@ pub(crate) fn parse_put_mmds(
 pub(crate) fn parse_patch_mmds(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.patch_api_requests.mmds_count.inc();
     Ok(ParsedRequest::new_sync(VmmAction::PatchMMDS(
-        serde_json::from_slice(body.raw()).map_err(|err| {
+        serde_json::from_slice(body.raw()).inspect_err(|_| {
             METRICS.patch_api_requests.mmds_fails.inc();
-            err
         })?,
     )))
 }

src/firecracker/src/api_server/request/net.rs

@@ -20,9 +20,8 @@ pub(crate) fn parse_put_net(
         return Err(RequestError::EmptyID);
     };
 
-    let netif = serde_json::from_slice::<NetworkInterfaceConfig>(body.raw()).map_err(|err| {
+    let netif = serde_json::from_slice::<NetworkInterfaceConfig>(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.network_fails.inc();
-        err
     })?;
     if id != netif.iface_id.as_str() {
         METRICS.put_api_requests.network_fails.inc();
@@ -53,9 +52,8 @@ pub(crate) fn parse_patch_net(
     };
 
     let netif =
-        serde_json::from_slice::<NetworkInterfaceUpdateConfig>(body.raw()).map_err(|err| {
+        serde_json::from_slice::<NetworkInterfaceUpdateConfig>(body.raw()).inspect_err(|_| {
             METRICS.patch_api_requests.network_fails.inc();
-            err
         })?;
     if id != netif.iface_id {
         METRICS.patch_api_requests.network_count.inc();

src/firecracker/src/api_server/request/vsock.rs

@@ -10,9 +10,8 @@ use super::Body;
 
 pub(crate) fn parse_put_vsock(body: &Body) -> Result<ParsedRequest, RequestError> {
     METRICS.put_api_requests.vsock_count.inc();
-    let vsock_cfg = serde_json::from_slice::<VsockDeviceConfig>(body.raw()).map_err(|err| {
+    let vsock_cfg = serde_json::from_slice::<VsockDeviceConfig>(body.raw()).inspect_err(|_| {
         METRICS.put_api_requests.vsock_fails.inc();
-        err
     })?;
 
     // Check for the presence of deprecated `vsock_id` field.

src/vmm/src/devices/legacy/serial.rs

@@ -386,7 +386,7 @@ mod tests {
             ),
             input: None::<std::io::Stdin>,
         };
-        serial.serial.raw_input(&[b'a', b'b', b'c']).unwrap();
+        serial.serial.raw_input(b"abc").unwrap();
 
         let invalid_reads_before = metrics.missed_read_count.count();
         let mut v = [0x00; 2];

src/vmm/src/devices/virtio/balloon/metrics.rs

@@ -31,7 +31,7 @@
 //!
 //! The system implements 1 type of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!   (i.e the number of times an API request failed). These metrics are reset upon flush.
 
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};

src/vmm/src/devices/virtio/block/virtio/metrics.rs

@@ -72,7 +72,8 @@
 //!
 //! The system implements 1 type of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!   (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!
 //! We add BlockDeviceMetrics entries from block::metrics::METRICS into Block device instead of
 //! Block device having individual separate BlockDeviceMetrics entries because Block device is not
 //! accessible from signal handlers to flush metrics and block::metrics::METRICS is.

src/vmm/src/devices/virtio/iovec.rs

@@ -264,10 +264,11 @@ impl<const L: u16> IoVecBufferMut<L> {
             // We use get_slice instead of `get_host_address` here in order to have the whole
             // range of the descriptor chain checked, i.e. [addr, addr + len) is a valid memory
             // region in the GuestMemoryMmap.
-            let slice = mem.get_slice(desc.addr, desc.len as usize).map_err(|err| {
-                self.vecs.pop_back(nr_iovecs);
-                err
-            })?;
+            let slice = mem
+                .get_slice(desc.addr, desc.len as usize)
+                .inspect_err(|_| {
+                    self.vecs.pop_back(nr_iovecs);
+                })?;
             // We need to mark the area of guest memory that will be mutated through this
             // IoVecBufferMut as dirty ahead of time, as we loose access to all
             // vm-memory related information after converting down to iovecs.
@@ -288,9 +289,8 @@ impl<const L: u16> IoVecBufferMut<L> {
             length = length
                 .checked_add(desc.len)
                 .ok_or(IoVecError::OverflowedDescriptor)
-                .map_err(|err| {
+                .inspect_err(|_| {
                     self.vecs.pop_back(nr_iovecs);
-                    err
                 })?;
 
             next_descriptor = desc.next_descriptor();

src/vmm/src/devices/virtio/mmio.rs

@@ -38,9 +38,9 @@ const MMIO_VERSION: u32 = 2;
 ///
 /// 1. Mmio reads and writes must be sent to this device at what is referred to here as MMIO base.
 /// 1. `Mmio::queue_evts` must be installed at `virtio::NOTIFY_REG_OFFSET` offset from the MMIO
-/// base. Each event in the array must be signaled if the index is written at that offset.
+///    base. Each event in the array must be signaled if the index is written at that offset.
 /// 1. `Mmio::interrupt_evt` must signal an interrupt that the guest driver is listening to when it
-/// is written to.
+///    is written to.
 ///
 /// Typically one page (4096 bytes) of MMIO address space is sufficient to handle this transport
 /// and inner virtio device.

src/vmm/src/devices/virtio/net/device.rs

@@ -514,10 +514,9 @@ impl Net {
                 NetError::VnetHeaderMissing
             })?;
 
-        let headers = frame_bytes_from_buf(&headers[..header_len]).map_err(|e| {
+        let headers = frame_bytes_from_buf(&headers[..header_len]).inspect_err(|_| {
             error!("VNET headers missing in TX frame");
             net_metrics.tx_malformed_frames.inc();
-            e
         })?;
 
         if let Some(ns) = mmds_ns {

src/vmm/src/devices/virtio/net/metrics.rs

@@ -75,7 +75,8 @@
 //!
 //! The system implements 1 types of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!   (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!
 //! We use net::metrics::METRICS instead of adding an entry of NetDeviceMetrics
 //! in Net so that metrics are accessible to be flushed even from signal handlers.
 

src/vmm/src/devices/virtio/queue.rs

@@ -172,9 +172,8 @@ impl Iterator for DescriptorIterator {
     type Item = DescriptorChain;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.0.take().map(|desc| {
+        self.0.take().inspect(|desc| {
             self.0 = desc.next_descriptor();
-            desc
         })
     }
 }
@@ -560,10 +559,9 @@ impl Queue {
         // index is bound by the queue size
         let desc_index = unsafe { self.avail_ring_ring_get(usize::from(idx)) };
 
-        DescriptorChain::checked_new(self.desc_table_ptr, self.actual_size(), desc_index).map(
-            |dc| {
+        DescriptorChain::checked_new(self.desc_table_ptr, self.actual_size(), desc_index).inspect(
+            |_| {
                 self.next_avail += Wrapping(1);
-                dc
             },
         )
     }
@@ -575,9 +573,8 @@ impl Queue {
     }
 
     /// Write used element into used_ring ring.
-    /// - [`ring_index_offset`] is an offset added to
-    /// the current [`self.next_used`] to obtain actual index
-    /// into used_ring.
+    /// - [`ring_index_offset`] is an offset added to the current [`self.next_used`] to obtain
+    ///   actual index into used_ring.
     pub fn write_used_element(
         &mut self,
         ring_index_offset: u16,

src/vmm/src/devices/virtio/rng/device.rs

@@ -119,9 +119,8 @@ impl Entropy {
         }
 
         let mut rand_bytes = vec![0; self.buffer.len() as usize];
-        rand::fill(&mut rand_bytes).map_err(|err| {
+        rand::fill(&mut rand_bytes).inspect_err(|_| {
             METRICS.host_rng_fails.inc();
-            err
         })?;
 
         // It is ok to unwrap here. We are writing `iovec.len()` bytes at offset 0.

src/vmm/src/devices/virtio/rng/metrics.rs

@@ -31,7 +31,7 @@
 //!
 //! The system implements 1 type of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!   (i.e the number of times an API request failed). These metrics are reset upon flush.
 
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};

src/vmm/src/devices/virtio/vhost_user_metrics.rs

@@ -64,9 +64,10 @@
 //!
 //! The system implements 2 type of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times activating a device failed). These metrics are reset upon flush.
+//!   (i.e the number of times activating a device failed). These metrics are reset upon flush.
 //! * Shared Store Metrics (SharedStoreMetrics) - are targeted at keeping a persistent value, it is
 //!   `not` intended to act as a counter (i.e for measure the process start up time for example).
+//!
 //! We add VhostUserDeviceMetrics entries from vhost_user_metrics::METRICS into vhost_user device
 //! instead of vhost_user device having individual separate VhostUserDeviceMetrics entries because
 //! vhost_user device is not accessible from signal handlers to flush metrics and

src/vmm/src/devices/virtio/vsock/event_handler.rs

@@ -9,7 +9,7 @@ use std::fmt::Debug;
 
 /// The vsock object implements the runtime logic of our vsock device:
 /// 1. Respond to TX queue events by wrapping virtio buffers into `VsockPacket`s, then sending
-/// those    packets to the `VsockBackend`;
+///    those packets to the `VsockBackend`;
 /// 2. Forward backend FD event notifications to the `VsockBackend`;
 /// 3. Fetch incoming packets from the `VsockBackend` and place them into the virtio RX queue;
 /// 4. Whenever we have processed some virtio buffers (either TX or RX), let the driver know by

src/vmm/src/devices/virtio/vsock/metrics.rs

@@ -34,7 +34,7 @@
 //!
 //! The system implements 1 type of metrics:
 //! * Shared Incremental Metrics (SharedIncMetrics) - dedicated for the metrics which need a counter
-//! (i.e the number of times an API request failed). These metrics are reset upon flush.
+//!   (i.e the number of times an API request failed). These metrics are reset upon flush.
 
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};

src/vmm/src/devices/virtio/vsock/packet.rs

@@ -7,6 +7,7 @@
 //! virtio queue:
 //! - the packet header; and
 //! - the packet data/buffer.
+//!
 //! There is a 1:1 relation between descriptor chains and packets: the first (chain head) holds
 //! the header, and an optional second descriptor holds the data. The second descriptor is only
 //! present for data packets (VSOCK_OP_RW).

src/vmm/src/devices/virtio/vsock/unix/muxer.rs

@@ -24,11 +24,12 @@
 ///       destination port to which it wants to connect);
 ///    3. Some event was triggered for a connected Unix socket, that belongs to a
 ///       `VsockConnection`.
-///    The muxer gets notified about all of these events, because, as a `VsockEpollListener`
-///    implementor, it gets to register a nested epoll FD into the main VMM epolling loop. All
-///    other pollable FDs are then registered under this nested epoll FD.
-///    To route all these events to their handlers, the muxer uses another `HashMap` object,
-///    mapping `RawFd`s to `EpollListener`s.
+///
+///  The muxer gets notified about all of these events, because, as a `VsockEpollListener`
+///  implementor, it gets to register a nested epoll FD into the main VMM epolling loop. All
+///  other pollable FDs are then registered under this nested epoll FD.
+///  To route all these events to their handlers, the muxer uses another `HashMap` object,
+///  mapping `RawFd`s to `EpollListener`s.
 use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
 use std::io::Read;

src/vmm/src/devices/virtio/vsock/unix/muxer_rxq.rs

@@ -67,6 +67,7 @@ impl MuxerRxQ {
     /// A push will fail when:
     /// - trying to push a connection key onto an out-of-sync, or full queue; or
     /// - trying to push an RST onto a queue already full of RSTs.
+    ///
     /// RSTs take precedence over connections, because connections can always be queried for
     /// pending RX data later. Aside from this queue, there is no other storage for RSTs, so
     /// failing to push one means that we have to drop the packet.

src/vmm/src/dumbo/pdu/mod.rs

@@ -66,8 +66,7 @@ enum ChecksumProto {
 /// * `bytes` - Raw bytes of a TCP packet or a UDP datagram
 /// * `src_addr` - IPv4 source address
 /// * `dst_addr` - IPv4 destination address
-/// * `protocol` - **must** be either `PROTOCOL_TCP` or `PROTOCOL_UDP` defined in
-/// `ipv4` module
+/// * `protocol` - **must** be either `PROTOCOL_TCP` or `PROTOCOL_UDP` defined in `ipv4` module
 ///
 /// More details about TCP checksum computation can be found [here].
 ///

src/vmm/src/dumbo/tcp/endpoint.rs

@@ -281,9 +281,8 @@ impl Endpoint {
             tcp_payload_src,
             timestamp_cycles(),
         ) {
-            Ok(write_result) => write_result.map(|segment| {
+            Ok(write_result) => write_result.inspect(|segment| {
                 self.response_seq += Wrapping(u32::from(segment.inner().payload_len()));
-                segment
             }),
             Err(_) => {
                 METRICS.mmds.tx_errors.inc();