build: treewide: fmt for edition 2024

`cargo +nightly fmt`

Signed-off-by: Philipp Schuster <philipp.schuster@cyberus-technology.de>
On-behalf-of: SAP philipp.schuster@sap.com

.rustfmt.toml

@@ -1,4 +1,4 @@
-edition = "2021"
+edition = "2024"
 group_imports="StdExternalCrate"
 imports_granularity="Module"
 

arch/src/aarch64/mod.rs

@@ -15,7 +15,7 @@ use std::sync::{Arc, Mutex};
 
 use hypervisor::arch::aarch64::gic::Vgic;
 use hypervisor::arch::aarch64::regs::MPIDR_EL1;
-use log::{log_enabled, Level};
+use log::{Level, log_enabled};
 use thiserror::Error;
 use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
 

arch/src/lib.rs

@@ -81,9 +81,9 @@ pub mod aarch64;
 
 #[cfg(target_arch = "aarch64")]
 pub use aarch64::{
-    arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt,
-    get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::IRQ_BASE, uefi, EntryPoint, _NSIG,
+    _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
+    fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
+    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
 };
 
 /// Module for riscv64 related functionality.
@@ -92,9 +92,9 @@ pub mod riscv64;
 
 #[cfg(target_arch = "riscv64")]
 pub use riscv64::{
-    arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt,
-    get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE,
-    layout::IRQ_BASE, uefi, EntryPoint, _NSIG,
+    _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
+    fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
+    layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
 };
 
 #[cfg(target_arch = "x86_64")]
@@ -102,10 +102,9 @@ pub mod x86_64;
 
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::{
-    arch_memory_regions, configure_system, configure_vcpu, generate_common_cpuid,
-    generate_ram_ranges, get_host_cpu_phys_bits, initramfs_load_addr, layout,
-    layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs, CpuidConfig, CpuidFeatureEntry,
-    EntryPoint, _NSIG,
+    _NSIG, CpuidConfig, CpuidFeatureEntry, EntryPoint, arch_memory_regions, configure_system,
+    configure_vcpu, generate_common_cpuid, generate_ram_ranges, get_host_cpu_phys_bits,
+    initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs,
 };
 
 /// Safe wrapper for `sysconf(_SC_PAGESIZE)`.

arch/src/riscv64/mod.rs

@@ -15,7 +15,7 @@ use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
 use hypervisor::arch::riscv64::aia::Vaia;
-use log::{log_enabled, Level};
+use log::{Level, log_enabled};
 use thiserror::Error;
 use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
 

arch/src/x86_64/mod.rs

@@ -14,7 +14,7 @@ mod mptable;
 pub mod regs;
 use std::mem;
 
