Maintenance 3

rustfmt.toml

@@ -0,0 +1,8 @@
+comment_width = 100
+wrap_comments = true
+format_code_in_doc_comments = true
+format_strings = true
+imports_granularity = "Module"
+normalize_comments = true
+normalize_doc_attributes = true
+group_imports = "StdExternalCrate"

src/cpu-template-helper/src/utils/x86_64.rs

@@ -194,7 +194,6 @@ mod tests {
     use vmm::cpu_config::x86_64::custom_cpu_template::CpuidRegisterModifier;
 
     use super::*;
-    use crate::utils::x86_64::{cpuid_leaf_modifier, cpuid_reg_modifier, msr_modifier};
 
     macro_rules! cpuid_modifier_map {
         ($leaf:expr, $subleaf:expr, $flags:expr, $register:expr, $value:expr) => {

src/firecracker/src/api_server/parsed_request.rs

@@ -406,12 +406,12 @@ pub mod tests {
             "{} {} HTTP/1.1\r\nContent-Type: application/json\r\n",
             request_type, endpoint
         );
-        if body.is_some() {
+        if let Some(body) = body {
             return format!(
                 "{}Content-Length: {}\r\n\r\n{}",
                 req_no_body,
-                body.unwrap().len(),
-                body.unwrap()
+                body.len(),
+                body
             );
         }
         format!("{}\r\n", req_no_body,)

src/vmm/src/arch/x86_64/interrupts.rs

@@ -111,7 +111,7 @@ mod tests {
 
         v.iter_mut()
             .for_each(|x| *x = set_apic_delivery_mode(*x, 2));
-        let after: Vec<u32> = v.iter().map(|x| ((*x & !0x700) | ((2) << 8))).collect();
+        let after: Vec<u32> = v.iter().map(|x| (*x & !0x700) | ((2) << 8)).collect();
         assert_eq!(v, after);
     }
 

src/vmm/src/builder.rs

@@ -31,6 +31,7 @@ use crate::device_manager::{
 };
 use crate::devices::virtio::balloon::Balloon;
 use crate::devices::virtio::block::device::Block;
+use crate::devices::virtio::device::VirtioDevice;
 use crate::devices::virtio::mem::{VIRTIO_MEM_DEFAULT_SLOT_SIZE_MIB, VirtioMem};
 use crate::devices::virtio::net::Net;
 use crate::devices::virtio::pmem::device::Pmem;
@@ -682,7 +683,7 @@ fn attach_net_devices<'a, I: Iterator<Item = &'a Arc<Mutex<Net>>> + Debug>(
     event_manager: &mut EventManager,
 ) -> Result<(), StartMicrovmError> {
     for net_device in net_devices {
-        let id = net_device.lock().expect("Poisoned lock").id().clone();
+        let id = net_device.lock().expect("Poisoned lock").id().to_string();
         event_manager.add_subscriber(net_device.clone());
         // The device mutex mustn't be locked here otherwise it will deadlock.
         device_manager.attach_virtio_device(vm, id, net_device.clone(), cmdline, false)?;
@@ -753,7 +754,7 @@ pub(crate) mod tests {
     use super::*;
     use crate::device_manager::tests::default_device_manager;
     use crate::devices::virtio::block::CacheType;
-    use crate::devices::virtio::generated::virtio_ids;
+    use crate::devices::virtio::device::VirtioDeviceType;
     use crate::devices::virtio::rng::device::ENTROPY_DEV_ID;
     use crate::devices::virtio::vsock::VSOCK_DEV_ID;
     use crate::mmds::data_store::{Mmds, MmdsVersion};
@@ -955,7 +956,7 @@ pub(crate) mod tests {
 
         assert!(
             vmm.device_manager
-                .get_virtio_device(virtio_ids::VIRTIO_ID_VSOCK, &vsock_dev_id)
+                .get_virtio_device(VirtioDeviceType::Vsock, &vsock_dev_id)
                 .is_some()
         );
     }
@@ -980,7 +981,7 @@ pub(crate) mod tests {
 
         assert!(
             vmm.device_manager
-                .get_virtio_device(virtio_ids::VIRTIO_ID_RNG, ENTROPY_DEV_ID)
+                .get_virtio_device(VirtioDeviceType::Rng, ENTROPY_DEV_ID)
                 .is_some()
         );
     }
@@ -1044,7 +1045,7 @@ pub(crate) mod tests {
 
         assert!(
             vmm.device_manager
-                .get_virtio_device(virtio_ids::VIRTIO_ID_BALLOON, BALLOON_DEV_ID)
+                .get_virtio_device(VirtioDeviceType::Balloon, BALLOON_DEV_ID)
                 .is_some()
         );
     }
@@ -1095,7 +1096,7 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=/dev/vda ro"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1116,7 +1117,7 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=PARTUUID=0eaa91a0-01 rw"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1138,7 +1139,7 @@ pub(crate) mod tests {
             assert!(!cmdline_contains(&cmdline, "root=/dev/vda"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1175,17 +1176,17 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=PARTUUID=0eaa91a0-01 rw"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, "root")
+                    .get_virtio_device(VirtioDeviceType::Block, "root")
                     .is_some()
             );
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, "secondary")
+                    .get_virtio_device(VirtioDeviceType::Block, "secondary")
                     .is_some()
             );
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, "third")
+                    .get_virtio_device(VirtioDeviceType::Block, "third")
                     .is_some()
             );
 
@@ -1214,7 +1215,7 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=/dev/vda rw"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1235,7 +1236,7 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=PARTUUID=0eaa91a0-01 ro"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1256,7 +1257,7 @@ pub(crate) mod tests {
             assert!(cmdline_contains(&cmdline, "root=/dev/vda rw"));
             assert!(
                 vmm.device_manager
-                    .get_virtio_device(virtio_ids::VIRTIO_ID_BLOCK, drive_id.as_str())
+                    .get_virtio_device(VirtioDeviceType::Block, drive_id.as_str())
                     .is_some()
             );
         }
@@ -1279,7 +1280,7 @@ pub(crate) mod tests {
         assert!(cmdline_contains(&cmdline, "root=/dev/pmem0 ro"));
         assert!(
             vmm.device_manager
-                .get_virtio_device(virtio_ids::VIRTIO_ID_PMEM, id.as_str())
+                .get_virtio_device(VirtioDeviceType::Pmem, id.as_str())
                 .is_some()
         );
     }

src/vmm/src/device_manager/mmio.rs

@@ -25,6 +25,7 @@ use crate::arch::{RTC_MEM_START, SERIAL_MEM_START};
 #[cfg(target_arch = "aarch64")]
 use crate::devices::legacy::{RTCDevice, SerialDevice};
 use crate::devices::pseudo::BootTimer;
+use crate::devices::virtio::device::VirtioDeviceType;
 use crate::devices::virtio::transport::mmio::MmioTransport;
 use crate::vstate::bus::{Bus, BusError};
 #[cfg(target_arch = "x86_64")]
@@ -118,7 +119,7 @@ pub struct MMIODevice<T> {
 #[derive(Debug, Default)]
 pub struct MMIODeviceManager {
     /// VirtIO devices using an MMIO transport layer
-    pub(crate) virtio_devices: HashMap<(u32, String), MMIODevice<MmioTransport>>,
+    pub(crate) virtio_devices: HashMap<(VirtioDeviceType, String), MMIODevice<MmioTransport>>,
     /// Boot timer device
     pub(crate) boot_timer: Option<MMIODevice<BootTimer>>,
     #[cfg(target_arch = "aarch64")]
@@ -382,20 +383,20 @@ impl MMIODeviceManager {
     /// Gets the specified device.
     pub fn get_virtio_device(
         &self,
-        virtio_type: u32,
+        device_type: VirtioDeviceType,
         device_id: &str,
     ) -> Option<&MMIODevice<MmioTransport>> {
         self.virtio_devices
-            .get(&(virtio_type, device_id.to_string()))
+            .get(&(device_type, device_id.to_string()))
     }
 
     /// Run fn for each registered virtio device.
     pub fn for_each_virtio_device<F, E: Debug>(&self, mut f: F) -> Result<(), E>
     where
-        F: FnMut(&u32, &String, &MMIODevice<MmioTransport>) -> Result<(), E>,
+        F: FnMut(&VirtioDeviceType, &String, &MMIODevice<MmioTransport>) -> Result<(), E>,
     {
-        for ((virtio_type, device_id), mmio_device) in &self.virtio_devices {
-            f(virtio_type, device_id, mmio_device)?;
+        for ((device_type, device_id), mmio_device) in &self.virtio_devices {
+            f(device_type, device_id, mmio_device)?;
         }
         Ok(())
     }
@@ -430,7 +431,7 @@ pub(crate) mod tests {
 
     use super::*;
     use crate::devices::virtio::ActivateError;
-    use crate::devices::virtio::device::VirtioDevice;
+    use crate::devices::virtio::device::{VirtioDevice, VirtioDeviceType};
     use crate::devices::virtio::queue::Queue;
     use crate::devices::virtio::transport::VirtioInterrupt;
     use crate::devices::virtio::transport::mmio::IrqTrigger;
@@ -491,7 +492,11 @@ pub(crate) mod tests {
     }
 
     impl VirtioDevice for DummyDevice {
-        impl_device_type!(0);
+        impl_device_type!(VirtioDeviceType::Net);
+
+        fn id(&self) -> &str {
+            "dummy"
+        }
 
         fn avail_features(&self) -> u64 {
             0
@@ -575,15 +580,21 @@ pub(crate) mod tests {
             )
             .unwrap();
 
-        assert!(device_manager.get_virtio_device(0, "foo").is_none());
-        let dev = device_manager.get_virtio_device(0, "dummy").unwrap();
+        assert!(
+            device_manager
+                .get_virtio_device(VirtioDeviceType::Net, "foo")
+                .is_none()
+        );
+        let dev = device_manager
+            .get_virtio_device(VirtioDeviceType::Net, "dummy")
+            .unwrap();
         assert_eq!(dev.resources.addr, arch::MEM_32BIT_DEVICES_START);
         assert_eq!(dev.resources.len, MMIO_LEN);
         assert_eq!(dev.resources.gsi, Some(arch::GSI_LEGACY_START));
 
         device_manager
-            .for_each_virtio_device(|virtio_type, device_id, mmio_device| {
-                assert_eq!(*virtio_type, 0);
+            .for_each_virtio_device(|device_type, device_id, mmio_device| {
+                assert_eq!(*device_type, VirtioDeviceType::Net);
                 assert_eq!(device_id, "dummy");
                 assert_eq!(mmio_device.resources.addr, arch::MEM_32BIT_DEVICES_START);
                 assert_eq!(mmio_device.resources.len, MMIO_LEN);
@@ -642,7 +653,7 @@ pub(crate) mod tests {
     #[test]
     fn test_dummy_device() {
         let dummy = DummyDevice::new();
-        assert_eq!(dummy.device_type(), 0);
+        assert_eq!(dummy.device_type(), VirtioDeviceType::Net);
         assert_eq!(dummy.queues().len(), QUEUE_SIZES.len());
     }
 

src/vmm/src/device_manager/mod.rs

@@ -31,7 +31,7 @@ use crate::devices::legacy::RTCDevice;
 use crate::devices::legacy::serial::SerialOut;
 use crate::devices::legacy::{IER_RDA_BIT, IER_RDA_OFFSET, SerialDevice};
 use crate::devices::pseudo::BootTimer;
-use crate::devices::virtio::device::VirtioDevice;
+use crate::devices::virtio::device::{VirtioDevice, VirtioDeviceType};
 use crate::devices::virtio::transport::mmio::{IrqTrigger, MmioTransport};
 use crate::resources::VmResources;
 use crate::snapshot::Persist;
@@ -332,11 +332,11 @@ impl DeviceManager {
     /// Get a VirtIO device of type `virtio_type` with ID `device_id`
     pub fn get_virtio_device(
         &self,
-        virtio_type: u32,
+        device_type: VirtioDeviceType,
         device_id: &str,
     ) -> Option<Arc<Mutex<dyn VirtioDevice>>> {
         if self.pci_devices.pci_segment.is_some() {
-            let pci_device = self.pci_devices.get_virtio_device(virtio_type, device_id)?;
+            let pci_device = self.pci_devices.get_virtio_device(device_type, device_id)?;
             Some(
                 pci_device
                     .lock()
@@ -347,7 +347,7 @@ impl DeviceManager {
         } else {
             let mmio_device = self
                 .mmio_devices
-                .get_virtio_device(virtio_type, device_id)?;
+                .get_virtio_device(device_type, device_id)?;
             Some(
                 mmio_device
                     .inner