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

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
-                .get_polled_evset()
-                .contains(epoll::Events::EPOLLOUT));
+            assert!(
+                ctx.conn
+                    .get_polled_evset()
+                    .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
-                .get_polled_evset()
-                .contains(epoll::Events::EPOLLOUT));
+            assert!(
+                ctx.conn
+                    .get_polled_evset()
+                    .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.
 ///