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>

block/src/async_io.rs

@@ -2,10 +2,11 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::DiskTopology;
 use thiserror::Error;
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::DiskTopology;
+
 #[derive(Error, Debug)]
 pub enum DiskFileError {
     /// Failed getting disk file size.

block/src/fixed_vhd.rs

@@ -2,12 +2,13 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhd::VhdFooter;
-use crate::BlockBackend;
 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;
+
 #[derive(Debug)]
 pub struct FixedVhd {
     file: File,

block/src/fixed_vhd_async.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use std::fs::File;
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::fixed_vhd::FixedVhd;
 use crate::raw_async::RawFileAsync;
 use crate::BlockBackend;
-use std::fs::File;
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
 
 pub struct FixedVhdDiskAsync(FixedVhd);
 

block/src/fixed_vhd_sync.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use std::fs::File;
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::fixed_vhd::FixedVhd;
 use crate::raw_sync::RawFileSync;
 use crate::BlockBackend;
-use std::fs::File;
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
 
 pub struct FixedVhdDiskSync(FixedVhd);
 

block/src/lib.rs

@@ -30,15 +30,6 @@ pub mod vhd;
 pub mod vhdx;
 pub mod vhdx_sync;
 
-use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
-use crate::fixed_vhd::FixedVhd;
-use crate::qcow::{QcowFile, RawFile};
-use crate::vhdx::{Vhdx, VhdxError};
-#[cfg(feature = "io_uring")]
-use io_uring::{opcode, IoUring, Probe};
-use libc::{ioctl, S_IFBLK, S_IFMT};
-use serde::{Deserialize, Serialize};
-use smallvec::SmallVec;
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::cmp;
 use std::collections::VecDeque;
@@ -52,6 +43,12 @@ use std::result;
 use std::sync::Arc;
 use std::sync::MutexGuard;
 use std::time::Instant;
+
+#[cfg(feature = "io_uring")]
+use io_uring::{opcode, IoUring, Probe};
+use libc::{ioctl, S_IFBLK, S_IFMT};
+use serde::{Deserialize, Serialize};
+use smallvec::SmallVec;
 use thiserror::Error;
 use virtio_bindings::virtio_blk::*;
 use virtio_queue::DescriptorChain;
@@ -64,6 +61,11 @@ use vmm_sys_util::aio;
 use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::{ioctl_io_nr, ioctl_ioc_nr};
 
+use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult};
+use crate::fixed_vhd::FixedVhd;
+use crate::qcow::{QcowFile, RawFile};
+use crate::vhdx::{Vhdx, VhdxError};
+
 const SECTOR_SHIFT: u8 = 9;
 pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
 

block/src/qcow/mod.rs

@@ -9,20 +9,15 @@ mod raw_file;
 mod refcount;
 mod vec_cache;
 
-use crate::qcow::{
-    qcow_raw_file::QcowRawFile,
-    refcount::RefCount,
-    vec_cache::{CacheMap, Cacheable, VecCache},
-};
-use crate::BlockBackend;
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use libc::{EINVAL, ENOSPC, ENOTSUP};
-use remain::sorted;
 use std::cmp::{max, min};
 use std::fs::OpenOptions;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
 use std::str;
+
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use libc::{EINVAL, ENOSPC, ENOTSUP};
+use remain::sorted;
 use thiserror::Error;
 use vmm_sys_util::{
     file_traits::FileSetLen, file_traits::FileSync, seek_hole::SeekHole, write_zeroes::PunchHole,
@@ -30,6 +25,12 @@ use vmm_sys_util::{
 };
 
 pub use crate::qcow::raw_file::RawFile;
+use crate::qcow::{
+    qcow_raw_file::QcowRawFile,
+    refcount::RefCount,
+    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;
@@ -1837,13 +1838,15 @@ pub fn detect_image_type(file: &mut RawFile) -> Result<ImageType> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use std::fs::File;
     use std::path::Path;
+
     use vmm_sys_util::tempdir::TempDir;
     use vmm_sys_util::tempfile::TempFile;
     use vmm_sys_util::write_zeroes::WriteZeroes;
 
+    use super::*;
+
     fn valid_header_v3() -> Vec<u8> {
         vec![
             0x51u8, 0x46, 0x49, 0xfb, // magic

block/src/qcow/qcow_raw_file.rs

@@ -4,12 +4,14 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use super::RawFile;
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use std::io::{self, BufWriter, Seek, SeekFrom, Write};
 use std::mem::size_of;
+
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use vmm_sys_util::write_zeroes::WriteZeroes;
 
+use super::RawFile;
+
 /// A qcow file. Allows reading/writing clusters and appending clusters.
 #[derive(Debug)]
 pub struct QcowRawFile {

block/src/qcow/raw_file.rs

@@ -8,15 +8,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::BlockBackend;
-use libc::c_void;
 use std::alloc::{alloc_zeroed, dealloc, Layout};
 use std::fs::{File, Metadata};
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::slice;
+
+use libc::c_void;
 use vmm_sys_util::{seek_hole::SeekHole, write_zeroes::PunchHole, write_zeroes::WriteZeroesAt};
 
+use crate::BlockBackend;
+
 #[derive(Debug)]
 pub struct RawFile {
     file: File,

block/src/qcow_sync.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
-use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
-use crate::AsyncAdaptor;
 use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
 use std::sync::{Arc, Mutex, MutexGuard};
+
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
+use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
+use crate::AsyncAdaptor;
+
 pub struct QcowDiskSync {
     qcow_file: Arc<Mutex<QcowFile>>,
 }

block/src/raw_async.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use std::fs::File;
+use std::io::{Seek, SeekFrom};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use io_uring::{opcode, squeue, types, IoUring};
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::DiskTopology;
-use io_uring::{opcode, squeue, types, IoUring};
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
 
 pub struct RawFileDisk {
     file: File,

block/src/raw_async_aio.rs

@@ -5,15 +5,17 @@
 // Copyright © 2023 Crusoe Energy Systems LLC
 //
 
+use std::fs::File;
+use std::io::{Seek, SeekFrom};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use vmm_sys_util::aio;
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::DiskTopology;
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::aio;
-use vmm_sys_util::eventfd::EventFd;
 
 pub struct RawFileDiskAio {
     file: File,

block/src/raw_sync.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use std::collections::VecDeque;
+use std::fs::File;
+use std::io::{Seek, SeekFrom};
+use std::os::unix::io::{AsRawFd, RawFd};
+
+use vmm_sys_util::eventfd::EventFd;
+
 use crate::async_io::{
     AsyncIo, AsyncIoError, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult,
 };
 use crate::DiskTopology;
-use std::collections::VecDeque;
-use std::fs::File;
-use std::io::{Seek, SeekFrom};
-use std::os::unix::io::{AsRawFd, RawFd};
-use vmm_sys_util::eventfd::EventFd;
 
 pub struct RawFileDiskSync {
     file: File,

block/src/vhd.rs

@@ -2,10 +2,11 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{read_aligned_block_size, DiskTopology};
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
 
+use crate::{read_aligned_block_size, DiskTopology};
+
 #[derive(Clone, Copy)]
 pub struct VhdFooter {
     cookie: u64,
@@ -117,11 +118,13 @@ pub fn is_fixed_vhd(f: &mut File) -> std::io::Result<bool> {
 
 #[cfg(test)]
 mod tests {
-    use super::{is_fixed_vhd, VhdFooter};
     use std::fs::File;
     use std::io::{Seek, SeekFrom, Write};
+
     use vmm_sys_util::tempfile::TempFile;
 
+    use super::{is_fixed_vhd, VhdFooter};
+
     fn valid_fixed_vhd_footer() -> Vec<u8> {
         vec![
             0x63, 0x6f, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x78, // cookie

block/src/vhdx/mod.rs

@@ -2,6 +2,15 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use std::collections::btree_map::BTreeMap;
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+use byteorder::{BigEndian, ByteOrder};
+use remain::sorted;
+use thiserror::Error;
+use uuid::Uuid;
+
 use crate::vhdx::{
     vhdx_bat::{BatEntry, VhdxBatError},
     vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError},
@@ -9,13 +18,6 @@ use crate::vhdx::{
     vhdx_metadata::{DiskSpec, VhdxMetadataError},
 };
 use crate::BlockBackend;
-use byteorder::{BigEndian, ByteOrder};
-use remain::sorted;
-use std::collections::btree_map::BTreeMap;
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom, Write};
-use thiserror::Error;
-use uuid::Uuid;
 
 macro_rules! div_round_up {
     ($n:expr,$d:expr) => {

block/src/vhdx/vhdx_bat.rs

@@ -2,14 +2,16 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx::{vhdx_header::RegionTableEntry, vhdx_metadata::DiskSpec};
-use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
-use remain::sorted;
 use std::fs::File;
 use std::io::{self, Seek, SeekFrom};
 use std::mem::size_of;
+
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use remain::sorted;
 use thiserror::Error;
 
+use crate::vhdx::{vhdx_header::RegionTableEntry, vhdx_metadata::DiskSpec};
+
 // Payload BAT Entry States
 pub const PAYLOAD_BLOCK_NOT_PRESENT: u64 = 0;
 pub const PAYLOAD_BLOCK_UNDEFINED: u64 = 1;

block/src/vhdx/vhdx_header.rs

@@ -4,12 +4,13 @@
 
 extern crate log;
 
-use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
-use remain::sorted;
 use std::collections::btree_map::BTreeMap;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
+
+use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
+use remain::sorted;
 use thiserror::Error;
 use uuid::Uuid;
 

block/src/vhdx/vhdx_io.rs

@@ -2,14 +2,16 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use std::fs::File;
+use std::io::{self, Read, Seek, SeekFrom, Write};
+
+use remain::sorted;
+use thiserror::Error;
+
 use crate::vhdx::{
     vhdx_bat::{self, BatEntry, VhdxBatError},
     vhdx_metadata::{self, DiskSpec},
 };
-use remain::sorted;
-use std::fs::File;
-use std::io::{self, Read, Seek, SeekFrom, Write};
-use thiserror::Error;
 
 const SECTOR_SIZE: u64 = 512;
 

block/src/vhdx/vhdx_metadata.rs

@@ -2,15 +2,17 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::vhdx::vhdx_header::RegionTableEntry;
-use byteorder::{LittleEndian, ReadBytesExt};
-use remain::sorted;
 use std::fs::File;
 use std::io::{self, Read, Seek, SeekFrom};
 use std::mem::size_of;
+
+use byteorder::{LittleEndian, ReadBytesExt};
+use remain::sorted;
 use thiserror::Error;
 use uuid::Uuid;
 
+use crate::vhdx::vhdx_header::RegionTableEntry;
+
 const METADATA_SIGN: u64 = 0x6174_6164_6174_656D;
 const METADATA_ENTRY_SIZE: usize = 32;
 const METADATA_MAX_ENTRIES: u16 = 2047;

block/src/vhdx_sync.rs

@@ -2,14 +2,16 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
-use crate::vhdx::{Result as VhdxResult, Vhdx};
-use crate::AsyncAdaptor;
 use std::collections::VecDeque;
 use std::fs::File;
 use std::sync::{Arc, Mutex, MutexGuard};
+
 use vmm_sys_util::eventfd::EventFd;
 
+use crate::async_io::{AsyncIo, AsyncIoResult, DiskFile, DiskFileError, DiskFileResult};
+use crate::vhdx::{Result as VhdxResult, Vhdx};
+use crate::AsyncAdaptor;
+
 pub struct VhdxDiskSync {
     vhdx_file: Arc<Mutex<Vhdx>>,
 }