misc: Adapt consistent import style formatting

Historically the Cloud Hypervisor coding style has been to ensure that
all imports are ordered and placed in a single group. Unfortunately
cargo fmt has no support for ensuring that all imports are in a single
group so if whitespace lines were added as part of the import statements
then they would only be odered correctly in the group.

By adopting "group_imports="StdExternalCrate" we can enforce a style
where imports are placed in at most three groups for std, external
crates and the crate itself. Choosing a style enforceable by the tooling
reduces the reviewer burden.

Signed-off-by: Rob Bradford <rbradford@rivosinc.com>

virtio-devices/src/balloon.rs

@@ -14,20 +14,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{
-    seccomp_filters::Thread, thread_helper::spawn_virtio_thread, ActivateResult, EpollHelper,
-    EpollHelperError, EpollHelperHandler, GuestMemoryMmap, VirtioCommon, VirtioDevice,
-    VirtioDeviceType, VirtioInterrupt, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
-    VIRTIO_F_VERSION_1,
-};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::io::{self, Write};
 use std::mem::size_of;
 use std::os::unix::io::AsRawFd;
 use std::result;
 use std::sync::{atomic::AtomicBool, Arc, Barrier};
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use virtio_queue::{Queue, QueueT};
 use vm_allocator::page_size::{align_page_size_down, get_page_size};
@@ -38,6 +33,13 @@ use vm_memory::{
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::{
+    seccomp_filters::Thread, thread_helper::spawn_virtio_thread, ActivateResult, EpollHelper,
+    EpollHelperError, EpollHelperHandler, GuestMemoryMmap, VirtioCommon, VirtioDevice,
+    VirtioDeviceType, VirtioInterrupt, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
+    VIRTIO_F_VERSION_1,
+};
+
 const QUEUE_SIZE: u16 = 128;
 const REPORTING_QUEUE_SIZE: u16 = 32;
 const MIN_NUM_QUEUES: usize = 2;

virtio-devices/src/block.rs

@@ -8,24 +8,6 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use super::Error as DeviceError;
-use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
-    VirtioDevice, VirtioDeviceType, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
-};
-use crate::seccomp_filters::Thread;
-use crate::thread_helper::spawn_virtio_thread;
-use crate::GuestMemoryMmap;
-use crate::VirtioInterrupt;
-use anyhow::anyhow;
-use block::{
-    async_io::AsyncIo, async_io::AsyncIoError, async_io::DiskFile, build_serial, Request,
-    RequestType, VirtioBlockConfig,
-};
-use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
-use rate_limiter::TokenType;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::VecDeque;
@@ -37,6 +19,16 @@ use std::path::PathBuf;
 use std::result;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Barrier};
+
+use anyhow::anyhow;
+use block::{
+    async_io::AsyncIo, async_io::AsyncIoError, async_io::DiskFile, build_serial, Request,
+    RequestType, VirtioBlockConfig,
+};
+use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
+use rate_limiter::TokenType;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use virtio_bindings::virtio_blk::*;
 use virtio_bindings::virtio_config::*;
@@ -47,6 +39,16 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
+use super::Error as DeviceError;
+use super::{
+    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
+    VirtioDevice, VirtioDeviceType, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST,
+};
+use crate::seccomp_filters::Thread;
+use crate::thread_helper::spawn_virtio_thread;
+use crate::GuestMemoryMmap;
+use crate::VirtioInterrupt;
+
 const SECTOR_SHIFT: u8 = 9;
 pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
 

virtio-devices/src/console.rs

