vm-virtio: vsock: Port unit testing from Firecracker

This unit testing porting effort is based off of Firecracker commit
1e1cb6f8f8003e0bdce11d265f0feb23249a03f6

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>

vm-virtio/src/vsock/mod.rs

@@ -89,6 +89,30 @@ pub enum VsockError {
 }
 type Result<T> = std::result::Result<T, VsockError>;
 
+#[derive(Debug)]
+pub enum VsockEpollHandlerError {
+    /// The vsock data/buffer virtio descriptor length is smaller than expected.
+    BufDescTooSmall,
+    /// The vsock data/buffer virtio descriptor is expected, but missing.
+    BufDescMissing,
+    /// Chained GuestMemory error.
+    GuestMemory,
+    /// Bounds check failed on guest memory pointer.
+    GuestMemoryBounds,
+    /// The vsock header descriptor length is too small.
+    HdrDescTooSmall(u32),
+    /// The vsock header `len` field holds an invalid value.
+    InvalidPktLen(u32),
+    /// A data fetch was attempted when no data was available.
+    NoData,
+    /// A data buffer was expected for the provided packet, but it is missing.
+    PktBufMissing,
+    /// Encountered an unexpected write-only virtio descriptor.
+    UnreadableDescriptor,
+    /// Encountered an unexpected read-only virtio descriptor.
+    UnwritableDescriptor,
+}
+
 /// A passive, event-driven object, that needs to be notified whenever an epoll-able event occurs.
 /// An event-polling control loop will use `get_polled_fd()` and `get_polled_evset()` to query
 /// the listener for the file descriptor and the set of events it's interested in. When such an
