devices/vsock: unix domain sockets backend

This is the first commit in the final season of the vsock saga. Building
on top of the vhost-less vsock device and the vsock connection state
machine, this brings the Unix Domain Sockets backend for vsock to
Firecracker.

The UDS backend-specific functionality resides mostly with the
`VsockMuxer`, in `devices/src/virtio/vsock/unix/muxer.rs` - a vsock
connection multiplexer, and a translator between guest-side AF_VSOCK and
host-side AF_UNIX streams.

Signed-off-by: Dan Horobeanu <[email protected]>

Author: dhrgit

devices/src/virtio/vsock/csm/mod.rs

@@ -4,7 +4,6 @@
 /// This module implements our vsock connection state machine. The heavy lifting is done by
 /// `connection::VsockConnection`, while this file only defines some constants and helper structs.
 ///
-#[allow(dead_code)]
 mod connection;
 mod txbuf;
 

devices/src/virtio/vsock/mod.rs

@@ -9,11 +9,12 @@ mod csm;
 mod device;
 mod epoll_handler;
 mod packet;
+mod unix;
 
 pub use self::defs::uapi::VIRTIO_ID_VSOCK as TYPE_VSOCK;
 pub use self::defs::EVENT_COUNT as VSOCK_EVENTS_COUNT;
 pub use self::device::Vsock;
-pub use DummyBackend as VsockUnixBackend;
+pub use self::unix::VsockUnixBackend;
 
 use std::os::unix::io::RawFd;
 use std::sync::mpsc;
@@ -24,7 +25,6 @@ use super::super::EpollHandler;
 use super::EpollConfigConstructor;
 use packet::VsockPacket;
 
-#[allow(dead_code)]
 mod defs {
     use crate::DeviceEventT;
 
@@ -189,35 +189,6 @@ pub trait VsockChannel {
 /// translates guest-side vsock connections to host-side Unix domain socket connections.
 pub trait VsockBackend: VsockChannel + VsockEpollListener + Send {}
 
-/// Placeholder implementor for a future vsock backend.
-pub struct DummyBackend {}
-impl DummyBackend {
-    pub fn new(_cid: u64, _path: String) -> Result<Self> {
-        Ok(Self {})
-    }
-}
-impl VsockEpollListener for DummyBackend {
-    fn get_polled_fd(&self) -> RawFd {
-        -1
-    }
-    fn get_polled_evset(&self) -> epoll::Events {
-        epoll::Events::empty()
-    }
-    fn notify(&mut self, _evset: epoll::Events) {}
-}
-impl VsockChannel for DummyBackend {
-    fn recv_pkt(&mut self, _pkt: &mut VsockPacket) -> Result<()> {
-        Ok(())
-    }
-    fn send_pkt(&mut self, _pkt: &VsockPacket) -> Result<()> {
-        Ok(())
-    }
-    fn has_pending_rx(&self) -> bool {
-        false
-    }
-}
-impl VsockBackend for DummyBackend {}
-
 #[cfg(test)]
 mod tests {
     use super::epoll_handler::VsockEpollHandler;

devices/src/virtio/vsock/unix/mod.rs

@@ -0,0 +1,49 @@
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/// This module implements the Unix Domain Sockets backend for vsock - a mediator between
+/// guest-side AF_VSOCK sockets and host-side AF_UNIX sockets. The heavy lifting is performed by
+/// `muxer::VsockMuxer`, a connection multiplexer that uses `super::csm::VsockConnection` for
+/// handling vsock connection states.
+/// Check out `muxer.rs` for a more detailed explanation of the inner workings of this backend.
+///
+mod muxer;
+mod muxer_killq;
+mod muxer_rxq;
+
+pub use muxer::VsockMuxer as VsockUnixBackend;
+
+mod defs {
+    /// Maximum number of established connections that we can handle.
+    pub const MAX_CONNECTIONS: usize = 1023;
+
+    /// Size of the muxer RX packet queue.
+    pub const MUXER_RXQ_SIZE: usize = 256;
+
+    /// Size of the muxer connection kill queue.
+    pub const MUXER_KILLQ_SIZE: usize = 128;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    /// Error registering a new epoll-listening FD.
+    EpollAdd(std::io::Error),
+    /// Error creating an epoll FD.
+    EpollFdCreate(std::io::Error),
+    /// The host made an invalid vsock port connection request.
+    InvalidPortRequest,
+    /// Error accepting a new connection from the host-side Unix socket.
+    UnixAccept(std::io::Error),
+    /// Error binding to the host-side Unix socket.
+    UnixBind(std::io::Error),
+    /// Error connecting to a host-side Unix socket.
+    UnixConnect(std::io::Error),
+    /// Error reading from host-side Unix socket.
+    UnixRead(std::io::Error),
+    /// Muxer connection limit reached.
+    TooManyConnections,
+}
+
+type Result<T> = std::result::Result<T, Error>;
+type MuxerConnection = super::csm::VsockConnection<std::os::unix::net::UnixStream>;