@@ -1,6 +1,28 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::cmp;
+use std::collections::VecDeque;
+use std::fs::File;
+use std::io;
+use std::io::{Read, Write};
+use std::os::unix::io::AsRawFd;
+use std::result;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Barrier, Mutex};
+
+use anyhow::anyhow;
+use libc::{EFD_NONBLOCK, TIOCGWINSZ};
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use serial_buffer::SerialBuffer;
+use thiserror::Error;
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{ByteValued, Bytes, GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vm_virtio::{AccessPlatform, Translatable};
+use vmm_sys_util::eventfd::EventFd;
+
 use super::Error as DeviceError;
 use super::{
     ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon, VirtioDevice,
@@ -11,26 +33,6 @@ use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::GuestMemoryMmap;
 use crate::VirtioInterrupt;
-use anyhow::anyhow;
-use libc::{EFD_NONBLOCK, TIOCGWINSZ};
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use serial_buffer::SerialBuffer;
-use std::cmp;
-use std::collections::VecDeque;
-use std::fs::File;
-use std::io;
-use std::io::{Read, Write};
-use std::os::unix::io::AsRawFd;
-use std::result;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-use std::sync::{Arc, Barrier, Mutex};
-use thiserror::Error;
-use virtio_queue::{Queue, QueueT};
-use vm_memory::{ByteValued, Bytes, GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vm_virtio::{AccessPlatform, Translatable};
-use vmm_sys_util::eventfd::EventFd;
 
 const QUEUE_SIZE: u16 = 256;
 const NUM_QUEUES: usize = 2;

virtio-devices/src/device.rs

@@ -6,11 +6,6 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::{
-    ActivateError, ActivateResult, Error, GuestMemoryMmap, GuestRegionMmap,
-    VIRTIO_F_RING_INDIRECT_DESC,
-};
-use libc::EFD_NONBLOCK;
 use std::collections::HashMap;
 use std::io::Write;
 use std::num::Wrapping;
@@ -19,6 +14,8 @@ use std::sync::{
     Arc, Barrier,
 };
 use std::thread;
+
+use libc::EFD_NONBLOCK;
 use virtio_queue::Queue;
 use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestUsize};
 use vm_migration::{MigratableError, Pausable};
@@ -26,6 +23,11 @@ use vm_virtio::AccessPlatform;
 use vm_virtio::VirtioDeviceType;
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::{
+    ActivateError, ActivateResult, Error, GuestMemoryMmap, GuestRegionMmap,
+    VIRTIO_F_RING_INDIRECT_DESC,
+};
+
 pub enum VirtioInterruptType {
     Config,
     Queue(u16),

virtio-devices/src/epoll_helper.rs

@@ -13,6 +13,7 @@ use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Barrier};
 use std::thread;
+
 use thiserror::Error;
 use vmm_sys_util::eventfd::EventFd;
 

virtio-devices/src/iommu.rs

@@ -2,18 +2,6 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use super::Error as DeviceError;
-use super::{
-    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon, VirtioDevice,
-    VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
-};
-use crate::seccomp_filters::Thread;
-use crate::thread_helper::spawn_virtio_thread;
-use crate::GuestMemoryMmap;
-use crate::{DmaRemapping, VirtioInterrupt, VirtioInterruptType};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::io;
 use std::mem::size_of;
@@ -22,6 +10,10 @@ use std::os::unix::io::AsRawFd;
 use std::result;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Barrier, Mutex, RwLock};
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use virtio_queue::{DescriptorChain, Queue, QueueT};
 use vm_device::dma_mapping::ExternalDmaMapping;
@@ -33,6 +25,16 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 use vm_virtio::AccessPlatform;
 use vmm_sys_util::eventfd::EventFd;
 
+use super::Error as DeviceError;
+use super::{
+    ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon, VirtioDevice,
+    VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
+};
+use crate::seccomp_filters::Thread;
+use crate::thread_helper::spawn_virtio_thread;
+use crate::GuestMemoryMmap;
+use crate::{DmaRemapping, VirtioInterrupt, VirtioInterruptType};
+
 /// Queues sizes
 const QUEUE_SIZE: u16 = 256;
 const NUM_QUEUES: usize = 2;

virtio-devices/src/lib.rs

@@ -15,8 +15,9 @@ extern crate event_monitor;
 #[macro_use]
 extern crate log;
 
-use serde::{Deserialize, Serialize};
 use std::io;
+
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 #[macro_use]
@@ -38,6 +39,9 @@ pub mod vhost_user;
 pub mod vsock;
 pub mod watchdog;
 
+use vm_memory::{bitmap::AtomicBitmap, GuestAddress, GuestMemory};
+use vm_virtio::VirtioDeviceType;
+
 pub use self::balloon::Balloon;
 pub use self::block::{Block, BlockState};
 pub use self::console::{Console, ConsoleResizer, Endpoint};
@@ -56,8 +60,6 @@ pub use self::rng::Rng;
 pub use self::vdpa::{Vdpa, VdpaDmaMapping};
 pub use self::vsock::Vsock;
 pub use self::watchdog::Watchdog;
-use vm_memory::{bitmap::AtomicBitmap, GuestAddress, GuestMemory};
-use vm_virtio::VirtioDeviceType;
 
 type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
 type GuestRegionMmap = vm_memory::GuestRegionMmap<AtomicBitmap>;

virtio-devices/src/mem.rs

@@ -14,18 +14,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::Error as DeviceError;
-use super::{
-    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
-    VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
-};
-use crate::seccomp_filters::Thread;
-use crate::thread_helper::spawn_virtio_thread;
-use crate::{GuestMemoryMmap, GuestRegionMmap};
-use crate::{VirtioInterrupt, VirtioInterruptType};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::io;
 use std::mem::size_of;
@@ -34,6 +22,10 @@ use std::result;
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc;
 use std::sync::{Arc, Barrier, Mutex};
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use virtio_queue::{DescriptorChain, Queue, QueueT};
 use vm_device::dma_mapping::ExternalDmaMapping;
@@ -45,6 +37,16 @@ use vm_migration::protocol::MemoryRangeTable;
 use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
 use vmm_sys_util::eventfd::EventFd;
 
+use super::Error as DeviceError;
+use super::{
+    ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
+    VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1,
+};
+use crate::seccomp_filters::Thread;
+use crate::thread_helper::spawn_virtio_thread;
+use crate::{GuestMemoryMmap, GuestRegionMmap};
+use crate::{VirtioInterrupt, VirtioInterruptType};
+
 const QUEUE_SIZE: u16 = 128;
 const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE];
 