@@ -131,3 +155,183 @@ pub trait VsockChannel {
 /// Currently, the only implementation we have is `crate::virtio::unix::muxer::VsockMuxer`, which
 /// translates guest-side vsock connections to host-side Unix domain socket connections.
 pub trait VsockBackend: VsockChannel + VsockEpollListener + Send {}
+
+#[cfg(test)]
+mod tests {
+    use libc::EFD_NONBLOCK;
+
+    use super::device::{VsockEpollHandler, RX_QUEUE_EVENT, TX_QUEUE_EVENT};
+    use super::packet::VSOCK_PKT_HDR_SIZE;
+    use super::*;
+
+    use std::os::unix::io::AsRawFd;
+    use std::sync::{Arc, RwLock};
+    use vmm_sys_util::eventfd::EventFd;
+
+    use crate::device::{VirtioInterrupt, VirtioInterruptType};
+    use crate::queue::tests::VirtQueue as GuestQ;
+    use crate::queue::Queue;
+    use crate::{VIRTQ_DESC_F_NEXT, VIRTQ_DESC_F_WRITE};
+    use vm_memory::{GuestAddress, GuestMemoryMmap};
+
+    pub struct TestBackend {
+        pub evfd: EventFd,
+        pub rx_err: Option<VsockError>,
+        pub tx_err: Option<VsockError>,
+        pub pending_rx: bool,
+        pub rx_ok_cnt: usize,
+        pub tx_ok_cnt: usize,
+        pub evset: Option<epoll::Events>,
+    }
+    impl TestBackend {
+        pub fn new() -> Self {
+            Self {
+                evfd: EventFd::new(EFD_NONBLOCK).unwrap(),
+                rx_err: None,
+                tx_err: None,
+                pending_rx: false,
+                rx_ok_cnt: 0,
+                tx_ok_cnt: 0,
+                evset: None,
+            }
+        }
+        pub fn set_rx_err(&mut self, err: Option<VsockError>) {
+            self.rx_err = err;
+        }
+        pub fn set_tx_err(&mut self, err: Option<VsockError>) {
+            self.tx_err = err;
+        }
+        pub fn set_pending_rx(&mut self, prx: bool) {
+            self.pending_rx = prx;
+        }
+    }
+    impl VsockChannel for TestBackend {
+        fn recv_pkt(&mut self, _pkt: &mut VsockPacket) -> Result<()> {
+            match self.rx_err.take() {
+                None => {
+                    self.rx_ok_cnt += 1;
+                    Ok(())
+                }
+                Some(e) => Err(e),
+            }
+        }
+        fn send_pkt(&mut self, _pkt: &VsockPacket) -> Result<()> {
+            match self.tx_err.take() {
+                None => {
+                    self.tx_ok_cnt += 1;
+                    Ok(())
+                }
+                Some(e) => Err(e),
+            }
+        }
+        fn has_pending_rx(&self) -> bool {
+            self.pending_rx
+        }
+    }
+    impl VsockEpollListener for TestBackend {
+        fn get_polled_fd(&self) -> RawFd {
+            self.evfd.as_raw_fd()
+        }
+        fn get_polled_evset(&self) -> epoll::Events {
+            epoll::Events::EPOLLIN
+        }
+        fn notify(&mut self, evset: epoll::Events) {
+            self.evset = Some(evset);
+        }
+    }
+    impl VsockBackend for TestBackend {}
+
+    pub struct TestContext {
+        pub cid: u64,
+        pub mem: GuestMemoryMmap,
+        pub mem_size: usize,
+        pub device: Vsock<TestBackend>,
+    }
+
+    impl TestContext {
+        pub fn new() -> Self {
+            const CID: u64 = 52;
+            const MEM_SIZE: usize = 1024 * 1024 * 128;
+            Self {
+                cid: CID,
+                mem: GuestMemoryMmap::new(&[(GuestAddress(0), MEM_SIZE)]).unwrap(),
+                mem_size: MEM_SIZE,
+                device: Vsock::new(CID, TestBackend::new()).unwrap(),
+            }
+        }
+
+        pub fn create_epoll_handler_context(&self) -> EpollHandlerContext {
+            const QSIZE: u16 = 2;
+
+            let guest_rxvq = GuestQ::new(GuestAddress(0x0010_0000), &self.mem, QSIZE as u16);
+            let guest_txvq = GuestQ::new(GuestAddress(0x0020_0000), &self.mem, QSIZE as u16);
+            let guest_evvq = GuestQ::new(GuestAddress(0x0030_0000), &self.mem, QSIZE as u16);
+            let rxvq = guest_rxvq.create_queue();
+            let txvq = guest_txvq.create_queue();
+            let evvq = guest_evvq.create_queue();
+
+            // Set up one available descriptor in the RX queue.
+            guest_rxvq.dtable[0].set(
+                0x0040_0000,
+                VSOCK_PKT_HDR_SIZE as u32,
+                VIRTQ_DESC_F_WRITE | VIRTQ_DESC_F_NEXT,
+                1,
+            );
+            guest_rxvq.dtable[1].set(0x0040_1000, 4096, VIRTQ_DESC_F_WRITE, 0);
+            guest_rxvq.avail.ring[0].set(0);
+            guest_rxvq.avail.idx.set(1);
+
+            // Set up one available descriptor in the TX queue.
+            guest_txvq.dtable[0].set(0x0050_0000, VSOCK_PKT_HDR_SIZE as u32, VIRTQ_DESC_F_NEXT, 1);
+            guest_txvq.dtable[1].set(0x0050_1000, 4096, 0, 0);
+            guest_txvq.avail.ring[0].set(0);
+            guest_txvq.avail.idx.set(1);
+
+            let queues = vec![rxvq, txvq, evvq];
+            let queue_evts = vec![
+                EventFd::new(EFD_NONBLOCK).unwrap(),
+                EventFd::new(EFD_NONBLOCK).unwrap(),
+                EventFd::new(EFD_NONBLOCK).unwrap(),
+            ];
+            let interrupt_cb = Arc::new(Box::new(
+                move |_: &VirtioInterruptType, _: Option<&Queue>| Ok(()),
+            ) as VirtioInterrupt);
+
+            EpollHandlerContext {
+                guest_rxvq,
+                guest_txvq,
+                guest_evvq,
+                handler: VsockEpollHandler {
+                    mem: Arc::new(RwLock::new(self.mem.clone())),
+                    queues,
+                    queue_evts,
+                    kill_evt: EventFd::new(EFD_NONBLOCK).unwrap(),
+                    interrupt_cb,
+                    backend: TestBackend::new(),
+                },
+            }
+        }
+    }
+
+    pub struct EpollHandlerContext<'a> {
+        pub handler: VsockEpollHandler<TestBackend>,
+        pub guest_rxvq: GuestQ<'a>,
+        pub guest_txvq: GuestQ<'a>,
+        pub guest_evvq: GuestQ<'a>,
+    }
+
+    impl<'a> EpollHandlerContext<'a> {
+        pub fn signal_txq_event(&mut self) {
+            self.handler.queue_evts[1].write(1).unwrap();
+            self.handler
+                .handle_event(TX_QUEUE_EVENT, epoll::Events::EPOLLIN)
+                .unwrap();
+        }
+        pub fn signal_rxq_event(&mut self) {
+            self.handler.queue_evts[0].write(1).unwrap();
+            self.handler
+                .handle_event(RX_QUEUE_EVENT, epoll::Events::EPOLLIN)
+                .unwrap();
+        }
+    }
+}