virtio: move testing utilities in separate module

Signed-off-by: Cihodaru Alexandru <[email protected]>

Author: AlexandruCihodaru

src/devices/src/virtio/mod.rs

@@ -16,6 +16,7 @@ mod mmio;
 pub mod net;
 pub mod persist;
 mod queue;
+pub mod test_utils;
 pub mod vsock;
 
 pub use self::balloon::*;

src/devices/src/virtio/persist.rs

@@ -196,10 +196,11 @@ impl Persist<'_> for MmioTransport {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::virtio::block::device::tests::default_mem;
     use crate::virtio::mmio::tests::DummyDevice;
-    use crate::virtio::{Block, Net, Vsock, VsockUnixBackend};
+    use crate::virtio::{net, Block, Net, Vsock, VsockUnixBackend};
 
+    use crate::virtio::block::test_utils::default_block_with_path;
+    use crate::virtio::test_utils::default_mem;
     use utils::tempfile::TempFile;
 
     const DEFAULT_QUEUE_MAX_SIZE: u16 = 256;
@@ -362,7 +363,6 @@ mod tests {
     }
 
     fn default_block() -> (MmioTransport, GuestMemoryMmap, Arc<Mutex<Block>>) {
-        use crate::virtio::block::device::tests::default_block_with_path;
         let mem = default_mem();
 
         // Create backing file.
@@ -377,7 +377,7 @@ mod tests {
 
     fn default_net() -> (MmioTransport, GuestMemoryMmap, Arc<Mutex<Net>>) {
         let mem = default_mem();
-        let net = Arc::new(Mutex::new(Net::default_net()));
+        let net = Arc::new(Mutex::new(net::test_utils::default_net()));
         let mmio_transport = MmioTransport::new(mem.clone(), net.clone());
 
         (mmio_transport, mem, net)

src/devices/src/virtio/queue.rs

@@ -389,266 +389,12 @@ impl Queue {
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use std::marker::PhantomData;
-    use std::mem;
 
     pub use super::*;
-    use crate::virtio::QueueError::{DescIndexOutOfBounds, UsedRing};
-    use vm_memory::{Bytes, GuestAddress, GuestMemoryMmap};
-
-    // Represents a location in GuestMemoryMmap which holds a given type.
-    pub struct SomeplaceInMemory<'a, T> {
-        pub location: GuestAddress,
-        mem: &'a GuestMemoryMmap,
-        phantom: PhantomData<*const T>,
-    }
-
-    // The ByteValued trait is required to use mem.read_obj_from_addr and write_obj_at_addr.
-    impl<'a, T> SomeplaceInMemory<'a, T>
-    where
-        T: vm_memory::ByteValued,
-    {
-        fn new(location: GuestAddress, mem: &'a GuestMemoryMmap) -> Self {
-            SomeplaceInMemory {
-                location,
-                mem,
-                phantom: PhantomData,
-            }
-        }
-
-        // Reads from the actual memory location.
-        pub fn get(&self) -> T {
-            self.mem.read_obj(self.location).unwrap()
-        }
-
-        // Writes to the actual memory location.
-        pub fn set(&self, val: T) {
-            self.mem.write_obj(val, self.location).unwrap()
-        }
-
-        // This function returns a place in memory which holds a value of type U, and starts
-        // offset bytes after the current location.
-        fn map_offset<U>(&self, offset: usize) -> SomeplaceInMemory<'a, U> {
-            SomeplaceInMemory {
-                location: self.location.checked_add(offset as u64).unwrap(),
-                mem: self.mem,
-                phantom: PhantomData,
-            }
-        }
-
-        // This function returns a place in memory which holds a value of type U, and starts
-        // immediately after the end of self (which is location + sizeof(T)).
-        fn next_place<U>(&self) -> SomeplaceInMemory<'a, U> {
-            self.map_offset::<U>(mem::size_of::<T>())
-        }
-
-        fn end(&self) -> GuestAddress {
-            self.location
-                .checked_add(mem::size_of::<T>() as u64)
-                .unwrap()
-        }
-    }
-
-    // Represents a virtio descriptor in guest memory.
-    pub struct VirtqDesc<'a> {
-        pub addr: SomeplaceInMemory<'a, u64>,
-        pub len: SomeplaceInMemory<'a, u32>,
-        pub flags: SomeplaceInMemory<'a, u16>,
-        pub next: SomeplaceInMemory<'a, u16>,
-    }
-
-    impl<'a> VirtqDesc<'a> {
-        pub const ALIGNMENT: u64 = 16;
-
-        fn new(start: GuestAddress, mem: &'a GuestMemoryMmap) -> Self {
-            assert_eq!(start.0 & (Self::ALIGNMENT - 1), 0);
-
-            let addr = SomeplaceInMemory::new(start, mem);
-            let len = addr.next_place();
-            let flags = len.next_place();
-            let next = flags.next_place();
-
-            VirtqDesc {
-                addr,
-                len,
-                flags,
-                next,
-            }
-        }
-
-        fn start(&self) -> GuestAddress {
-            self.addr.location
-        }
-
-        fn end(&self) -> GuestAddress {
-            self.next.end()
-        }
-
-        pub fn set(&self, addr: u64, len: u32, flags: u16, next: u16) {
-            self.addr.set(addr);
-            self.len.set(len);
-            self.flags.set(flags);
-            self.next.set(next);
-        }
-
-        pub fn check_data(&self, expected_data: &[u8]) {
-            assert!(self.len.get() as usize >= expected_data.len());
-            let mem = self.addr.mem;
-            let mut buf = vec![0; expected_data.len() as usize];
-            assert!(mem
-                .read_slice(&mut buf, GuestAddress::new(self.addr.get()))
-                .is_ok());
-            assert_eq!(buf.as_slice(), expected_data);
-        }
-    }
-
-    // Represents a virtio queue ring. The only difference between the used and available rings,
-    // is the ring element type.
-    pub struct VirtqRing<'a, T> {
-        pub flags: SomeplaceInMemory<'a, u16>,
-        pub idx: SomeplaceInMemory<'a, u16>,
-        pub ring: Vec<SomeplaceInMemory<'a, T>>,
-        pub event: SomeplaceInMemory<'a, u16>,
-    }
-
-    impl<'a, T> VirtqRing<'a, T>
-    where
-        T: vm_memory::ByteValued,
-    {
-        fn new(
-            start: GuestAddress,
-            mem: &'a GuestMemoryMmap,
-            qsize: u16,
-            alignment: usize,
-        ) -> Self {
-            assert_eq!(start.0 & (alignment as u64 - 1), 0);
-
-            let flags = SomeplaceInMemory::new(start, mem);
-            let idx = flags.next_place();
-
-            let mut ring = Vec::with_capacity(qsize as usize);
-
-            ring.push(idx.next_place());
-
-            for _ in 1..qsize as usize {
-                let x = ring.last().unwrap().next_place();
-                ring.push(x)
-            }
-
-            let event = ring.last().unwrap().next_place();
-
-            flags.set(0);
-            idx.set(0);
-            event.set(0);
 
-            VirtqRing {
-                flags,
-                idx,
-                ring,
-                event,
-            }
-        }
-
-        pub fn end(&self) -> GuestAddress {
-            self.event.end()
-        }
-    }
-
-    #[repr(C)]
-    #[derive(Clone, Copy, Default)]
-    pub struct VirtqUsedElem {
-        pub id: u32,
-        pub len: u32,
-    }
-
-    unsafe impl vm_memory::ByteValued for VirtqUsedElem {}
-
-    pub type VirtqAvail<'a> = VirtqRing<'a, u16>;
-    pub type VirtqUsed<'a> = VirtqRing<'a, VirtqUsedElem>;
-
-    pub struct VirtQueue<'a> {
-        pub dtable: Vec<VirtqDesc<'a>>,
-        pub avail: VirtqAvail<'a>,
-        pub used: VirtqUsed<'a>,
-    }
-
-    impl<'a> VirtQueue<'a> {
-        // We try to make sure things are aligned properly :-s
-        pub fn new(start: GuestAddress, mem: &'a GuestMemoryMmap, qsize: u16) -> Self {
-            // power of 2?
-            assert!(qsize > 0 && qsize & (qsize - 1) == 0);
-
-            let mut dtable = Vec::with_capacity(qsize as usize);
-
-            let mut end = start;
-
-            for _ in 0..qsize {
-                let d = VirtqDesc::new(end, mem);
-                end = d.end();
-                dtable.push(d);
-            }
-
-            const AVAIL_ALIGN: usize = 2;
-
-            let avail = VirtqAvail::new(end, mem, qsize, AVAIL_ALIGN);
-
-            const USED_ALIGN: u64 = 4;
-
-            let mut x = avail.end().0;
-            x = (x + USED_ALIGN - 1) & !(USED_ALIGN - 1);
-
-            let used = VirtqUsed::new(GuestAddress(x), mem, qsize, USED_ALIGN as usize);
-
-            VirtQueue {
-                dtable,
-                avail,
-                used,
-            }
-        }
-
-        pub fn size(&self) -> u16 {
-            self.dtable.len() as u16
-        }
-
-        fn dtable_start(&self) -> GuestAddress {
-            self.dtable.first().unwrap().start()
-        }
-
-        fn avail_start(&self) -> GuestAddress {
-            self.avail.flags.location
-        }
-
-        fn used_start(&self) -> GuestAddress {
-            self.used.flags.location
-        }
-
-        // Creates a new Queue, using the underlying memory regions represented by the VirtQueue.
-        pub fn create_queue(&self) -> Queue {
-            let mut q = Queue::new(self.size());
-
-            q.size = self.size();
-            q.ready = true;
-            q.desc_table = self.dtable_start();
-            q.avail_ring = self.avail_start();
-            q.used_ring = self.used_start();
-
-            q
-        }
-
-        pub fn start(&self) -> GuestAddress {
-            self.dtable_start()
-        }
-
-        pub fn end(&self) -> GuestAddress {
-            self.used.end()
-        }
-
-        pub fn check_used_elem(&self, used_index: u16, expected_id: u16, expected_len: u32) {
-            let used_elem = self.used.ring[used_index as usize].get();
-            assert_eq!(used_elem.id, expected_id as u32);
-            assert_eq!(used_elem.len, expected_len);
-        }
-    }
+    use crate::virtio::test_utils::VirtQueue;
+    use crate::virtio::QueueError::{DescIndexOutOfBounds, UsedRing};
+    use vm_memory::{GuestAddress, GuestMemoryMmap};
 
     #[test]
     fn test_checked_new_descriptor_chain() {