virtio-devices/src/net.rs

@@ -5,6 +5,36 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the THIRD-PARTY file.
 
+use std::collections::HashMap;
+use std::net::Ipv4Addr;
+use std::num::Wrapping;
+use std::ops::Deref;
+use std::os::unix::io::{AsRawFd, RawFd};
+use std::result;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Barrier};
+use std::thread;
+
+use anyhow::anyhow;
+#[cfg(not(fuzzing))]
+use net_util::virtio_features_to_tap_offload;
+use net_util::CtrlQueue;
+use net_util::{
+    build_net_config_space, build_net_config_space_with_mq, open_tap, MacAddr, NetCounters,
+    NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio, VirtioNetConfig,
+};
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use virtio_bindings::virtio_config::*;
+use virtio_bindings::virtio_net::*;
+use virtio_bindings::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{ByteValued, GuestAddressSpace, GuestMemoryAtomic};
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vm_virtio::AccessPlatform;
+use vmm_sys_util::eventfd::EventFd;
+
 use super::Error as DeviceError;
 use super::{
     ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
@@ -15,34 +45,6 @@ use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::GuestMemoryMmap;
 use crate::VirtioInterrupt;
-use anyhow::anyhow;
-#[cfg(not(fuzzing))]
-use net_util::virtio_features_to_tap_offload;
-use net_util::CtrlQueue;
-use net_util::{
-    build_net_config_space, build_net_config_space_with_mq, open_tap, MacAddr, NetCounters,
-    NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio, VirtioNetConfig,
-};
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::net::Ipv4Addr;
-use std::num::Wrapping;
-use std::ops::Deref;
-use std::os::unix::io::{AsRawFd, RawFd};
-use std::result;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Barrier};
-use std::thread;
-use thiserror::Error;
-use virtio_bindings::virtio_config::*;
-use virtio_bindings::virtio_net::*;
-use virtio_bindings::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
-use virtio_queue::{Queue, QueueT};
-use vm_memory::{ByteValued, GuestAddressSpace, GuestMemoryAtomic};
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vm_virtio::AccessPlatform;
-use vmm_sys_util::eventfd::EventFd;
 
 /// Control queue
 // Event available on the control queue.

virtio-devices/src/pmem.rs