-use hypervisor::arch::x86::{CpuIdEntry, CPUID_FLAG_VALID_INDEX};
+use hypervisor::arch::x86::{CPUID_FLAG_VALID_INDEX, CpuIdEntry};
 use hypervisor::{CpuVendor, HypervisorCpuError, HypervisorError};
 use linux_loader::loader::bootparam::{boot_params, setup_header};
 use linux_loader::loader::elf::start_info::{
@@ -525,8 +525,12 @@ impl CpuidFeatureEntry {
                 error!(
                     "Detected incompatible CPUID entry: leaf={:#02x} (subleaf={:#02x}), register='{:?}', \
                     compatible_check='{:?}', source VM feature='{:#04x}', destination VM feature'{:#04x}'.",
-                    entry.function, entry.index, entry.feature_reg,
-                    entry.compatible_check, src_vm_feature, dest_vm_feature
+                    entry.function,
+                    entry.index,
+                    entry.feature_reg,
+                    entry.compatible_check,
+                    src_vm_feature,
+                    dest_vm_feature
                 );
 
                 compatible = false;

arch/src/x86_64/mptable.rs

@@ -12,9 +12,9 @@ use thiserror::Error;
 use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError};
 
 use super::MAX_SUPPORTED_CPUS_LEGACY;
+use crate::GuestMemoryMmap;
 use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
 use crate::x86_64::{get_x2apic_id, mpspec};
-use crate::GuestMemoryMmap;
 
 // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
 // trait (in this case `ByteValued`) where:

arch/src/x86_64/smbios.rs

@@ -12,8 +12,8 @@ use thiserror::Error;
 use uuid::Uuid;
 use vm_memory::{Address, ByteValued, Bytes, GuestAddress};
 
-use crate::layout::SMBIOS_START;
 use crate::GuestMemoryMmap;
+use crate::layout::SMBIOS_START;
 
 #[derive(Debug, Error)]
 pub enum Error {

block/src/fixed_vhd.rs

@@ -6,8 +6,8 @@ use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::os::unix::io::{AsRawFd, RawFd};
 
-use crate::vhd::VhdFooter;
 use crate::BlockBackend;
+use crate::vhd::VhdFooter;
 
 #[derive(Debug)]
 pub struct FixedVhd {

block/src/fixed_vhd_sync.rs

@@ -7,12 +7,12 @@ use std::os::unix::io::{AsRawFd, RawFd};
 
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::BlockBackend;
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::fixed_vhd::FixedVhd;
 use crate::raw_sync::RawFileSync;
-use crate::BlockBackend;
 
 pub struct FixedVhdDiskSync(FixedVhd);
 

block/src/lib.rs

@@ -31,7 +31,7 @@ pub mod vhd;
 pub mod vhdx;
 pub mod vhdx_sync;
 
-use std::alloc::{alloc_zeroed, dealloc, Layout};
+use std::alloc::{Layout, alloc_zeroed, dealloc};
 use std::collections::VecDeque;
 use std::fmt::Debug;
 use std::fs::File;
@@ -44,8 +44,8 @@ use std::time::Instant;
 use std::{cmp, result};
 
 #[cfg(feature = "io_uring")]
-use io_uring::{opcode, IoUring, Probe};
-use libc::{ioctl, S_IFBLK, S_IFMT};
+use io_uring::{IoUring, Probe, opcode};
+use libc::{S_IFBLK, S_IFMT, ioctl};
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use thiserror::Error;

block/src/qcow/mod.rs

@@ -24,11 +24,11 @@ use vmm_sys_util::file_traits::{FileSetLen, FileSync};
 use vmm_sys_util::seek_hole::SeekHole;
 use vmm_sys_util::write_zeroes::{PunchHole, WriteZeroesAt};
 
+use crate::BlockBackend;
 use crate::qcow::qcow_raw_file::QcowRawFile;
 pub use crate::qcow::raw_file::RawFile;
 use crate::qcow::refcount::RefCount;
 use crate::qcow::vec_cache::{CacheMap, Cacheable, VecCache};
-use crate::BlockBackend;
 
 /// Nesting depth limit for disk formats that can open other disk files.
 const MAX_NESTING_DEPTH: u32 = 10;

block/src/qcow/raw_file.rs

@@ -8,7 +8,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use std::alloc::{alloc_zeroed, dealloc, Layout};
+use std::alloc::{Layout, alloc_zeroed, dealloc};
 use std::fs::{File, Metadata};
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::os::unix::io::{AsRawFd, RawFd};

block/src/qcow/vec_cache.rs

@@ -4,8 +4,8 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use std::collections::hash_map::IterMut;
 use std::collections::HashMap;
+use std::collections::hash_map::IterMut;
 use std::io;
 use std::ops::{Index, IndexMut};
 use std::slice::SliceIndex;

block/src/qcow_sync.rs

@@ -9,11 +9,11 @@ use std::os::fd::AsRawFd;
 
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::AsyncAdaptor;
 use crate::async_io::{
     AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
-use crate::AsyncAdaptor;
 
 pub struct QcowDiskSync {
     qcow_file: QcowFile,

block/src/raw_async.rs

@@ -6,7 +6,7 @@ use std::fs::File;
 use std::io::{Error, Seek, SeekFrom};
 use std::os::unix::io::{AsRawFd, RawFd};
 
-use io_uring::{opcode, types, IoUring};
+use io_uring::{IoUring, opcode, types};
 use vmm_sys_util::eventfd::EventFd;
 
 use crate::async_io::{

block/src/raw_async_aio.rs

@@ -12,10 +12,10 @@ use std::os::unix::io::{AsRawFd, RawFd};
 use vmm_sys_util::aio;
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::DiskTopology;
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
 };
-use crate::DiskTopology;
 
 pub struct RawFileDiskAio {
     file: File,

block/src/raw_sync.rs

@@ -9,10 +9,10 @@ use std::os::unix::io::{AsRawFd, RawFd};
 
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::DiskTopology;
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
 };
-use crate::DiskTopology;
 
 pub struct RawFileDiskSync {
     file: File,

block/src/vhd.rs

@@ -5,7 +5,7 @@
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
 
-use crate::{read_aligned_block_size, DiskTopology};
+use crate::{DiskTopology, read_aligned_block_size};
 
 #[derive(Clone, Copy)]
 pub struct VhdFooter {
@@ -123,7 +123,7 @@ mod tests {
 
     use vmm_sys_util::tempfile::TempFile;
 
-    use super::{is_fixed_vhd, VhdFooter};
+    use super::{VhdFooter, is_fixed_vhd};
 
     fn valid_fixed_vhd_footer() -> Vec<u8> {
         vec![

block/src/vhdx/mod.rs

@@ -12,11 +12,11 @@ use remain::sorted;
 use thiserror::Error;
 use uuid::Uuid;
 
+use crate::BlockBackend;
 use crate::vhdx::vhdx_bat::{BatEntry, VhdxBatError};
 use crate::vhdx::vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError};
 use crate::vhdx::vhdx_io::VhdxIoError;
 use crate::vhdx::vhdx_metadata::{DiskSpec, VhdxMetadataError};
-use crate::BlockBackend;
 
 mod vhdx_bat;
 mod vhdx_header;

block/src/vhdx/vhdx_io.rs

@@ -35,9 +35,7 @@ pub enum VhdxIoError {
 pub type Result<T> = std::result::Result<T, VhdxIoError>;
 
 macro_rules! align {
-    ($n:expr, $align:expr) => {{
-        $n.div_ceil($align) * $align
-    }};
+    ($n:expr, $align:expr) => {{ $n.div_ceil($align) * $align }};
 }
 
 #[derive(Default)]

block/src/vhdx_sync.rs

@@ -8,11 +8,11 @@ use std::os::fd::AsRawFd;
 
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::AsyncAdaptor;
 use crate::async_io::{
     AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::vhdx::{Result as VhdxResult, Vhdx};
-use crate::AsyncAdaptor;
 
 pub struct VhdxDiskSync {
     vhdx_file: Vhdx,

devices/src/acpi.rs

@@ -8,9 +8,9 @@ use std::sync::{Arc, Barrier};
 use std::thread;
 use std::time::Instant;
 
-use acpi_tables::{aml, Aml, AmlSink};
-use vm_device::interrupt::InterruptSourceGroup;
+use acpi_tables::{Aml, AmlSink, aml};
 use vm_device::BusDevice;
+use vm_device::interrupt::InterruptSourceGroup;
 use vm_memory::GuestAddress;
 use vmm_sys_util::eventfd::EventFd;
 

devices/src/gic.rs

@@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
 
 use anyhow::anyhow;
 use arch::layout;
-use hypervisor::arch::aarch64::gic::{GicState, Vgic, VgicConfig};
 use hypervisor::CpuState;
+use hypervisor::arch::aarch64::gic::{GicState, Vgic, VgicConfig};
 use vm_device::interrupt::{
     InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
     LegacyIrqSourceConfig, MsiIrqGroupConfig,

devices/src/ioapic.rs

@@ -14,11 +14,11 @@ use std::sync::{Arc, Barrier};
 
 use byteorder::{ByteOrder, LittleEndian};
 use serde::{Deserialize, Serialize};
+use vm_device::BusDevice;
 use vm_device::interrupt::{
     InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
     MsiIrqGroupConfig, MsiIrqSourceConfig,
 };
-use vm_device::BusDevice;
 use vm_memory::GuestAddress;
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::eventfd::EventFd;

devices/src/ivshmem.rs

@@ -12,9 +12,9 @@ use std::sync::{Arc, Barrier, Mutex};
 use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use pci::{
-    BarReprogrammingParams, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType,
-    PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass,
-    PCI_CONFIGURATION_ID,
+    BarReprogrammingParams, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable,
+    PciBarRegionType, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType,
+    PciSubclass,
 };
 use serde::{Deserialize, Serialize};
 use thiserror::Error;

devices/src/legacy/cmos.rs

@@ -12,7 +12,7 @@ use std::{mem, thread};
 // https://github.com/rust-lang/libc/issues/1848
 #[cfg_attr(target_env = "musl", allow(deprecated))]
 use libc::time_t;
-use libc::{clock_gettime, gmtime_r, timespec, tm, CLOCK_REALTIME};
+use libc::{CLOCK_REALTIME, clock_gettime, gmtime_r, timespec, tm};
 use vm_device::BusDevice;
 use vmm_sys_util::eventfd::EventFd;
 

devices/src/legacy/fw_cfg.rs

@@ -20,6 +20,7 @@ use std::{
 };
 
 use acpi_tables::rsdp::Rsdp;
+use arch::RegionType;
 #[cfg(target_arch = "aarch64")]
 use arch::aarch64::layout::{
     MEM_32BIT_DEVICES_START, MEM_32BIT_RESERVED_START, RAM_64BIT_START, RAM_START as HIGH_RAM_START,
@@ -29,7 +30,6 @@ use arch::layout::{
     EBDA_START, HIGH_RAM_START, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START,
     MEM_32BIT_RESERVED_START, PCI_MMCONFIG_SIZE, PCI_MMCONFIG_START, RAM_64BIT_START,
 };
-use arch::RegionType;
 use bitfield_struct::bitfield;
 #[cfg(target_arch = "x86_64")]
 use linux_loader::bootparam::boot_params;
@@ -752,7 +752,9 @@ impl BusDevice for FwCfg {
                 data.copy_from_slice(&addr_lo.to_be_bytes());
             }
             _ => {
-                debug!("fw_cfg: read from unknown port {port:#x}: {size:#x} bytes and offset {offset:#x}.");
+                debug!(
+                    "fw_cfg: read from unknown port {port:#x}: {size:#x} bytes and offset {offset:#x}."
+                );
             }
         };
     }

devices/src/legacy/gpio_pl061.rs

@@ -12,8 +12,8 @@ use std::{io, result};
 
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use vm_device::interrupt::InterruptSourceGroup;
 use vm_device::BusDevice;
+use vm_device::interrupt::InterruptSourceGroup;
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 
 use crate::{read_le_u32, write_le_u32};

devices/src/legacy/serial.rs

@@ -10,8 +10,8 @@ use std::sync::{Arc, Barrier};
 use std::{io, result};
 
 use serde::{Deserialize, Serialize};
-use vm_device::interrupt::InterruptSourceGroup;
 use vm_device::BusDevice;
+use vm_device::interrupt::InterruptSourceGroup;
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::errno::Result;
 

devices/src/legacy/uart_pl011.rs

@@ -13,8 +13,8 @@ use std::{io, result};
 
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use vm_device::interrupt::InterruptSourceGroup;
 use vm_device::BusDevice;
+use vm_device::interrupt::InterruptSourceGroup;
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 
 use crate::{read_le_u32, write_le_u32};

devices/src/lib.rs

@@ -37,7 +37,7 @@ pub mod tpm;
 pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};
 #[cfg(feature = "ivshmem")]
 pub use self::ivshmem::IvshmemDevice;
-pub use self::pvpanic::{PvPanicDevice, PVPANIC_DEVICE_MMIO_SIZE};
+pub use self::pvpanic::{PVPANIC_DEVICE_MMIO_SIZE, PvPanicDevice};
 
 bitflags! {
     pub struct AcpiNotificationFlags: u8 {

devices/src/pvmemcontrol.rs

@@ -520,7 +520,7 @@ impl PvmemcontrolBusDevice {
                     ret_value: get_page_size().into(),
                     arg0: MAJOR_VERSION.into(),
                     arg1: MINOR_VERSION.into(),
-                })
+                });
             }
             FunctionCode::Dontneed => self.madvise(addr, length, libc::MADV_DONTNEED),
             FunctionCode::Remove => self.madvise(addr, length, libc::MADV_REMOVE),

devices/src/pvpanic.rs

@@ -9,9 +9,9 @@ use std::sync::{Arc, Barrier, Mutex};
 
 use anyhow::anyhow;
 use pci::{
-    BarReprogrammingParams, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType,
-    PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass,
-    PCI_CONFIGURATION_ID,
+    BarReprogrammingParams, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable,
+    PciBarRegionType, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType,
+    PciSubclass,
 };
 use serde::{Deserialize, Serialize};
 use thiserror::Error;

devices/src/tpm.rs

@@ -12,8 +12,8 @@ use arch::aarch64::layout::{TPM_SIZE, TPM_START};
 #[cfg(target_arch = "x86_64")]
 use arch::x86_64::layout::{TPM_SIZE, TPM_START};
 use thiserror::Error;
-use tpm::emulator::{BackendCmd, Emulator};
 use tpm::TPM_CRB_BUFFER_MAX;
+use tpm::emulator::{BackendCmd, Emulator};
 use vm_device::BusDevice;
 
 #[derive(Error, Debug)]

hypervisor/src/arch/x86/emulator/instructions/mod.rs

@@ -7,8 +7,8 @@
 use iced_x86::*;
 
 use crate::arch::emulator::{EmulationError, PlatformEmulator, PlatformError};
-use crate::arch::x86::emulator::CpuStateManager;
 use crate::arch::x86::Exception;
+use crate::arch::x86::emulator::CpuStateManager;
 
 pub mod cmp;
 pub mod mov;

hypervisor/src/arch/x86/emulator/mod.rs

@@ -7,13 +7,13 @@
 use anyhow::Context;
 use iced_x86::*;
 
+use crate::StandardRegisters;
 use crate::arch::emulator::{EmulationError, EmulationResult, PlatformEmulator, PlatformError};
 use crate::arch::x86::emulator::instructions::*;
 use crate::arch::x86::regs::{CR0_PE, EFER_LMA};
 use crate::arch::x86::{
-    segment_type_expand_down, segment_type_ro, Exception, SegmentRegister, SpecialRegisters,
+    Exception, SegmentRegister, SpecialRegisters, segment_type_expand_down, segment_type_ro,
 };
-use crate::StandardRegisters;
 
 #[macro_use]
 mod instructions;
@@ -254,7 +254,7 @@ impl CpuStateManager for EmulatorCpuState {
                 return Err(PlatformError::InvalidRegister(anyhow!(
                     "read_reg invalid GPR {:?}",
                     r
-                )))
+                )));
             }
         };
 
@@ -375,7 +375,7 @@ impl CpuStateManager for EmulatorCpuState {
                 return Err(PlatformError::InvalidRegister(anyhow!(
                     "write_reg invalid register {:?}",
                     reg
-                )))
+                )));
             }
         }
 
@@ -660,9 +660,9 @@ mod mock_vmm {
     use std::sync::{Arc, Mutex};
 
     use super::*;
+    use crate::StandardRegisters;
     use crate::arch::x86::emulator::EmulatorCpuState as CpuState;
     use crate::arch::x86::gdt::{gdt_entry, segment_from_gdt};
-    use crate::StandardRegisters;
 
     #[derive(Debug, Clone)]
     pub struct MockVmm {

hypervisor/src/cpu.rs

@@ -17,14 +17,14 @@ use thiserror::Error;
 #[cfg(not(target_arch = "riscv64"))]
 use vm_memory::GuestAddress;
 
-#[cfg(target_arch = "x86_64")]
-use crate::arch::x86::{CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters};
-#[cfg(feature = "tdx")]
-use crate::kvm::{TdxExitDetails, TdxExitStatus};
 #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use crate::RegList;
 #[cfg(target_arch = "aarch64")]
 use crate::VcpuInit;
+#[cfg(target_arch = "x86_64")]
+use crate::arch::x86::{CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters};
+#[cfg(feature = "tdx")]
+use crate::kvm::{TdxExitDetails, TdxExitStatus};
 use crate::{CpuState, MpState, StandardRegisters};
 
 #[cfg(target_arch = "x86_64")]

hypervisor/src/hypervisor.rs

@@ -13,6 +13,7 @@ use std::sync::Arc;
 
 use thiserror::Error;
 
+use crate::HypervisorType;
 #[cfg(target_arch = "x86_64")]
 use crate::arch::x86::CpuIdEntry;
 #[cfg(target_arch = "x86_64")]
@@ -20,7 +21,6 @@ use crate::cpu::CpuVendor;
 #[cfg(feature = "tdx")]
 use crate::kvm::TdxCapabilities;
 use crate::vm::Vm;
-use crate::HypervisorType;
 
 #[derive(Error, Debug)]
 pub enum HypervisorError {

hypervisor/src/kvm/aarch64/gic/dist_regs.rs

@@ -6,7 +6,7 @@ use kvm_ioctls::DeviceFd;
 use crate::arch::aarch64::gic::{Error, Result};
 use crate::device::HypervisorDeviceError;
 use crate::kvm::kvm_bindings::{
-    kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_DIST_REGS, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
+    KVM_DEV_ARM_VGIC_GRP_DIST_REGS, KVM_DEV_ARM_VGIC_GRP_NR_IRQS, kvm_device_attr,
 };
 
 /*

hypervisor/src/kvm/aarch64/gic/icc_regs.rs

@@ -7,10 +7,11 @@ use kvm_ioctls::DeviceFd;
 use crate::arch::aarch64::gic::{Error, Result};
 use crate::device::HypervisorDeviceError;
 use crate::kvm::kvm_bindings::{
-    kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, KVM_REG_ARM64_SYSREG_CRM_MASK,
+    KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, KVM_REG_ARM64_SYSREG_CRM_MASK,
     KVM_REG_ARM64_SYSREG_CRM_SHIFT, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_CRN_SHIFT,
     KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP1_MASK,
     KVM_REG_ARM64_SYSREG_OP1_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT,
+    kvm_device_attr,
 };
 
 const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32;

hypervisor/src/kvm/aarch64/gic/redist_regs.rs

@@ -4,15 +4,15 @@
 
 use kvm_ioctls::DeviceFd;
 
+use crate::CpuState;
 use crate::arch::aarch64::gic::{Error, Result};
 use crate::device::HypervisorDeviceError;
-use crate::kvm::kvm_bindings::{
-    kvm_device_attr, kvm_one_reg, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS, KVM_REG_ARM64,
-    KVM_REG_ARM64_SYSREG, KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT,
-    KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT, KVM_REG_SIZE_U64,
-};
 use crate::kvm::VcpuKvmState;
-use crate::CpuState;
+use crate::kvm::kvm_bindings::{
+    KVM_DEV_ARM_VGIC_GRP_REDIST_REGS, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG,
+    KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK,
+    KVM_REG_ARM64_SYSREG_OP2_SHIFT, KVM_REG_SIZE_U64, kvm_device_attr, kvm_one_reg,
+};
 
 // Relevant redistributor registers that we want to save/restore.
 const GICR_CTLR: u32 = 0x0000;

hypervisor/src/kvm/aarch64/mod.rs

@@ -11,8 +11,8 @@
 pub mod gic;
 
 use kvm_bindings::{
-    kvm_mp_state, kvm_one_reg, kvm_regs, KVM_REG_ARM_COPROC_MASK, KVM_REG_ARM_CORE,
-    KVM_REG_SIZE_MASK, KVM_REG_SIZE_U32, KVM_REG_SIZE_U64,
+    KVM_REG_ARM_COPROC_MASK, KVM_REG_ARM_CORE, KVM_REG_SIZE_MASK, KVM_REG_SIZE_U32,
+    KVM_REG_SIZE_U64, kvm_mp_state, kvm_one_reg, kvm_regs,
 };
 pub use kvm_ioctls::{Cap, Kvm};
 use serde::{Deserialize, Serialize};

hypervisor/src/kvm/mod.rs

@@ -29,7 +29,7 @@ use vmm_sys_util::eventfd::EventFd;
 #[cfg(target_arch = "aarch64")]
 use crate::aarch64::gic::KvmGicV3Its;
 #[cfg(target_arch = "aarch64")]
-pub use crate::aarch64::{check_required_kvm_extensions, is_system_register, VcpuKvmState};
+pub use crate::aarch64::{VcpuKvmState, check_required_kvm_extensions, is_system_register};
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::gic::{Vgic, VgicConfig};
 #[cfg(target_arch = "riscv64")]
@@ -40,36 +40,37 @@ use crate::arm64_core_reg_id;
 use crate::riscv64::aia::KvmAiaImsics;
 #[cfg(target_arch = "riscv64")]
 pub use crate::riscv64::{
-    aia::AiaImsicsState as AiaState, check_required_kvm_extensions, is_non_core_register,
-    VcpuKvmState,
+    VcpuKvmState, aia::AiaImsicsState as AiaState, check_required_kvm_extensions,
+    is_non_core_register,
 };
 #[cfg(target_arch = "riscv64")]
 use crate::riscv64_reg_id;
 use crate::vm::{self, InterruptSourceConfig, VmOps};
-use crate::{cpu, hypervisor, HypervisorType};
+use crate::{HypervisorType, cpu, hypervisor};
 // x86_64 dependencies
 #[cfg(target_arch = "x86_64")]
 pub mod x86_64;
 #[cfg(target_arch = "x86_64")]
 use kvm_bindings::{
-    kvm_enable_cap, kvm_msr_entry, MsrList, KVM_CAP_HYPERV_SYNIC, KVM_CAP_SPLIT_IRQCHIP,
-    KVM_CAP_X2APIC_API, KVM_GUESTDBG_USE_HW_BP, KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK,
-    KVM_X2APIC_API_USE_32BIT_IDS,
+    KVM_CAP_HYPERV_SYNIC, KVM_CAP_SPLIT_IRQCHIP, KVM_CAP_X2APIC_API, KVM_GUESTDBG_USE_HW_BP,
+    KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK, KVM_X2APIC_API_USE_32BIT_IDS, MsrList, kvm_enable_cap,
+    kvm_msr_entry,
 };
 #[cfg(target_arch = "x86_64")]
 use x86_64::check_required_kvm_extensions;
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::{CpuId, ExtendedControlRegisters, MsrEntries, VcpuKvmState};
 
-#[cfg(target_arch = "x86_64")]
-use crate::arch::x86::{
-    CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters, XsaveState, NUM_IOAPIC_PINS,
-};
 #[cfg(target_arch = "x86_64")]
 use crate::ClockData;
+#[cfg(target_arch = "x86_64")]
+use crate::arch::x86::{
+    CpuIdEntry, FpuState, LapicState, MsrEntry, NUM_IOAPIC_PINS, SpecialRegisters, XsaveState,
+};
 use crate::{
-    CpuState, IoEventAddress, IrqRoutingEntry, MpState, StandardRegisters, UserMemoryRegion,
+    CpuState, IoEventAddress, IrqRoutingEntry, MpState, StandardRegisters,
     USER_MEMORY_REGION_LOG_DIRTY, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE,
+    UserMemoryRegion,
 };
 // aarch64 dependencies
 #[cfg(target_arch = "aarch64")]
@@ -86,23 +87,23 @@ use std::mem;
 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
 pub use kvm_bindings::kvm_vcpu_events as VcpuEvents;
 pub use kvm_bindings::{
-    kvm_clock_data, kvm_create_device, kvm_create_device as CreateDevice,
-    kvm_device_attr as DeviceAttr, kvm_device_type_KVM_DEV_TYPE_VFIO, kvm_guest_debug,
-    kvm_irq_routing, kvm_irq_routing_entry, kvm_mp_state, kvm_run, kvm_userspace_memory_region,
     KVM_GUESTDBG_ENABLE, KVM_GUESTDBG_SINGLESTEP, KVM_IRQ_ROUTING_IRQCHIP, KVM_IRQ_ROUTING_MSI,
-    KVM_MEM_LOG_DIRTY_PAGES, KVM_MEM_READONLY, KVM_MSI_VALID_DEVID,
+    KVM_MEM_LOG_DIRTY_PAGES, KVM_MEM_READONLY, KVM_MSI_VALID_DEVID, kvm_clock_data,
+    kvm_create_device, kvm_create_device as CreateDevice, kvm_device_attr as DeviceAttr,
+    kvm_device_type_KVM_DEV_TYPE_VFIO, kvm_guest_debug, kvm_irq_routing, kvm_irq_routing_entry,
+    kvm_mp_state, kvm_run, kvm_userspace_memory_region,
 };
 #[cfg(target_arch = "aarch64")]
 use kvm_bindings::{
-    kvm_regs, user_pt_regs, KVM_GUESTDBG_USE_HW, KVM_NR_SPSR, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG,
+    KVM_GUESTDBG_USE_HW, KVM_NR_SPSR, KVM_REG_ARM_CORE, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG,
     KVM_REG_ARM64_SYSREG_CRM_MASK, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_OP0_MASK,
-    KVM_REG_ARM64_SYSREG_OP1_MASK, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM_CORE,
-    KVM_REG_SIZE_U128, KVM_REG_SIZE_U32, KVM_REG_SIZE_U64,
+    KVM_REG_ARM64_SYSREG_OP1_MASK, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_SIZE_U32,
+    KVM_REG_SIZE_U64, KVM_REG_SIZE_U128, kvm_regs, user_pt_regs,
 };
 #[cfg(target_arch = "riscv64")]
-use kvm_bindings::{kvm_riscv_core, KVM_REG_RISCV_CORE};
+use kvm_bindings::{KVM_REG_RISCV_CORE, kvm_riscv_core};
 #[cfg(feature = "tdx")]
-use kvm_bindings::{kvm_run__bindgen_ty_1, KVMIO};
+use kvm_bindings::{KVMIO, kvm_run__bindgen_ty_1};
 pub use kvm_ioctls::{Cap, Kvm, VcpuExit};
 use thiserror::Error;
 use vfio_ioctls::VfioDeviceFd;
@@ -112,10 +113,10 @@ use vmm_sys_util::ioctl_io_nr;
 use vmm_sys_util::{ioctl::ioctl_with_val, ioctl_iowr_nr};
 pub use {kvm_bindings, kvm_ioctls};
 
-#[cfg(target_arch = "aarch64")]
-use crate::arch::aarch64::regs;
 #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use crate::RegList;
+#[cfg(target_arch = "aarch64")]
+use crate::arch::aarch64::regs;
 #[cfg(target_arch = "x86_64")]
 ioctl_io_nr!(KVM_NMI, kvm_bindings::KVMIO, 0x9a);
 
@@ -2866,7 +2867,7 @@ impl cpu::Vcpu for KvmVcpu {
     /// Return the list of initial MSR entries for a VCPU
     ///
     fn boot_msr_entries(&self) -> Vec<MsrEntry> {
-        use crate::arch::x86::{msr_index, MTRR_ENABLE, MTRR_MEM_TYPE_WB};
+        use crate::arch::x86::{MTRR_ENABLE, MTRR_MEM_TYPE_WB, msr_index};
 
         [
             msr!(msr_index::MSR_IA32_SYSENTER_CS),

hypervisor/src/kvm/riscv64/aia.rs

@@ -7,10 +7,10 @@ use std::any::Any;
 use kvm_ioctls::DeviceFd;
 use serde::{Deserialize, Serialize};
 
+use crate::Vm;
 use crate::arch::riscv64::aia::{Error, Result, Vaia, VaiaConfig};
 use crate::device::HypervisorDeviceError;
 use crate::kvm::KvmVm;
-use crate::Vm;
 
 pub struct KvmAiaImsics {
     /// The KVM device for the Aia

hypervisor/src/kvm/riscv64/mod.rs

@@ -5,8 +5,8 @@
 pub mod aia;
 
 use kvm_bindings::{
-    kvm_mp_state, kvm_one_reg, kvm_riscv_core, KVM_REG_RISCV_CORE, KVM_REG_RISCV_TYPE_MASK,
-    KVM_REG_SIZE_MASK, KVM_REG_SIZE_U64,
+    KVM_REG_RISCV_CORE, KVM_REG_RISCV_TYPE_MASK, KVM_REG_SIZE_MASK, KVM_REG_SIZE_U64, kvm_mp_state,
+    kvm_one_reg, kvm_riscv_core,
 };
 pub use kvm_ioctls::{Cap, Kvm};
 use serde::{Deserialize, Serialize};

hypervisor/src/kvm/x86_64/mod.rs

@@ -13,18 +13,17 @@ use serde::{Deserialize, Serialize};
 /// Export generically-named wrappers of kvm-bindings for Unix-based platforms
 ///
 pub use {
-    kvm_bindings::kvm_cpuid_entry2, kvm_bindings::kvm_dtable, kvm_bindings::kvm_fpu,
-    kvm_bindings::kvm_lapic_state, kvm_bindings::kvm_mp_state as MpState,
+    kvm_bindings::CpuId, kvm_bindings::KVM_CPUID_FLAG_SIGNIFCANT_INDEX, kvm_bindings::MsrList,
+    kvm_bindings::Msrs as MsrEntries, kvm_bindings::kvm_cpuid_entry2, kvm_bindings::kvm_dtable,
+    kvm_bindings::kvm_fpu, kvm_bindings::kvm_lapic_state, kvm_bindings::kvm_mp_state as MpState,
     kvm_bindings::kvm_msr_entry, kvm_bindings::kvm_regs, kvm_bindings::kvm_segment,
     kvm_bindings::kvm_sregs, kvm_bindings::kvm_vcpu_events as VcpuEvents,
     kvm_bindings::kvm_xcrs as ExtendedControlRegisters, kvm_bindings::kvm_xsave,
-    kvm_bindings::CpuId, kvm_bindings::MsrList, kvm_bindings::Msrs as MsrEntries,
-    kvm_bindings::KVM_CPUID_FLAG_SIGNIFCANT_INDEX,
 };
 
 use crate::arch::x86::{
-    CpuIdEntry, DescriptorTable, FpuState, LapicState, MsrEntry, SegmentRegister, SpecialRegisters,
-    XsaveState, CPUID_FLAG_VALID_INDEX,
+    CPUID_FLAG_VALID_INDEX, CpuIdEntry, DescriptorTable, FpuState, LapicState, MsrEntry,
+    SegmentRegister, SpecialRegisters, XsaveState,
 };
 use crate::kvm::{Cap, Kvm, KvmError, KvmResult};
 

hypervisor/src/lib.rs

@@ -61,7 +61,7 @@ pub use device::HypervisorDeviceError;
 #[cfg(all(feature = "kvm", target_arch = "aarch64"))]
 pub use kvm::aarch64;
 #[cfg(all(feature = "kvm", target_arch = "riscv64"))]
-pub use kvm::{riscv64, AiaState};
+pub use kvm::{AiaState, riscv64};
 pub use vm::{
     DataMatch, HypervisorVmError, InterruptSourceConfig, LegacyIrqSourceConfig, MsiIrqSourceConfig,
     Vm, VmOps,

hypervisor/src/mshv/mod.rs

@@ -14,7 +14,7 @@ use arc_swap::ArcSwap;
 use mshv_bindings::*;
 #[cfg(target_arch = "x86_64")]
 use mshv_ioctls::InterruptRequest;
-use mshv_ioctls::{set_registers_64, Mshv, NoDatamatch, VcpuFd, VmFd, VmType};
+use mshv_ioctls::{Mshv, NoDatamatch, VcpuFd, VmFd, VmType, set_registers_64};
 use vfio_ioctls::VfioDeviceFd;
 use vm::DataMatch;
 #[cfg(feature = "sev_snp")]
@@ -32,7 +32,7 @@ use crate::arch::x86::emulator::Emulator;
 use crate::mshv::aarch64::emulator;
 use crate::mshv::emulator::MshvEmulatorContext;
 use crate::vm::{self, InterruptSourceConfig, VmOps};
-use crate::{cpu, hypervisor, vec_with_array_field, HypervisorType};
+use crate::{HypervisorType, cpu, hypervisor, vec_with_array_field};
 #[cfg(feature = "sev_snp")]
 mod snp_constants;
 // x86_64 dependencies
@@ -45,10 +45,10 @@ use std::os::unix::io::AsRawFd;
 #[cfg(target_arch = "aarch64")]
 use std::sync::Mutex;
 
-#[cfg(target_arch = "aarch64")]
-use aarch64::gic::{MshvGicV2M, BASE_SPI_IRQ};
 #[cfg(target_arch = "aarch64")]
 pub use aarch64::VcpuMshvState;
+#[cfg(target_arch = "aarch64")]
+use aarch64::gic::{BASE_SPI_IRQ, MshvGicV2M};
 #[cfg(feature = "sev_snp")]
 use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
 #[cfg(feature = "sev_snp")]
@@ -57,7 +57,7 @@ use vmm_sys_util::eventfd::EventFd;
 #[cfg(target_arch = "x86_64")]
 pub use x86_64::*;
 #[cfg(target_arch = "x86_64")]
-pub use x86_64::{emulator, VcpuMshvState};
+pub use x86_64::{VcpuMshvState, emulator};
 ///
 /// Export generically-named wrappers of mshv-bindings for Unix-based platforms
 ///
@@ -66,18 +66,18 @@ pub use {
     mshv_bindings::mshv_device_attr as DeviceAttr, mshv_ioctls, mshv_ioctls::DeviceFd,
 };
 
+#[cfg(target_arch = "x86_64")]
+use crate::ClockData;
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::gic::{Vgic, VgicConfig};
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::regs;
 #[cfg(target_arch = "x86_64")]
 use crate::arch::x86::{CpuIdEntry, FpuState, MsrEntry};
-#[cfg(target_arch = "x86_64")]
-use crate::ClockData;
 use crate::{
-    CpuState, IoEventAddress, IrqRoutingEntry, MpState, UserMemoryRegion,
-    USER_MEMORY_REGION_ADJUSTABLE, USER_MEMORY_REGION_EXECUTE, USER_MEMORY_REGION_READ,
-    USER_MEMORY_REGION_WRITE,
+    CpuState, IoEventAddress, IrqRoutingEntry, MpState, USER_MEMORY_REGION_ADJUSTABLE,
+    USER_MEMORY_REGION_EXECUTE, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE,
+    UserMemoryRegion,
 };
 
 pub const PAGE_SHIFT: usize = 12;
@@ -1512,7 +1512,7 @@ impl cpu::Vcpu for MshvVcpu {
     /// Return the list of initial MSR entries for a VCPU
     ///
     fn boot_msr_entries(&self) -> Vec<MsrEntry> {
-        use crate::arch::x86::{msr_index, MTRR_ENABLE, MTRR_MEM_TYPE_WB};
+        use crate::arch::x86::{MTRR_ENABLE, MTRR_MEM_TYPE_WB, msr_index};
 
         [
             msr!(msr_index::MSR_IA32_SYSENTER_CS),

hypervisor/src/mshv/x86_64/mod.rs

@@ -21,16 +21,16 @@ pub mod emulator;
 /// Export generically-named wrappers of mshv_bindings for Unix-based platforms
 ///
 pub use {
-    mshv_bindings::hv_cpuid_entry, mshv_bindings::mshv_user_mem_region as MemoryRegion,
-    mshv_bindings::msr_entry, mshv_bindings::AllVpStateComponents, mshv_bindings::CpuId,
-    mshv_bindings::DebugRegisters, mshv_bindings::FloatingPointUnit,
-    mshv_bindings::LapicState as MshvLapicState, mshv_bindings::MiscRegs as MiscRegisters,
-    mshv_bindings::MsrList, mshv_bindings::Msrs as MsrEntries, mshv_bindings::Msrs,
+    mshv_bindings::AllVpStateComponents, mshv_bindings::CpuId, mshv_bindings::DebugRegisters,
+    mshv_bindings::FloatingPointUnit, mshv_bindings::LapicState as MshvLapicState,
+    mshv_bindings::MiscRegs as MiscRegisters, mshv_bindings::MsrList,
+    mshv_bindings::Msrs as MsrEntries, mshv_bindings::Msrs,
     mshv_bindings::SegmentRegister as MshvSegmentRegister,
     mshv_bindings::SpecialRegisters as MshvSpecialRegisters,
     mshv_bindings::StandardRegisters as MshvStandardRegisters, mshv_bindings::SuspendRegisters,
     mshv_bindings::TableRegister, mshv_bindings::VcpuEvents, mshv_bindings::XSave as Xsave,
-    mshv_bindings::Xcrs as ExtendedControlRegisters,
+    mshv_bindings::Xcrs as ExtendedControlRegisters, mshv_bindings::hv_cpuid_entry,
+    mshv_bindings::mshv_user_mem_region as MemoryRegion, mshv_bindings::msr_entry,
 };
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -60,7 +60,9 @@ impl fmt::Display for VcpuMshvState {
             msr_entries[i][1] = entry.data;
             msr_entries[i][0] = entry.index as u64;
         }
-        write!(f, "Number of MSRs: {}: MSRs: {:#010X?}, -- VCPU Events: {:?} -- Standard registers: {:?} Special Registers: {:?} ---- Floating Point Unit: {:?} --- Extended Control Register: {:?} --- DBG: {:?} --- VP States: {:?}",
+        write!(
+            f,
+            "Number of MSRs: {}: MSRs: {:#010X?}, -- VCPU Events: {:?} -- Standard registers: {:?} Special Registers: {:?} ---- Floating Point Unit: {:?} --- Extended Control Register: {:?} --- DBG: {:?} --- VP States: {:?}",
             msr_entries.len(),
             msr_entries,
             self.vcpu_events,

hypervisor/src/vm.rs

@@ -20,6 +20,8 @@ use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
 use thiserror::Error;
 use vmm_sys_util::eventfd::EventFd;
 
+#[cfg(target_arch = "x86_64")]
+use crate::ClockData;
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::gic::{Vgic, VgicConfig};
 #[cfg(target_arch = "riscv64")]
@@ -27,8 +29,6 @@ use crate::arch::riscv64::aia::{Vaia, VaiaConfig};
 #[cfg(feature = "tdx")]
 use crate::arch::x86::CpuIdEntry;
 use crate::cpu::Vcpu;
-#[cfg(target_arch = "x86_64")]
-use crate::ClockData;
 use crate::{IoEventAddress, IrqRoutingEntry, UserMemoryRegion};
 
 ///

net_util/src/lib.rs

@@ -23,18 +23,18 @@ use std::{io, mem, net};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use virtio_bindings::virtio_net::{
-    virtio_net_hdr_v1, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN,
-    VIRTIO_NET_F_GUEST_CSUM, VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_TSO4,
-    VIRTIO_NET_F_GUEST_TSO6, VIRTIO_NET_F_GUEST_UFO, VIRTIO_NET_F_MAC, VIRTIO_NET_F_MQ,
+    VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN, VIRTIO_NET_F_GUEST_CSUM,
+    VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_TSO6,
+    VIRTIO_NET_F_GUEST_UFO, VIRTIO_NET_F_MAC, VIRTIO_NET_F_MQ, virtio_net_hdr_v1,
 };
-use vm_memory::bitmap::AtomicBitmap;
 use vm_memory::ByteValued;
+use vm_memory::bitmap::AtomicBitmap;
 
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
 
 pub use ctrl_queue::{CtrlQueue, Error as CtrlQueueError};
-pub use mac::{MacAddr, MAC_ADDR_LEN};
-pub use open_tap::{open_tap, Error as OpenTapError};
+pub use mac::{MAC_ADDR_LEN, MacAddr};
+pub use open_tap::{Error as OpenTapError, open_tap};
 pub use queue_pair::{NetCounters, NetQueuePair, NetQueuePairError, RxVirtio, TxVirtio};
 pub use tap::{Error as TapError, Tap};
 

net_util/src/open_tap.rs

@@ -8,7 +8,7 @@ use std::{fs, io};
 
 use thiserror::Error;
 
-use super::{vnet_hdr_len, MacAddr, Tap, TapError};
+use super::{MacAddr, Tap, TapError, vnet_hdr_len};
 
 #[derive(Error, Debug)]
 pub enum Error {

net_util/src/queue_pair.rs

@@ -5,8 +5,8 @@
 use std::io;
 use std::num::Wrapping;
 use std::os::unix::io::{AsRawFd, RawFd};
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 
 use rate_limiter::{RateLimiter, TokenType};
 use thiserror::Error;
@@ -15,7 +15,7 @@ use vm_memory::bitmap::Bitmap;
 use vm_memory::{Bytes, GuestMemory};
 use vm_virtio::{AccessPlatform, Translatable};
 
-use super::{register_listener, unregister_listener, vnet_hdr_len, Tap};
+use super::{Tap, register_listener, unregister_listener, vnet_hdr_len};
 
 #[derive(Clone)]
 pub struct TxVirtio {

net_util/src/tap.rs

@@ -15,8 +15,8 @@ use thiserror::Error;
 use vmm_sys_util::ioctl::{ioctl_with_mut_ref, ioctl_with_ref, ioctl_with_val};
 
 use super::{
-    create_inet_socket, create_sockaddr, create_unix_socket, vnet_hdr_len, Error as NetUtilError,
-    MacAddr,
+    Error as NetUtilError, MacAddr, create_inet_socket, create_sockaddr, create_unix_socket,
+    vnet_hdr_len,
 };
 use crate::mac::MAC_ADDR_LEN;
 
@@ -551,7 +551,7 @@ impl AsRawFd for Tap {
 #[cfg(test)]
 mod tests {
     use std::net::Ipv4Addr;
-    use std::sync::{mpsc, LazyLock, Mutex};
+    use std::sync::{LazyLock, Mutex, mpsc};
     use std::time::Duration;
     use std::{str, thread};
 
@@ -860,7 +860,8 @@ mod tests {
 
         // We use a separate thread to wait for the test packet because the API exposed by pnet is
         // blocking. This thread will be killed when the main thread exits.
-        let _handle = thread::spawn(move || loop {
+        let _handle = thread::spawn(move || {
+            loop {
                 let buf = rx.next().unwrap();
                 let p = ParsedPkt::new(buf);
                 p.print();
@@ -871,6 +872,7 @@ mod tests {
                         break;
                     }
                 }
+            }
         });
 
         // We wait for at most SLEEP_MILLIS * SLEEP_ITERS milliseconds for the reception of the

pci/src/bus.rs

@@ -13,11 +13,11 @@ use byteorder::{ByteOrder, LittleEndian};
 use thiserror::Error;
 use vm_device::{Bus, BusDevice, BusDeviceSync};
 
+use crate::PciBarConfiguration;
 use crate::configuration::{
     PciBarRegionType, PciBridgeSubclass, PciClassCode, PciConfiguration, PciHeaderType,
 };
 use crate::device::{BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice};
-use crate::PciBarConfiguration;
 
 const VENDOR_ID_INTEL: u16 = 0x8086;
 const DEVICE_ID_INTEL_VIRT_PCIE_HOST: u16 = 0x0d57;

pci/src/device.rs

@@ -12,8 +12,8 @@ use thiserror::Error;
 use vm_allocator::{AddressAllocator, SystemAllocator};
 use vm_device::Resource;
 
-use crate::configuration::{self, PciBarRegionType};
 use crate::PciBarConfiguration;
+use crate::configuration::{self, PciBarRegionType};
 
 #[derive(Error, Debug)]
 pub enum Error {

pci/src/lib.rs

@@ -24,16 +24,16 @@ use serde::de::Visitor;
 
 pub use self::bus::{PciBus, PciConfigIo, PciConfigMmio, PciRoot, PciRootError};
 pub use self::configuration::{
-    PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciCapability, PciCapabilityId,
-    PciClassCode, PciConfiguration, PciExpressCapabilityId, PciHeaderType, PciMassStorageSubclass,
-    PciNetworkControllerSubclass, PciProgrammingInterface, PciSerialBusSubClass, PciSubclass,
-    PCI_CONFIGURATION_ID,
+    PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciCapability,
+    PciCapabilityId, PciClassCode, PciConfiguration, PciExpressCapabilityId, PciHeaderType,
+    PciMassStorageSubclass, PciNetworkControllerSubclass, PciProgrammingInterface,
+    PciSerialBusSubClass, PciSubclass,
 };
 pub use self::device::{
     BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice,
 };
-pub use self::msi::{msi_num_enabled_vectors, MsiCap, MsiConfig};
-pub use self::msix::{MsixCap, MsixConfig, MsixTableEntry, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE};
+pub use self::msi::{MsiCap, MsiConfig, msi_num_enabled_vectors};
+pub use self::msix::{MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, MsixCap, MsixConfig, MsixTableEntry};
 pub use self::vfio::{MmioRegion, VfioDmaMapping, VfioPciDevice, VfioPciError};
 pub use self::vfio_user::{VfioUserDmaMapping, VfioUserPciDevice, VfioUserPciDeviceError};
 

pci/src/vfio.rs

@@ -14,7 +14,7 @@ use std::sync::{Arc, Barrier, Mutex};
 use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use hypervisor::HypervisorVmError;
-use libc::{sysconf, _SC_PAGESIZE};
+use libc::{_SC_PAGESIZE, sysconf};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use vfio_bindings::bindings::vfio::*;
@@ -34,13 +34,13 @@ use vm_memory::{Address, GuestAddress, GuestAddressSpace, GuestMemory, GuestUsiz
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::eventfd::EventFd;
 
-use crate::msi::{MsiConfigState, MSI_CONFIG_ID};
+use crate::msi::{MSI_CONFIG_ID, MsiConfigState};
 use crate::msix::MsixConfigState;
 use crate::{
-    msi_num_enabled_vectors, BarReprogrammingParams, MsiCap, MsiConfig, MsixCap, MsixConfig,
-    PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciBdf, PciCapabilityId,
-    PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciExpressCapabilityId,
-    PciHeaderType, PciSubclass, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, PCI_CONFIGURATION_ID,
+    BarReprogrammingParams, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, MsiCap, MsiConfig, MsixCap,
+    MsixConfig, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType,
+    PciBdf, PciCapabilityId, PciClassCode, PciConfiguration, PciDevice, PciDeviceError,
+    PciExpressCapabilityId, PciHeaderType, PciSubclass, msi_num_enabled_vectors,
 };
 
 pub(crate) const VFIO_COMMON_ID: &str = "vfio_common";
@@ -1664,8 +1664,7 @@ impl VfioPciDevice {
                     if !is_page_size_aligned(area.size) || !is_page_size_aligned(area.offset) {
                         warn!(
                             "Could not mmap sparse area that is not page size aligned (offset = 0x{:x}, size = 0x{:x})",
-                            area.offset,
-                            area.size,
+                            area.offset, area.size,
                         );
                         return Ok(());
                     }
@@ -2040,9 +2039,9 @@ impl<M: GuestAddressSpace + Sync + Send> ExternalDmaMapping for VfioDmaMapping<M
             match mem.get_host_address(guest_addr) {
                 Ok(t) => t as u64,
                 Err(e) => {
-                    return Err(io::Error::other(
-                        format!("unable to retrieve user address for gpa 0x{gpa:x} from guest memory region: {e}")
-                    ));
+                    return Err(io::Error::other(format!(
+                        "unable to retrieve user address for gpa 0x{gpa:x} from guest memory region: {e}"
+                    )));
                 }
             }
         } else if self.mmio_regions.lock().unwrap().check_range(gpa, size) {

pci/src/vfio_user.rs

@@ -24,7 +24,7 @@ use vm_memory::{
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::eventfd::EventFd;
 
-use crate::vfio::{UserMemoryRegion, Vfio, VfioCommon, VfioError, VFIO_COMMON_ID};
+use crate::vfio::{UserMemoryRegion, VFIO_COMMON_ID, Vfio, VfioCommon, VfioError};
 use crate::{
     BarReprogrammingParams, PciBarConfiguration, PciBdf, PciDevice, PciDeviceError, PciSubclass,
     VfioPciError,

performance-metrics/src/main.rs

@@ -9,8 +9,8 @@ extern crate test_infra;
 mod performance_tests;
 
 use std::process::Command;
-use std::sync::mpsc::channel;
 use std::sync::Arc;
+use std::sync::mpsc::channel;
 use std::time::Duration;
 use std::{env, fmt, thread};
 

performance-metrics/src/performance_tests.rs

@@ -12,7 +12,7 @@ use std::{fs, thread};
 use test_infra::{Error as InfraError, *};
 use thiserror::Error;
 
-use crate::{mean, ImageFormat, PerformanceTestControl, PerformanceTestOverrides};
+use crate::{ImageFormat, PerformanceTestControl, PerformanceTestOverrides, mean};
 
 #[cfg(target_arch = "x86_64")]
 pub const FOCAL_IMAGE_NAME: &str = "focal-server-cloudimg-amd64-custom-20210609-0.raw";

rate_limiter/src/group.rs

@@ -306,7 +306,7 @@ pub(crate) mod tests {
 
     use super::RateLimiterGroupHandle;
     use crate::group::RateLimiterGroup;
-    use crate::{TokenBucket, TokenType, REFILL_TIMER_INTERVAL_MS};
+    use crate::{REFILL_TIMER_INTERVAL_MS, TokenBucket, TokenType};
 
     impl RateLimiterGroupHandle {
         fn bandwidth(&self) -> Option<TokenBucket> {

rate_limiter/src/lib.rs

@@ -48,8 +48,8 @@ extern crate log;
 
 use std::io;
 use std::os::unix::io::{AsRawFd, RawFd};
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{Duration, Instant};
 
 use thiserror::Error;
@@ -470,7 +470,7 @@ impl RateLimiter {
                         std::io::ErrorKind::WouldBlock => {
                             return Err(Error::SpuriousRateLimiterEvent(
                                 "Rate limiter event handler called without a present timer",
-                            ))
+                            ));
                         }
                         _ => return Err(Error::TimerFdWaitError(err)),
                     }

serial_buffer/src/lib.rs

@@ -5,8 +5,8 @@
 
 use std::collections::VecDeque;
 use std::io::Write;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 const MAX_BUFFER_SIZE: usize = 1 << 20;
 

src/bin/ch-remote.rs

@@ -13,8 +13,8 @@ use std::os::unix::net::UnixStream;
 use std::process;
 
 use api_client::{
-    simple_api_command, simple_api_command_with_fds, simple_api_full_command,
-    Error as ApiClientError,
+    Error as ApiClientError, simple_api_command, simple_api_command_with_fds,
+    simple_api_full_command,
 };
 use clap::{Arg, ArgAction, ArgMatches, Command};
 use log::error;
@@ -1128,7 +1128,9 @@ fn main() {
             process::exit(1);
         }
         _ => {
-            error!("Please either provide the api-socket option or dbus-service-name and dbus-object-path options");
+            error!(
+                "Please either provide the api-socket option or dbus-service-name and dbus-object-path options"
+            );
             process::exit(1);
         }
     };

src/main.rs

@@ -8,22 +8,22 @@ mod test_util;
 
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::sync::mpsc::channel;
 use std::sync::Mutex;
+use std::sync::mpsc::channel;
 use std::{env, io};
 
 use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command};
 use event_monitor::event;
 use libc::EFD_NONBLOCK;
-use log::{error, warn, LevelFilter};
+use log::{LevelFilter, error, warn};
 use option_parser::OptionParser;
 use seccompiler::SeccompAction;
 use signal_hook::consts::SIGSYS;
 use thiserror::Error;
-#[cfg(feature = "dbus_api")]
-use vmm::api::dbus::{dbus_api_graceful_shutdown, DBusApiOptions};
-use vmm::api::http::http_api_graceful_shutdown;
 use vmm::api::ApiAction;
+#[cfg(feature = "dbus_api")]
+use vmm::api::dbus::{DBusApiOptions, dbus_api_graceful_shutdown};
+use vmm::api::http::http_api_graceful_shutdown;
 use vmm::config::{RestoreConfig, VmParams};
 use vmm::landlock::{Landlock, LandlockError};
 use vmm::vm_config;

test_infra/src/lib.rs

@@ -1118,10 +1118,12 @@ impl Guest {
         thread::sleep(std::time::Duration::new(10, 0));
 
         // Write something to vsock from the host
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "echo -e \"CONNECT 16\\nHelloWorld!\" | socat - UNIX-CONNECT:{socket}"
             ))
-        .success());
+            .success()
+        );
 
         // Wait for the thread to terminate.
         listen_socat.join().unwrap();
@@ -1134,10 +1136,11 @@ impl Guest {
 
     #[cfg(target_arch = "x86_64")]
     pub fn check_nvidia_gpu(&self) {
-        assert!(self
-            .ssh_command("nvidia-smi")
+        assert!(
+            self.ssh_command("nvidia-smi")
                 .unwrap()
-            .contains("NVIDIA L40S"));
+                .contains("NVIDIA L40S")
+        );
     }
 
     pub fn reboot_linux(&self, current_reboot_count: u32, custom_timeout: Option<i32>) {
@@ -1334,11 +1337,9 @@ impl<'a> GuestCommand<'a> {
             if pipesize >= PIPE_SIZE && pipesize1 >= PIPE_SIZE {
                 Ok(child)
             } else {
-                Err(std::io::Error::other(
-                    format!(
+                Err(std::io::Error::other(format!(
                     "resizing pipe w/ 'fnctl' failed: stdout pipesize {pipesize}, stderr pipesize {pipesize1}"
-                    ),
-                ))
+                )))
             }
         } else {
             // The caller should call .wait() on the returned child

tests/integration.rs

@@ -20,7 +20,7 @@ use std::path::PathBuf;
 use std::process::{Child, Command, Stdio};
 use std::string::String;
 use std::sync::mpsc::Receiver;
-use std::sync::{mpsc, Mutex};
+use std::sync::{Mutex, mpsc};
 use std::time::Duration;
 use std::{fs, io, thread};
 
@@ -719,10 +719,12 @@ fn setup_ovs_dpdk() {
     assert!(exec_host_command_status("service openvswitch-switch restart").success());
 
     // Create OVS-DPDK bridge and ports
-    assert!(exec_host_command_status(
+    assert!(
+        exec_host_command_status(
             "ovs-vsctl add-br ovsbr0 -- set bridge ovsbr0 datapath_type=netdev",
         )
-    .success());
+        .success()
+    );
     assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user1 -- set Interface vhost-user1 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient1").success());
     assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user2 -- set Interface vhost-user2 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient2").success());
     assert!(exec_host_command_status("ip link set up dev ovsbr0").success());
@@ -1658,8 +1660,10 @@ fn _test_virtio_fs(
                     "{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
                 )));
             } else {
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}"));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")
+                );
             }
 
             thread::sleep(std::time::Duration::new(10, 0));
@@ -1739,8 +1743,10 @@ fn _test_virtio_fs(
                     "{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
                 )));
             } else {
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}"));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")
+                );
             }
 
             thread::sleep(std::time::Duration::new(10, 0));
@@ -1894,8 +1900,10 @@ fn _test_virtio_vsock(hotplug: bool) {
                 Some(format!("cid=3,socket={socket},id=test0").as_str()),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
+            );
             thread::sleep(std::time::Duration::new(10, 0));
             // Check adding a second one fails
             assert!(!remote_command(
@@ -2112,7 +2120,8 @@ fn get_counters(api_socket: &str) -> Counters {
 
 fn pty_read(mut pty: std::fs::File) -> Receiver<String> {
     let (tx, rx) = mpsc::channel::<String>();
-    thread::spawn(move || loop {
+    thread::spawn(move || {
+        loop {
             thread::sleep(std::time::Duration::new(1, 0));
             let mut buf = [0; 512];
             match pty.read(&mut buf) {
@@ -2125,6 +2134,7 @@ fn pty_read(mut pty: std::fs::File) -> Receiver<String> {
                 }
                 Err(_) => break,
             }
+        }
     });
     rx
 }
@@ -2257,9 +2267,11 @@ fn _test_virtio_iommu(acpi: bool) {
         guest.wait_vm_boot(None).unwrap();
 
         // Verify the virtio-iommu device is present.
-        assert!(guest
+        assert!(
+            guest
                 .does_device_vendor_pair_match("0x1057", "0x1af4")
-            .unwrap_or_default());
+                .unwrap_or_default()
+        );
 
         // On AArch64, if the guest system boots from FDT, the behavior of IOMMU is a bit
         // different with ACPI.
@@ -2319,9 +2331,11 @@ fn get_reboot_count(guest: &Guest) -> u32 {
 
 fn enable_guest_watchdog(guest: &Guest, watchdog_sec: u32) {
     // Check for PCI device
-    assert!(guest
+    assert!(
+        guest
             .does_device_vendor_pair_match("0x1063", "0x1af4")
-        .unwrap_or_default());
+            .unwrap_or_default()
+    );
 
     // Enable systemd watchdog
     guest
@@ -2335,9 +2349,11 @@ fn enable_guest_watchdog(guest: &Guest, watchdog_sec: u32) {
 
 fn make_guest_panic(guest: &Guest) {
     // Check for pvpanic device
-    assert!(guest
+    assert!(
+        guest
             .does_device_vendor_pair_match("0x0011", "0x1b36")
-        .unwrap_or_default());
+            .unwrap_or_default()
+    );
 
     // Trigger guest a panic
     guest.ssh_command("screen -dmS reboot sh -c \"sleep 5; echo s | tee /proc/sysrq-trigger; echo c | sudo tee /proc/sysrq-trigger\"").unwrap();
@@ -2974,13 +2990,17 @@ mod common_parallel {
                 ),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"test0\",\"bdf\":\"0001:00:01.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"test0\",\"bdf\":\"0001:00:01.0\"}")
+            );
 
             // Check IOMMU setup
-            assert!(guest
+            assert!(
+                guest
                     .does_device_vendor_pair_match("0x1057", "0x1af4")
-                .unwrap_or_default());
+                    .unwrap_or_default()
+            );
             assert_eq!(
                 guest
                     .ssh_command("ls /sys/kernel/iommu_groups/0/devices")
@@ -4429,9 +4449,11 @@ mod common_parallel {
         let r = std::panic::catch_unwind(|| {
             guest.wait_vm_boot(None).unwrap();
 
-            assert!(guest
+            assert!(
+                guest
                     .does_device_vendor_pair_match("0x1043", "0x1af4")
-                .unwrap_or_default());
+                    .unwrap_or_default()
+            );
 
             guest.ssh_command(&cmd).unwrap();
         });
@@ -5407,8 +5429,10 @@ mod common_parallel {
                 ),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
+            );
 
             thread::sleep(std::time::Duration::new(10, 0));
 
@@ -5454,8 +5478,10 @@ mod common_parallel {
                 ),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
+            );
 
             thread::sleep(std::time::Duration::new(10, 0));
 
@@ -5953,8 +5979,10 @@ mod common_parallel {
                     "{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
                 )));
             } else {
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}"));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
+                );
             }
 
             // Check that /dev/pmem0 exists and the block size is 128M
@@ -6084,8 +6112,10 @@ mod common_parallel {
                     "{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
                 )));
             } else {
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:05.0\"}"));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains("{\"id\":\"test0\",\"bdf\":\"0000:00:05.0\"}")
+                );
             }
 
             thread::sleep(std::time::Duration::new(5, 0));
@@ -6128,8 +6158,10 @@ mod common_parallel {
                     "{{\"id\":\"test1\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
                 )));
             } else {
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains("{\"id\":\"test1\",\"bdf\":\"0000:00:05.0\"}"));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains("{\"id\":\"test1\",\"bdf\":\"0000:00:05.0\"}")
+                );
             }
 
             thread::sleep(std::time::Duration::new(5, 0));
@@ -6566,15 +6598,19 @@ mod common_parallel {
         let phy_net = "eth0";
 
         // Create a macvtap interface for the guest VM to use
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "sudo ip link add link {phy_net} name {guest_macvtap_name} type macvtap mod bridge"
             ))
-        .success());
-        assert!(exec_host_command_status(&format!(
+            .success()
+        );
+        assert!(
+            exec_host_command_status(&format!(
                 "sudo ip link set {} address {} up",
                 guest_macvtap_name, guest.network.guest_mac
             ))
-        .success());
+            .success()
+        );
         assert!(
             exec_host_command_status(&format!("sudo ip link show {guest_macvtap_name}")).success()
         );
@@ -6593,16 +6629,20 @@ mod common_parallel {
 
         // Create a macvtap on the same physical net interface for
         // the host machine to use
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "sudo ip link add link {phy_net} name {host_macvtap_name} type macvtap mod bridge"
             ))
-        .success());
+            .success()
+        );
         // Use default mask "255.255.255.0"
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "sudo ip address add {}/24 dev {}",
                 guest.network.host_ip, host_macvtap_name
             ))
-        .success());
+            .success()
+        );
         assert!(
             exec_host_command_status(&format!("sudo ip link set dev {host_macvtap_name} up"))
                 .success()
@@ -6638,11 +6678,15 @@ mod common_parallel {
                 remote_command_w_output(&api_socket, "add-net", Some(&net_params));
             assert!(cmd_success);
             #[cfg(target_arch = "x86_64")]
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"_net2\",\"bdf\":\"0000:00:05.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"_net2\",\"bdf\":\"0000:00:05.0\"}")
+            );
             #[cfg(target_arch = "aarch64")]
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"_net0\",\"bdf\":\"0000:00:05.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"_net0\",\"bdf\":\"0000:00:05.0\"}")
+            );
         }
 
         // The functional connectivity provided by the virtio-net device
@@ -6818,21 +6862,27 @@ mod common_parallel {
     fn setup_spdk_nvme(nvme_dir: &std::path::Path) -> Child {
         cleanup_spdk_nvme();
 
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "mkdir -p {}",
                 nvme_dir.join("nvme-vfio-user").to_str().unwrap()
             ))
-        .success());
-        assert!(exec_host_command_status(&format!(
+            .success()
+        );
+        assert!(
+            exec_host_command_status(&format!(
                 "truncate {} -s 128M",
                 nvme_dir.join("test-disk.raw").to_str().unwrap()
             ))
-        .success());
-        assert!(exec_host_command_status(&format!(
+            .success()
+        );
+        assert!(
+            exec_host_command_status(&format!(
                 "mkfs.ext4 {}",
                 nvme_dir.join("test-disk.raw").to_str().unwrap()
             ))
-        .success());
+            .success()
+        );
 
         // Start the SPDK nvmf_tgt daemon to present NVMe device as a VFIO user device
         let child = Command::new("/usr/local/bin/spdk-nvme/nvmf_tgt")
@@ -6846,11 +6896,13 @@ mod common_parallel {
             3,
             std::time::Duration::new(5, 0),
         ));
-        assert!(exec_host_command_status(&format!(
+        assert!(
+            exec_host_command_status(&format!(
                 "/usr/local/bin/spdk-nvme/rpc.py bdev_aio_create {} test 512",
                 nvme_dir.join("test-disk.raw").to_str().unwrap()
             ))
-        .success());
+            .success()
+        );
         assert!(exec_host_command_status(
                 "/usr/local/bin/spdk-nvme/rpc.py nvmf_create_subsystem nqn.2019-07.io.spdk:cnode -a -s test"
             )
@@ -6911,8 +6963,10 @@ mod common_parallel {
                 )),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"vfio_user0\",\"bdf\":\"0000:00:05.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"vfio_user0\",\"bdf\":\"0000:00:05.0\"}")
+            );
 
             thread::sleep(std::time::Duration::new(10, 0));
 
@@ -7017,15 +7071,19 @@ mod common_parallel {
                 Some("id=myvdpa0,path=/dev/vhost-vdpa-1,num_queues=1,pci_segment=1,iommu=on"),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"myvdpa0\",\"bdf\":\"0001:00:01.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"myvdpa0\",\"bdf\":\"0001:00:01.0\"}")
+            );
 
             thread::sleep(std::time::Duration::new(10, 0));
 
             // Check IOMMU setup
-            assert!(guest
+            assert!(
+                guest
                     .does_device_vendor_pair_match("0x1057", "0x1af4")
-                .unwrap_or_default());
+                    .unwrap_or_default()
+            );
             assert_eq!(
                 guest
                     .ssh_command("ls /sys/kernel/iommu_groups/0/devices")
@@ -7419,7 +7477,7 @@ mod ivshmem {
     use std::fs::remove_dir_all;
     use std::process::Command;
 
-    use test_infra::{handle_child_output, kill_child, Guest, GuestCommand, UbuntuDiskConfig};
+    use test_infra::{Guest, GuestCommand, UbuntuDiskConfig, handle_child_output, kill_child};
 
     use crate::*;
 
@@ -9404,8 +9462,10 @@ mod windows {
                     Some(format!("path={disk},readonly=off").as_str()),
                 );
                 assert!(cmd_success);
-                assert!(String::from_utf8_lossy(&cmd_output)
-                    .contains(format!("\"id\":\"{disk_id}\"").as_str()));
+                assert!(
+                    String::from_utf8_lossy(&cmd_output)
+                        .contains(format!("\"id\":\"{disk_id}\"").as_str())
+                );
                 thread::sleep(std::time::Duration::new(5, 0));
                 // Online disk devices
                 windows_guest.disks_set_rw();
@@ -9615,8 +9675,10 @@ mod vfio {
                 Some(format!("id=vfio0,path={NVIDIA_VFIO_DEVICE}").as_str()),
             );
             assert!(cmd_success);
-            assert!(String::from_utf8_lossy(&cmd_output)
-                .contains("{\"id\":\"vfio0\",\"bdf\":\"0000:00:06.0\"}"));
+            assert!(
+                String::from_utf8_lossy(&cmd_output)
+                    .contains("{\"id\":\"vfio0\",\"bdf\":\"0000:00:06.0\"}")
+            );
 
             thread::sleep(std::time::Duration::new(10, 0));
 
@@ -9694,10 +9756,12 @@ mod vfio {
         let r = std::panic::catch_unwind(|| {
             guest.wait_vm_boot(None).unwrap();
 
-            assert!(guest
+            assert!(
+                guest
                     .ssh_command("sudo dmesg")
                     .unwrap()
-                .contains("input address: 42 bits"));
+                    .contains("input address: 42 bits")
+            );
         });
 
         let _ = child.kill();
@@ -11382,11 +11446,13 @@ mod rate_limiter {
             String::from(test_img_dir.as_path().join("blk.img").to_str().unwrap());
 
         // Create the test block image
-        assert!(exec_host_command_output(&format!(
+        assert!(
+            exec_host_command_output(&format!(
                 "dd if=/dev/zero of={blk_rate_limiter_test_img} bs=1M count=1024"
             ))
             .status
-        .success());
+            .success()
+        );
 
         let test_blk_params = if bandwidth {
             format!(
@@ -11491,11 +11557,13 @@ mod rate_limiter {
                     .unwrap(),
             );
 
-            assert!(exec_host_command_output(&format!(
+            assert!(
+                exec_host_command_output(&format!(
                     "dd if=/dev/zero of={test_img_path} bs=1M count=1024"
                 ))
                 .status
-            .success());
+                .success()
+            );
 
             disk_args.push(format!(
                 "path={test_img_path},num_queues={num_queues},rate_limit_group=group0"

vhost_user_block/src/lib.rs

@@ -19,13 +19,13 @@ use std::time::Instant;
 use std::{convert, io, process, result};
 
 use block::qcow::{self, ImageType, QcowFile};
-use block::{build_serial, Request, VirtioBlockConfig};
+use block::{Request, VirtioBlockConfig, build_serial};
 use libc::EFD_NONBLOCK;
 use log::*;
 use option_parser::{OptionParser, OptionParserError, Toggle};
 use thiserror::Error;
-use vhost::vhost_user::message::*;
 use vhost::vhost_user::Listener;
+use vhost::vhost_user::message::*;
 use vhost_user_backend::bitmap::BitmapMmapRegion;
 use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringState, VringT};
 use virtio_bindings::virtio_blk::*;

vhost_user_net/src/lib.rs

@@ -15,12 +15,12 @@ use std::{io, process};
 use libc::EFD_NONBLOCK;
 use log::*;
 use net_util::{
-    open_tap, MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TxVirtio,
+    MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TxVirtio, open_tap,
 };
 use option_parser::{OptionParser, OptionParserError, Toggle};
 use thiserror::Error;
-use vhost::vhost_user::message::*;
 use vhost::vhost_user::Listener;
+use vhost::vhost_user::message::*;
 use vhost_user_backend::bitmap::BitmapMmapRegion;
 use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringT};
 use virtio_bindings::virtio_config::{VIRTIO_F_NOTIFY_ON_EMPTY, VIRTIO_F_VERSION_1};

virtio-devices/src/balloon.rs

@@ -37,9 +37,9 @@ use vmm_sys_util::eventfd::EventFd;
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::{
-    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap,
-    VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioInterruptType,
-    EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
+    ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
+    GuestMemoryMmap, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
+    VirtioInterrupt, VirtioInterruptType,
 };
 
 const QUEUE_SIZE: u16 = 128;

virtio-devices/src/block.rs

@@ -19,12 +19,12 @@ use std::{io, result};
 
 use anyhow::anyhow;
 use block::async_io::{AsyncIo, AsyncIoError, DiskFile};
-use block::fcntl::{get_lock_state, LockError, LockType};
+use block::fcntl::{LockError, LockType, get_lock_state};
 use block::{
-    build_serial, fcntl, ExecuteAsync, ExecuteError, Request, RequestType, VirtioBlockConfig,
+    ExecuteAsync, ExecuteError, Request, RequestType, VirtioBlockConfig, build_serial, fcntl,
 };
-use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
 use rate_limiter::TokenType;
+use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
 use seccompiler::SeccompAction;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
@@ -38,9 +38,9 @@ use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterruptType,
-    EPOLL_HELPER_EVENT_LAST,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType,
+    VirtioInterruptType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/console.rs

@@ -22,9 +22,9 @@ use vm_virtio::{AccessPlatform, Translatable};
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError,
-    VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
+    ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
+    Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
+    VirtioDeviceType, VirtioInterruptType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/iommu.rs

@@ -24,8 +24,8 @@ use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError,
-    VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
+    ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
+    Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/lib.rs

@@ -51,10 +51,10 @@ pub use self::device::{
     VirtioSharedMemoryList,
 };
 pub use self::epoll_helper::{
-    EpollHelper, EpollHelperError, EpollHelperHandler, EPOLL_HELPER_EVENT_LAST,
+    EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
 };
 pub use self::iommu::{AccessPlatformMapping, Iommu, IommuMapping};
-pub use self::mem::{BlocksState, Mem, VirtioMemMappingSource, VIRTIO_MEM_ALIGN_SIZE};
+pub use self::mem::{BlocksState, Mem, VIRTIO_MEM_ALIGN_SIZE, VirtioMemMappingSource};
 pub use self::net::{Net, NetCtrlEpollHandler};
 pub use self::pmem::Pmem;
 pub use self::rng::Rng;

virtio-devices/src/mem.rs

@@ -18,7 +18,7 @@ use std::collections::BTreeMap;
 use std::mem::size_of;
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::sync::atomic::AtomicBool;
-use std::sync::{mpsc, Arc, Barrier, Mutex};
+use std::sync::{Arc, Barrier, Mutex, mpsc};
 use std::{io, result};
 
 use anyhow::anyhow;
@@ -36,9 +36,9 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_VERSION_1,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
+    VirtioDeviceType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/net.rs

@@ -18,8 +18,8 @@ use anyhow::anyhow;
 #[cfg(not(fuzzing))]
 use net_util::virtio_features_to_tap_offload;
 use net_util::{
-    build_net_config_space, build_net_config_space_with_mq, open_tap, CtrlQueue, MacAddr,
-    NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio, VirtioNetConfig,
+    CtrlQueue, MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio,
+    VirtioNetConfig, build_net_config_space, build_net_config_space_with_mq, open_tap,
 };
 use seccompiler::SeccompAction;
 use serde::{Deserialize, Serialize};
@@ -34,9 +34,9 @@ use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, RateLimiterConfig, VirtioCommon, VirtioDevice, VirtioDeviceType,
-    VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, RateLimiterConfig, VirtioCommon, VirtioDevice,
+    VirtioDeviceType, VirtioInterruptType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/pmem.rs

@@ -28,9 +28,9 @@ use vm_virtio::{AccessPlatform, Translatable};
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
+    VirtioCommon, VirtioDevice, VirtioDeviceType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/rng.rs

@@ -21,9 +21,9 @@ use vm_virtio::{AccessPlatform, Translatable};
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
+    VirtioCommon, VirtioDevice, VirtioDeviceType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

virtio-devices/src/seccomp_filters.rs

@@ -53,13 +53,15 @@ const VFIO_IOMMU_UNMAP_DMA: u64 = 0x3b72;
 
 #[cfg(feature = "sev_snp")]
 fn mshv_sev_snp_ioctl_seccomp_rule() -> SeccompRule {
-    and![Cond::new(
+    and![
+        Cond::new(
             1,
             ArgLen::Dword,
             Eq,
             mshv_ioctls::MSHV_MODIFY_GPA_HOST_ACCESS()
         )
-    .unwrap()]
+        .unwrap()
+    ]
 }
 
 #[cfg(feature = "sev_snp")]

virtio-devices/src/thread_helper.rs

@@ -6,12 +6,12 @@
 use std::panic::AssertUnwindSafe;
 use std::thread::{self, JoinHandle};
 
-use seccompiler::{apply_filter, SeccompAction};
+use seccompiler::{SeccompAction, apply_filter};
 use vmm_sys_util::eventfd::EventFd;
 
-use crate::epoll_helper::EpollHelperError;
-use crate::seccomp_filters::{get_seccomp_filter, Thread};
 use crate::ActivateError;
+use crate::epoll_helper::EpollHelperError;
+use crate::seccomp_filters::{Thread, get_seccomp_filter};
 
 pub(crate) fn spawn_virtio_thread<F>(
     name: &str,

virtio-devices/src/transport/mod.rs

@@ -5,7 +5,7 @@
 use vmm_sys_util::eventfd::EventFd;
 mod pci_common_config;
 mod pci_device;
-pub use pci_common_config::{VirtioPciCommonConfig, VIRTIO_PCI_COMMON_CONFIG_ID};
+pub use pci_common_config::{VIRTIO_PCI_COMMON_CONFIG_ID, VirtioPciCommonConfig};
 pub use pci_device::{VirtioPciDevice, VirtioPciDeviceActivator, VirtioPciDeviceError};
 
 pub trait VirtioTransport {

virtio-devices/src/transport/pci_device.rs

@@ -35,11 +35,11 @@ use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
 use super::pci_common_config::VirtioPciCommonConfigState;
-use crate::transport::{VirtioPciCommonConfig, VirtioTransport, VIRTIO_PCI_COMMON_CONFIG_ID};
+use crate::transport::{VIRTIO_PCI_COMMON_CONFIG_ID, VirtioPciCommonConfig, VirtioTransport};
 use crate::{
-    ActivateResult, GuestMemoryMmap, VirtioDevice, VirtioDeviceType, VirtioInterrupt,
-    VirtioInterruptType, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED,
-    DEVICE_FEATURES_OK, DEVICE_INIT,
+    ActivateResult, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED,
+    DEVICE_FEATURES_OK, DEVICE_INIT, GuestMemoryMmap, VirtioDevice, VirtioDeviceType,
+    VirtioInterrupt, VirtioInterruptType,
 };
 
 /// Vector value used to disable MSI for a queue.
@@ -973,7 +973,7 @@ impl PciDevice for VirtioPciDevice {
                         settings_bar_addr = Some(GuestAddress(base));
                         use_64bit_bar = match type_ {
                             PciBarType::Io => {
-                                return Err(PciDeviceError::InvalidResource(resource))
+                                return Err(PciDeviceError::InvalidResource(resource));
                             }
                             PciBarType::Mmio32 => false,
                             PciBarType::Mmio64 => true,

virtio-devices/src/vdpa.rs

@@ -12,9 +12,9 @@ use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use vhost::vdpa::{VhostVdpa, VhostVdpaIovaRange};
+use vhost::vhost_kern::VhostKernFeatures;
 use vhost::vhost_kern::vdpa::VhostKernVdpa;
 use vhost::vhost_kern::vhost_binding::VHOST_BACKEND_F_SUSPEND;
-use vhost::vhost_kern::VhostKernFeatures;
 use vhost::{VhostBackend, VringConfigData};
 use virtio_queue::desc::RawDescriptor;
 use virtio_queue::{Queue, QueueT};
@@ -25,9 +25,9 @@ use vm_virtio::{AccessPlatform, Translatable};
 use vmm_sys_util::eventfd::EventFd;
 
 use crate::{
-    ActivateError, ActivateResult, GuestMemoryMmap, VirtioCommon, VirtioDevice, VirtioInterrupt,
-    VirtioInterruptType, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FEATURES_OK,
-    VIRTIO_F_IOMMU_PLATFORM,
+    ActivateError, ActivateResult, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK,
+    DEVICE_FEATURES_OK, GuestMemoryMmap, VIRTIO_F_IOMMU_PLATFORM, VirtioCommon, VirtioDevice,
+    VirtioInterrupt, VirtioInterruptType,
 };
 
 #[derive(Error, Debug)]

virtio-devices/src/vhost_user/blk.rs

@@ -9,8 +9,8 @@ use block::VirtioBlockConfig;
 use seccompiler::SeccompAction;
 use serde::{Deserialize, Serialize};
 use vhost::vhost_user::message::{
-    VhostUserConfigFlags, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
-    VHOST_USER_CONFIG_OFFSET,
+    VHOST_USER_CONFIG_OFFSET, VhostUserConfigFlags, VhostUserProtocolFeatures,
+    VhostUserVirtioFeatures,
 };
 use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
 use virtio_bindings::virtio_blk::{
@@ -26,11 +26,11 @@ use vmm_sys_util::eventfd::EventFd;
 
 use super::super::{ActivateResult, VirtioCommon, VirtioDevice, VirtioDeviceType};
 use super::vu_common_ctrl::{VhostUserConfig, VhostUserHandle};
-use super::{Error, Result, DEFAULT_VIRTIO_FEATURES};
+use super::{DEFAULT_VIRTIO_FEATURES, Error, Result};
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::vhost_user::VhostUserCommon;
-use crate::{GuestMemoryMmap, GuestRegionMmap, VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM};
+use crate::{GuestMemoryMmap, GuestRegionMmap, VIRTIO_F_IOMMU_PLATFORM, VirtioInterrupt};
 
 const DEFAULT_QUEUE_NUMBER: usize = 1;
 
@@ -134,8 +134,10 @@ impl Blk {
                 };
 
             if num_queues > backend_num_queues {
-                error!("vhost-user-blk requested too many queues ({}) since the backend only supports {}\n",
-                num_queues, backend_num_queues);
+                error!(
+                    "vhost-user-blk requested too many queues ({}) since the backend only supports {}\n",
+                    num_queues, backend_num_queues
+                );
                 return Err(Error::BadQueueNum);
             }
 

virtio-devices/src/vhost_user/fs.rs

@@ -7,7 +7,7 @@ use std::{result, thread};
 
 use seccompiler::SeccompAction;
 use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, Bytes};
+use serde_with::{Bytes, serde_as};
 use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
 use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
 use virtio_queue::Queue;
@@ -18,13 +18,13 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 use vmm_sys_util::eventfd::EventFd;
 
 use super::vu_common_ctrl::VhostUserHandle;
-use super::{Error, Result, DEFAULT_VIRTIO_FEATURES};
+use super::{DEFAULT_VIRTIO_FEATURES, Error, Result};
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::vhost_user::VhostUserCommon;
 use crate::{
-    ActivateResult, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioCommon, VirtioDevice,
-    VirtioDeviceType, VirtioInterrupt, VirtioSharedMemoryList, VIRTIO_F_IOMMU_PLATFORM,
+    ActivateResult, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VIRTIO_F_IOMMU_PLATFORM,
+    VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioSharedMemoryList,
 };
 
 const NUM_QUEUE_OFFSET: usize = 1;

virtio-devices/src/vhost_user/mod.rs

@@ -10,11 +10,11 @@ use std::sync::{Arc, Barrier, Mutex};
 use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use vhost::Error as VhostError;
 use vhost::vhost_user::message::{
     VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
 };
 use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontendReqHandler};
-use vhost::Error as VhostError;
 use virtio_queue::{Error as QueueError, Queue};
 use vm_memory::mmap::MmapRegionError;
 use vm_memory::{Address, Error as MmapError, GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
@@ -24,10 +24,10 @@ use vmm_sys_util::eventfd::EventFd;
 use vu_common_ctrl::VhostUserHandle;
 
 use crate::{
-    ActivateError, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap,
-    GuestRegionMmap, VirtioInterrupt, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER,
-    VIRTIO_F_NOTIFICATION_DATA, VIRTIO_F_ORDER_PLATFORM, VIRTIO_F_RING_EVENT_IDX,
-    VIRTIO_F_RING_INDIRECT_DESC, VIRTIO_F_VERSION_1,
+    ActivateError, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
+    GuestMemoryMmap, GuestRegionMmap, VIRTIO_F_IN_ORDER, VIRTIO_F_NOTIFICATION_DATA,
+    VIRTIO_F_ORDER_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_RING_INDIRECT_DESC,
+    VIRTIO_F_VERSION_1, VirtioInterrupt,
 };
 
 pub mod blk;

virtio-devices/src/vhost_user/net.rs

@@ -5,7 +5,7 @@ use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Barrier, Mutex};
 use std::{result, thread};
 
-use net_util::{build_net_config_space, CtrlQueue, MacAddr, VirtioNetConfig};
+use net_util::{CtrlQueue, MacAddr, VirtioNetConfig, build_net_config_space};
 use seccompiler::SeccompAction;
 use serde::{Deserialize, Serialize};
 use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
@@ -28,9 +28,9 @@ use crate::thread_helper::spawn_virtio_thread;
 use crate::vhost_user::vu_common_ctrl::{VhostUserConfig, VhostUserHandle};
 use crate::vhost_user::{Error, Result, VhostUserCommon};
 use crate::{
-    ActivateResult, GuestMemoryMmap, GuestRegionMmap, NetCtrlEpollHandler, VirtioCommon,
-    VirtioDevice, VirtioDeviceType, VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM,
-    VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1,
+    ActivateResult, GuestMemoryMmap, GuestRegionMmap, NetCtrlEpollHandler, VIRTIO_F_IOMMU_PLATFORM,
+    VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
+    VirtioInterrupt,
 };
 
 const DEFAULT_QUEUE_NUMBER: usize = 2;
@@ -168,8 +168,10 @@ impl Net {
                 };
 
             if num_queues > backend_num_queues {
-                error!("vhost-user-net requested too many queues ({}) since the backend only supports {}\n",
-                num_queues, backend_num_queues);
+                error!(
+                    "vhost-user-net requested too many queues ({}) since the backend only supports {}\n",
+                    num_queues, backend_num_queues
+                );
                 return Err(Error::BadQueueNum);
             }
 

virtio-devices/src/vhost_user/vu_common_ctrl.rs

@@ -5,8 +5,8 @@ use std::ffi;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::os::unix::net::UnixListener;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
@@ -29,8 +29,8 @@ use vmm_sys_util::eventfd::EventFd;
 use super::{Error, Result};
 use crate::vhost_user::Inflight;
 use crate::{
-    get_host_address_range, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioInterrupt,
-    VirtioInterruptType,
+    GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioInterrupt, VirtioInterruptType,
+    get_host_address_range,
 };
 
 // Size of a dirty page for vhost-user.
@@ -399,7 +399,7 @@ impl VhostUserHandle {
                             acked_features: 0,
                             vrings_info: None,
                             queue_indexes: Vec::new(),
-                        })
+                        });
                     }
                     Err(e) => e,
                 };

virtio-devices/src/vsock/csm/connection.rs

@@ -89,7 +89,7 @@ use super::super::defs::uapi;
 use super::super::packet::VsockPacket;
 use super::super::{Result as VsockResult, VsockChannel, VsockEpollListener, VsockError};
 use super::txbuf::TxBuf;
-use super::{defs, ConnState, Error, PendingRx, PendingRxSet, Result};
+use super::{ConnState, Error, PendingRx, PendingRxSet, Result, defs};
 
 /// A self-managing connection object, that handles communication between a guest-side AF_VSOCK
 /// socket and a host-side `Read + Write + AsRawFd` stream.
@@ -1158,10 +1158,11 @@ mod tests {
 
             // When there's data in the TX buffer, the connection should ask to be notified when it
             // can write to its backing stream.
-            assert!(ctx
-                .conn
+            assert!(
+                ctx.conn
                     .get_polled_evset()
-                .contains(epoll::Events::EPOLLOUT));
+                    .contains(epoll::Events::EPOLLOUT)
+            );
             assert_eq!(ctx.conn.tx_buf.len(), data.len());
 
             // Unlock the write stream and notify the connection it can now write its buffered
@@ -1212,10 +1213,11 @@ mod tests {
             stream.write_state = StreamState::Closed;
             ctx.set_stream(stream);
 
-            assert!(ctx
-                .conn
+            assert!(
+                ctx.conn
                     .get_polled_evset()
-                .contains(epoll::Events::EPOLLOUT));
+                    .contains(epoll::Events::EPOLLOUT)
+            );
             ctx.notify_epollout();
             assert_eq!(ctx.conn.state, ConnState::Killed);
         }

virtio-devices/src/vsock/csm/txbuf.rs

@@ -5,7 +5,7 @@
 use std::io::Write;
 use std::num::Wrapping;
 
-use super::{defs, Error, Result};
+use super::{Error, Result, defs};
 
 /// A simple ring-buffer implementation, used by vsock connections to buffer TX (guest -> host)
 /// data.  Memory for this buffer is allocated lazily, since buffering will only be needed when

virtio-devices/src/vsock/device.rs

@@ -47,10 +47,10 @@ use super::{VsockBackend, VsockPacket};
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::{
-    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError,
-    GuestMemoryMmap, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt,
-    VirtioInterruptType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER, VIRTIO_F_IOMMU_PLATFORM,
-    VIRTIO_F_VERSION_1,
+    ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
+    Error as DeviceError, GuestMemoryMmap, VIRTIO_F_IN_ORDER, VIRTIO_F_IOMMU_PLATFORM,
+    VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt,
+    VirtioInterruptType,
 };
 
 const QUEUE_SIZE: u16 = 256;

virtio-devices/src/vsock/mod.rs

@@ -172,7 +172,7 @@ pub mod tests {
     use vm_virtio::queue::testing::VirtQueue as GuestQ;
     use vmm_sys_util::eventfd::EventFd;
 
-    use super::device::{VsockEpollHandler, RX_QUEUE_EVENT, TX_QUEUE_EVENT};
+    use super::device::{RX_QUEUE_EVENT, TX_QUEUE_EVENT, VsockEpollHandler};
     use super::packet::VSOCK_PKT_HDR_SIZE;
     use super::*;
     use crate::device::{VirtioInterrupt, VirtioInterruptType};

virtio-devices/src/vsock/packet.rs

@@ -24,7 +24,7 @@ use virtio_queue::DescriptorChain;
 use vm_memory::{Address, GuestMemory};
 use vm_virtio::{AccessPlatform, Translatable};
 
-use super::{defs, Result, VsockError};
+use super::{Result, VsockError, defs};
 use crate::get_host_address_range;
 
 // The vsock packet header is defined by the C struct:
@@ -427,8 +427,8 @@ mod tests {
 
     use super::super::tests::TestContext;
     use super::*;
-    use crate::vsock::defs::MAX_PKT_BUF_SIZE;
     use crate::GuestMemoryMmap;
+    use crate::vsock::defs::MAX_PKT_BUF_SIZE;
 
     macro_rules! create_context {
         ($test_ctx:ident, $handler_ctx:ident) => {

virtio-devices/src/vsock/unix/mod.rs

@@ -13,9 +13,9 @@ mod muxer;
 mod muxer_killq;
 mod muxer_rxq;
 
+pub use Error as VsockUnixError;
 pub use muxer::VsockMuxer as VsockUnixBackend;
 use thiserror::Error;
-pub use Error as VsockUnixError;
 
 mod defs {
     /// Maximum number of established connections that we can handle.

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

@@ -52,7 +52,7 @@ use super::super::{
 };
 use super::muxer_killq::MuxerKillQ;
 use super::muxer_rxq::MuxerRxQ;
-use super::{defs, Error, MuxerConnection, Result};
+use super::{Error, MuxerConnection, Result, defs};
 
 /// A unique identifier of a `MuxerConnection` object. Connections are stored in a hash map,
 /// keyed by a `ConnMapKey` object.

virtio-devices/src/vsock/unix/muxer_killq.rs

@@ -29,7 +29,7 @@ use std::collections::{HashMap, VecDeque};
 use std::time::Instant;
 
 use super::muxer::ConnMapKey;
-use super::{defs, MuxerConnection};
+use super::{MuxerConnection, defs};
 
 /// A kill queue item, holding the connection key and the scheduled time for termination.
 ///

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

@@ -20,7 +20,7 @@ use std::collections::{HashMap, VecDeque};
 
 use super::super::VsockChannel;
 use super::muxer::{ConnMapKey, MuxerRx};
-use super::{defs, MuxerConnection};
+use super::{MuxerConnection, defs};
 
 /// The muxer RX queue.
 ///

virtio-devices/src/watchdog.rs

@@ -23,9 +23,9 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 use vmm_sys_util::eventfd::EventFd;
 
 use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
-    Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_VERSION_1,
+    ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
+    EpollHelperHandler, Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
+    VirtioDeviceType,
 };
 use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;

vm-allocator/src/page_size.rs

@@ -1,7 +1,7 @@
 // Copyright 2023 Arm Limited (or its affiliates). All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use libc::{sysconf, _SC_PAGESIZE};
+use libc::{_SC_PAGESIZE, sysconf};
 
 /// get host page size
 pub fn get_page_size() -> u64 {