@@ -6,6 +6,27 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use std::fs::File;
+use std::io;
+use std::mem::size_of;
+use std::os::unix::io::AsRawFd;
+use std::result;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Barrier};
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use virtio_queue::{DescriptorChain, Queue, QueueT};
+use vm_memory::{
+    Address, ByteValued, Bytes, GuestAddress, GuestAddressSpace, GuestMemoryAtomic,
+    GuestMemoryError, GuestMemoryLoadGuard,
+};
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vm_virtio::{AccessPlatform, Translatable};
+use vmm_sys_util::eventfd::EventFd;
+
 use super::Error as DeviceError;
 use super::{
     ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler,
@@ -16,25 +37,6 @@ use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::{GuestMemoryMmap, MmapRegion};
 use crate::{VirtioInterrupt, VirtioInterruptType};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io;
-use std::mem::size_of;
-use std::os::unix::io::AsRawFd;
-use std::result;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Barrier};
-use thiserror::Error;
-use virtio_queue::{DescriptorChain, Queue, QueueT};
-use vm_memory::{
-    Address, ByteValued, Bytes, GuestAddress, GuestAddressSpace, GuestMemoryAtomic,
-    GuestMemoryError, GuestMemoryLoadGuard,
-};
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vm_virtio::{AccessPlatform, Translatable};
-use vmm_sys_util::eventfd::EventFd;
 
 const QUEUE_SIZE: u16 = 256;
 const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE];

virtio-devices/src/rng.rs

@@ -4,6 +4,23 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use std::fs::File;
+use std::io;
+use std::os::unix::io::AsRawFd;
+use std::result;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Barrier};
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vm_virtio::{AccessPlatform, Translatable};
+use vmm_sys_util::eventfd::EventFd;
+
 use super::Error as DeviceError;
 use super::{
     ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
@@ -14,21 +31,6 @@ use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::GuestMemoryMmap;
 use crate::{VirtioInterrupt, VirtioInterruptType};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io;
-use std::os::unix::io::AsRawFd;
-use std::result;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Barrier};
-use thiserror::Error;
-use virtio_queue::{Queue, QueueT};
-use vm_memory::{GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vm_virtio::{AccessPlatform, Translatable};
-use vmm_sys_util::eventfd::EventFd;
 
 const QUEUE_SIZE: u16 = 256;
 const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE];

virtio-devices/src/thread_helper.rs

@@ -3,17 +3,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+use std::{
+    panic::AssertUnwindSafe,
+    thread::{self, JoinHandle},
+};
+
+use seccompiler::{apply_filter, SeccompAction};
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::{
     epoll_helper::EpollHelperError,
     seccomp_filters::{get_seccomp_filter, Thread},
     ActivateError,
 };
-use seccompiler::{apply_filter, SeccompAction};
-use std::{
-    panic::AssertUnwindSafe,
-    thread::{self, JoinHandle},
-};
-use vmm_sys_util::eventfd::EventFd;
 
 pub(crate) fn spawn_virtio_thread<F>(
     name: &str,

virtio-devices/src/transport/pci_common_config.rs

@@ -6,15 +6,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::VirtioDevice;
-use byteorder::{ByteOrder, LittleEndian};
-use serde::{Deserialize, Serialize};
 use std::sync::atomic::{AtomicU16, Ordering};
 use std::sync::{Arc, Mutex};
+
+use byteorder::{ByteOrder, LittleEndian};
+use serde::{Deserialize, Serialize};
 use virtio_queue::{Queue, QueueT};
 use vm_migration::{MigratableError, Pausable, Snapshot, Snapshottable};
 use vm_virtio::AccessPlatform;
 
+use crate::VirtioDevice;
+
 pub const VIRTIO_PCI_COMMON_CONFIG_ID: &str = "virtio_pci_common_config";
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -404,11 +406,12 @@ impl Snapshottable for VirtioPciCommonConfig {
 
 #[cfg(test)]
 mod tests {
+    use vm_memory::GuestMemoryAtomic;
+    use vmm_sys_util::eventfd::EventFd;
+
     use super::*;
     use crate::GuestMemoryMmap;
     use crate::{ActivateResult, VirtioInterrupt};
-    use vm_memory::GuestMemoryAtomic;
-    use vmm_sys_util::eventfd::EventFd;
 
     struct DummyDevice(u32);
     const QUEUE_SIZE: u16 = 256;

virtio-devices/src/transport/pci_device.rs

@@ -6,13 +6,13 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::transport::{VirtioPciCommonConfig, VirtioTransport, VIRTIO_PCI_COMMON_CONFIG_ID};
-use crate::GuestMemoryMmap;
-use crate::{
-    ActivateResult, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioInterruptType,
-    DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED, DEVICE_FEATURES_OK,
-    DEVICE_INIT,
-};
+use std::any::Any;
+use std::cmp;
+use std::io::Write;
+use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, AtomicU16, AtomicUsize, Ordering};
+use std::sync::{Arc, Barrier, Mutex};
+
 use anyhow::anyhow;
 use libc::EFD_NONBLOCK;
 use pci::{
@@ -21,12 +21,6 @@ use pci::{
     PciHeaderType, PciMassStorageSubclass, PciNetworkControllerSubclass, PciSubclass,
 };
 use serde::{Deserialize, Serialize};
-use std::any::Any;
-use std::cmp;
-use std::io::Write;
-use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, AtomicU16, AtomicUsize, Ordering};
-use std::sync::{Arc, Barrier, Mutex};
 use thiserror::Error;
 use virtio_queue::{Queue, QueueT};
 use vm_allocator::{AddressAllocator, SystemAllocator};
@@ -41,6 +35,13 @@ 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::GuestMemoryMmap;
+use crate::{
+    ActivateResult, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioInterruptType,
+    DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED, DEVICE_FEATURES_OK,
+    DEVICE_INIT,
+};
 
 /// Vector value used to disable MSI for a queue.
 const VIRTQ_MSI_NO_VECTOR: u16 = 0xffff;

virtio-devices/src/vdpa.rs

@@ -3,13 +3,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use crate::{
-    ActivateError, ActivateResult, GuestMemoryMmap, VirtioCommon, VirtioDevice, VirtioInterrupt,
-    VirtioInterruptType, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FEATURES_OK,
-    VIRTIO_F_IOMMU_PLATFORM,
-};
-use anyhow::anyhow;
-use serde::{Deserialize, Serialize};
 use std::{
     collections::BTreeMap,
     io, result,
@@ -18,6 +11,9 @@ use std::{
         Arc, Mutex,
     },
 };
+
+use anyhow::anyhow;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use vhost::{
     vdpa::{VhostVdpa, VhostVdpaIovaRange},
@@ -32,6 +28,12 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
 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,
+};
+
 #[derive(Error, Debug)]
 pub enum Error {
     #[error("Failed to create vhost-vdpa: {0}")]

virtio-devices/src/vhost_user/blk.rs

@@ -1,23 +1,15 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use super::super::{ActivateResult, VirtioCommon, VirtioDevice, VirtioDeviceType};
-use super::vu_common_ctrl::{VhostUserConfig, VhostUserHandle};
-use super::{Error, Result, DEFAULT_VIRTIO_FEATURES};
-use crate::seccomp_filters::Thread;
-use crate::thread_helper::spawn_virtio_thread;
-use crate::vhost_user::VhostUserCommon;
-use crate::{GuestMemoryMmap, GuestRegionMmap};
-use crate::{VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM};
-use block::VirtioBlockConfig;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::mem;
 use std::result;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Barrier, Mutex};
 use std::thread;
 
+use block::VirtioBlockConfig;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use vhost::vhost_user::message::{
     VhostUserConfigFlags, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
     VHOST_USER_CONFIG_OFFSET,
@@ -36,6 +28,15 @@ use vm_migration::{
 };
 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 crate::seccomp_filters::Thread;
+use crate::thread_helper::spawn_virtio_thread;
+use crate::vhost_user::VhostUserCommon;
+use crate::{GuestMemoryMmap, GuestRegionMmap};
+use crate::{VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM};
+
 const DEFAULT_QUEUE_NUMBER: usize = 1;
 
 #[derive(Serialize, Deserialize)]

virtio-devices/src/vhost_user/fs.rs

@@ -1,6 +1,24 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::result;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Barrier, Mutex};
+use std::thread;
+
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use serde_with::{serde_as, Bytes};
+use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
+use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
+use virtio_queue::Queue;
+use vm_memory::{ByteValued, GuestMemoryAtomic};
+use vm_migration::{
+    protocol::MemoryRangeTable, Migratable, MigratableError, Pausable, Snapshot, Snapshottable,
+    Transportable,
+};
+use vmm_sys_util::eventfd::EventFd;
+
 use super::vu_common_ctrl::VhostUserHandle;
 use super::{Error, Result, DEFAULT_VIRTIO_FEATURES};
 use crate::seccomp_filters::Thread;
@@ -11,22 +29,6 @@ use crate::{
     VirtioInterrupt, VirtioSharedMemoryList, VIRTIO_F_IOMMU_PLATFORM,
 };
 use crate::{GuestMemoryMmap, GuestRegionMmap, MmapRegion};
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, Bytes};
-use std::result;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Barrier, Mutex};
-use std::thread;
-use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
-use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
-use virtio_queue::Queue;
-use vm_memory::{ByteValued, GuestMemoryAtomic};
-use vm_migration::{
-    protocol::MemoryRangeTable, Migratable, MigratableError, Pausable, Snapshot, Snapshottable,
-    Transportable,
-};
-use vmm_sys_util::eventfd::EventFd;
 
 const NUM_QUEUE_OFFSET: usize = 1;
 const DEFAULT_QUEUE_NUMBER: usize = 2;

virtio-devices/src/vhost_user/mod.rs

@@ -1,18 +1,13 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-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,
-};
-use anyhow::anyhow;
-use serde::{Deserialize, Serialize};
 use std::io;
 use std::ops::Deref;
 use std::os::unix::io::AsRawFd;
 use std::sync::{atomic::AtomicBool, Arc, Barrier, Mutex};
+
+use anyhow::anyhow;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use vhost::vhost_user::message::{
     VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
@@ -29,6 +24,13 @@ use vm_migration::{protocol::MemoryRangeTable, MigratableError, Snapshot};
 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,
+};
+
 pub mod blk;
 pub mod fs;
 pub mod net;

virtio-devices/src/vhost_user/net.rs

@@ -1,22 +1,14 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::seccomp_filters::Thread;
-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, NetCtrlEpollHandler, VirtioCommon, VirtioDevice, VirtioDeviceType,
-    VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1,
-};
-use crate::{GuestMemoryMmap, GuestRegionMmap};
-use net_util::{build_net_config_space, CtrlQueue, MacAddr, VirtioNetConfig};
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
 use std::result;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Barrier, Mutex};
 use std::thread;
+
+use net_util::{build_net_config_space, CtrlQueue, MacAddr, VirtioNetConfig};
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
 use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
 use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
 use virtio_bindings::virtio_net::{
@@ -34,6 +26,16 @@ use vm_migration::{
 };
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::seccomp_filters::Thread;
+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, NetCtrlEpollHandler, VirtioCommon, VirtioDevice, VirtioDeviceType,
+    VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1,
+};
+use crate::{GuestMemoryMmap, GuestRegionMmap};
+
 const DEFAULT_QUEUE_NUMBER: usize = 2;
 
 #[derive(Serialize, Deserialize)]

virtio-devices/src/vhost_user/vu_common_ctrl.rs

@@ -1,12 +1,6 @@
 // Copyright 2019 Intel Corporation. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use super::{Error, Result};
-use crate::vhost_user::Inflight;
-use crate::{
-    get_host_address_range, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioInterrupt,
-    VirtioInterruptType,
-};
 use std::ffi;
 use std::fs::File;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
@@ -15,6 +9,7 @@ use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
+
 use vhost::vhost_kern::vhost_binding::{VHOST_F_LOG_ALL, VHOST_VRING_F_LOG};
 use vhost::vhost_user::message::{
     VhostUserHeaderFlag, VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
@@ -30,6 +25,13 @@ use vm_memory::{
 use vm_migration::protocol::MemoryRangeTable;
 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,
+};
+
 // Size of a dirty page for vhost-user.
 const VHOST_LOG_PAGE: u64 = 0x1000;
 

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

@@ -672,13 +672,15 @@ where
 
 #[cfg(test)]
 mod tests {
+    use std::io::{Error as IoError, Result as IoResult};
+
+    use libc::EFD_NONBLOCK;
+    use virtio_queue::QueueOwnedT;
+    use vmm_sys_util::eventfd::EventFd;
+
     use super::super::super::tests::TestContext;
     use super::super::defs as csm_defs;
     use super::*;
-    use libc::EFD_NONBLOCK;
-    use std::io::{Error as IoError, Result as IoResult};
-    use virtio_queue::QueueOwnedT;
-    use vmm_sys_util::eventfd::EventFd;
 
     const LOCAL_CID: u64 = 2;
     const PEER_CID: u64 = 3;

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

@@ -144,11 +144,12 @@ impl TxBuf {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::io::Error as IoError;
     use std::io::ErrorKind;
     use std::io::Result as IoResult;
 
+    use super::*;
+
     struct TestSink {
         data: Vec<u8>,
         err: Option<IoError>,

virtio-devices/src/vsock/device.rs

@@ -8,6 +8,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the THIRD-PARTY file.
 
+use std::io;
+use std::os::unix::io::AsRawFd;
+use std::path::PathBuf;
+use std::result;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Barrier, RwLock};
+
+use anyhow::anyhow;
+use byteorder::{ByteOrder, LittleEndian};
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use virtio_queue::Queue;
+use virtio_queue::QueueOwnedT;
+use virtio_queue::QueueT;
+use vm_memory::GuestAddressSpace;
+use vm_memory::GuestMemoryAtomic;
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vm_virtio::AccessPlatform;
+use vmm_sys_util::eventfd::EventFd;
+
 /// This is the `VirtioDevice` implementation for our vsock device. It handles the virtio-level
 /// device logic: feature negotiation, device configuration, and device activation.
 /// The run-time device logic (i.e. event-driven data handling) is implemented by
@@ -37,24 +57,6 @@ use crate::{
     EpollHelperHandler, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterruptType,
     EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
 };
-use anyhow::anyhow;
-use byteorder::{ByteOrder, LittleEndian};
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use std::io;
-use std::os::unix::io::AsRawFd;
-use std::path::PathBuf;
-use std::result;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Barrier, RwLock};
-use virtio_queue::Queue;
-use virtio_queue::QueueOwnedT;
-use virtio_queue::QueueT;
-use vm_memory::GuestAddressSpace;
-use vm_memory::GuestMemoryAtomic;
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vm_virtio::AccessPlatform;
-use vmm_sys_util::eventfd::EventFd;
 
 const QUEUE_SIZE: u16 = 256;
 const NUM_QUEUES: usize = 3;
@@ -522,11 +524,12 @@ impl<B> Migratable for Vsock<B> where B: VsockBackend + Sync + 'static {}
 
 #[cfg(test)]
 mod tests {
+    use libc::EFD_NONBLOCK;
+
     use super::super::tests::{NoopVirtioInterrupt, TestContext};
     use super::super::*;
     use super::*;
     use crate::ActivateError;
-    use libc::EFD_NONBLOCK;
 
     #[test]
     fn test_virtio_device() {

virtio-devices/src/vsock/mod.rs

@@ -13,13 +13,14 @@ mod device;
 mod packet;
 mod unix;
 
+use std::os::unix::io::RawFd;
+
+use packet::VsockPacket;
+
 pub use self::device::Vsock;
 pub use self::unix::VsockUnixBackend;
 pub use self::unix::VsockUnixError;
 
-use packet::VsockPacket;
-use std::os::unix::io::RawFd;
-
 mod defs {
 
     /// Max vsock packet data/buffer size.
@@ -162,6 +163,16 @@ pub trait VsockBackend: VsockChannel + VsockEpollListener + Send {}
 
 #[cfg(test)]
 mod tests {
+    use std::os::unix::io::AsRawFd;
+    use std::path::PathBuf;
+    use std::sync::{Arc, RwLock};
+
+    use libc::EFD_NONBLOCK;
+    use virtio_bindings::virtio_ring::{VRING_DESC_F_NEXT, VRING_DESC_F_WRITE};
+    use vm_memory::{GuestAddress, GuestMemoryAtomic};
+    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::packet::VSOCK_PKT_HDR_SIZE;
     use super::*;
@@ -169,14 +180,6 @@ mod tests {
     use crate::epoll_helper::EpollHelperHandler;
     use crate::EpollHelper;
     use crate::GuestMemoryMmap;
-    use libc::EFD_NONBLOCK;
-    use std::os::unix::io::AsRawFd;
-    use std::path::PathBuf;
-    use std::sync::{Arc, RwLock};
-    use virtio_bindings::virtio_ring::{VRING_DESC_F_NEXT, VRING_DESC_F_WRITE};
-    use vm_memory::{GuestAddress, GuestMemoryAtomic};
-    use vm_virtio::queue::testing::VirtQueue as GuestQ;
-    use vmm_sys_util::eventfd::EventFd;
 
     pub struct NoopVirtioInterrupt {}
 

virtio-devices/src/vsock/packet.rs

@@ -16,16 +16,17 @@
 //! in guest memory. This is done to avoid unnecessarily copying data from guest memory
 //! to temporary buffers, before passing it on to the vsock backend.
 
-use byteorder::{ByteOrder, LittleEndian};
 use std::ops::Deref;
 use std::sync::Arc;
 
+use byteorder::{ByteOrder, LittleEndian};
+use virtio_queue::DescriptorChain;
+use vm_memory::{Address, GuestMemory};
+use vm_virtio::{AccessPlatform, Translatable};
+
 use super::defs;
 use super::{Result, VsockError};
 use crate::get_host_address_range;
-use virtio_queue::DescriptorChain;
-use vm_memory::{Address, GuestMemory};
-use vm_virtio::{AccessPlatform, Translatable};
 
 // The vsock packet header is defined by the C struct:
 //
@@ -420,15 +421,16 @@ impl VsockPacket {
 #[cfg(test)]
 #[allow(clippy::undocumented_unsafe_blocks)]
 mod tests {
-    use super::super::tests::TestContext;
-    use super::*;
-    use crate::vsock::defs::MAX_PKT_BUF_SIZE;
-    use crate::GuestMemoryMmap;
     use virtio_bindings::virtio_ring::VRING_DESC_F_WRITE;
     use virtio_queue::QueueOwnedT;
     use vm_memory::GuestAddress;
     use vm_virtio::queue::testing::VirtqDesc as GuestQDesc;
 
+    use super::super::tests::TestContext;
+    use super::*;
+    use crate::vsock::defs::MAX_PKT_BUF_SIZE;
+    use crate::GuestMemoryMmap;
+
     macro_rules! create_context {
         ($test_ctx:ident, $handler_ctx:ident) => {
             let $test_ctx = TestContext::new();

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

@@ -849,12 +849,14 @@ impl VsockMuxer {
 
 #[cfg(test)]
 mod tests {
+    use std::io::Write;
+    use std::path::{Path, PathBuf};
+
+    use virtio_queue::QueueOwnedT;
+
     use super::super::super::csm::defs as csm_defs;
     use super::super::super::tests::TestContext as VsockTestContext;
     use super::*;
-    use std::io::Write;
-    use std::path::{Path, PathBuf};
-    use virtio_queue::QueueOwnedT;
 
     const PEER_CID: u32 = 3;
     const PEER_BUF_ALLOC: u32 = 64 * 1024;

virtio-devices/src/watchdog.rs

@@ -5,6 +5,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
+use std::fs::File;
+use std::io::{self, Read};
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::result;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Barrier, Mutex};
+use std::time::Instant;
+
+use anyhow::anyhow;
+use seccompiler::SeccompAction;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use virtio_queue::{Queue, QueueT};
+use vm_memory::{Bytes, GuestAddressSpace, GuestMemoryAtomic};
+use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
+use vmm_sys_util::eventfd::EventFd;
+
 use super::Error as DeviceError;
 use super::{
     ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, VirtioCommon,
@@ -14,21 +31,6 @@ use crate::seccomp_filters::Thread;
 use crate::thread_helper::spawn_virtio_thread;
 use crate::GuestMemoryMmap;
 use crate::{VirtioInterrupt, VirtioInterruptType};
-use anyhow::anyhow;
-use seccompiler::SeccompAction;
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io::{self, Read};
-use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
-use std::result;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Barrier, Mutex};
-use std::time::Instant;
-use thiserror::Error;
-use virtio_queue::{Queue, QueueT};
-use vm_memory::{Bytes, GuestAddressSpace, GuestMemoryAtomic};
-use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
-use vmm_sys_util::eventfd::EventFd;
 
 const QUEUE_SIZE: u16 = 8;
 const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE];