vhost-device-console: add Unix domain socket backend support

- Introduce `BackendType::Uds` for VM communication via Unix sockets
- Refactor address generation logic with `generate_vm_sock_addrs`
- Add CLI parameter `--vm-sock` to specify UDS path
- Update documentation and error handling

Signed-off-by: Hang SU <[email protected]>
Suggested-by: Xuewei Niu <[email protected]>

Author: Hang SU

vhost-device-console/CHANGELOG.md

@@ -4,6 +4,7 @@
 ### Added
 
 - [#811](https://github.com/rust-vmm/vhost-device/pull/811) Being able to specify max queue size
+- [#821](https://github.com/rust-vmm/vhost-device/pull/821) Add Unix domain socket backend support
 
 ### Changed
 

vhost-device-console/README.md

@@ -6,14 +6,17 @@ This program is a vhost-user backend that emulates a VirtIO Console device.
 The device's binary takes as parameters a socket path, a socket number which
 is the number of connections, commonly used across all vhost-devices to
 communicate with the vhost-user frontend devices, and the backend type
-"nested" or "network".
+"nested" or "network" or "uds".
 
 The "nested" backend allows input/output to the guest console through the
 current terminal.
 
 The "network" backend creates a local TCP port (specified on vhost-device-console
 arguments) and allows input/output to the guest console via that socket.
 
+The "uds" backend creates a unix domain socket (specified on vhost-device-console
+arguments) and allows input/output to the guest console via that socket.
+
 This program is tested with QEMU's `vhost-user-device-pci` device.
 Examples' section below.
 
@@ -40,13 +43,18 @@ vhost-device-console --socket-path=<SOCKET_PATH>
  The localhost's port to be used for each guest, this part will be increased with
  0,1,2..socket_count-1.
 
--- option:: -b, --backend=nested|network
+-- option:: -b, --backend=nested|network|uds
 
   The backend type vhost-device-console to be used. The current implementation
-  supports two types of backends: "nested", "network" (described above).
+  supports 3 types of backends: "nested", "network", "uds".
   Note: The nested backend is selected by default and can be used only when
         socket_count equals 1.
 
+.. option:: -v, --vm-sock=uds-file-path
+
+  The unix domain socket to be used for each guest, this part will be increased with
+  0,1,2..socket_count-1.
+
 .. option:: -q, --max-queue-size=SIZE
 
   The maximum size of virtqueues. It is optional, and the default value is
@@ -62,10 +70,10 @@ VIRTIO_CONSOLE_F_SIZE features.
 ## Features
 
 The current device gives access to multiple QEMU guest by providing a login prompt
-either by connecting to a localhost server port (network backend) or by creating an
-nested command prompt in the current terminal (nested backend). This prompt appears
-as soon as the guest is fully booted and gives the ability to user run command as a
-in regular terminal.
+either by connecting to a localhost server port (network backend) or a unix socket
+file (uds backend) or by creating an nested command prompt in the current terminal
+(nested backend). This prompt appears as soon as the guest is fully booted and
+gives the ability to user run command as a in regular terminal.
 
 ## Examples
 

vhost-device-console/src/backend.rs

@@ -42,11 +42,14 @@ pub enum Error {
     ThreadPanic(String, Box<dyn Any + Send>),
     #[error("Error using multiple sockets with Nested backend")]
     WrongBackendSocket,
+    #[error("Invalid uds file")]
+    InvalidUdsFile,
 }
 
 #[derive(PartialEq, Eq, Debug)]
 pub struct VuConsoleConfig {
     pub socket_path: PathBuf,
+    pub vm_sock: String,
     pub backend: BackendType,
     pub tcp_port: String,
     pub socket_count: u32,
@@ -73,23 +76,33 @@ impl VuConsoleConfig {
         (0..self.socket_count).map(make_socket_path).collect()
     }
 
-    pub fn generate_tcp_addrs(&self) -> Vec<String> {
-        let tcp_port_base = self.tcp_port.clone();
-
-        let make_tcp_port = |i: u32| -> String {
-            let port_num: u32 = tcp_port_base.clone().parse().unwrap();
-            "127.0.0.1:".to_owned() + &(port_num + i).to_string()
-        };
-
-        (0..self.socket_count).map(make_tcp_port).collect()
+    pub fn generate_vm_sock_addrs(&self) -> Vec<String> {
+        match self.backend {
+            // if type is Nested, result will be dropped.
+            BackendType::Nested => {
+                vec![String::new()]
+            }
+
+            BackendType::Network => {
+                let port_base: u32 = self.tcp_port.parse().unwrap();
+                let make_tcp_port =
+                    |i: u32| -> String { "127.0.0.1:".to_owned() + &(port_base + i).to_string() };
+                (0..self.socket_count).map(make_tcp_port).collect()
+            }
+
+            BackendType::Uds => {
+                let make_uds_path = |i: u32| -> String { self.vm_sock.to_owned() + &i.to_string() };
+                (0..self.socket_count).map(make_uds_path).collect()
+            }
+        }
     }
 }
 
 /// This is the public API through which an external program starts the
 /// vhost-device-console backend server.
 pub fn start_backend_server(
     socket: PathBuf,
-    tcp_addr: String,
+    vm_sock: String,
     backend: BackendType,
     max_queue_size: usize,
 ) -> Result<()> {
@@ -104,7 +117,7 @@ pub fn start_backend_server(
         vu_console_backend
             .write()
             .unwrap()
-            .assign_input_method(tcp_addr.clone())
+            .assign_input_method(vm_sock.clone())
             .map_err(Error::CouldNotInitBackend)?;
 
         let mut daemon = VhostUserDaemon::new(
@@ -132,26 +145,29 @@ pub fn start_backend_server(
 pub fn start_backend(config: VuConsoleConfig) -> Result<()> {
     let mut handles = HashMap::new();
     let (senders, receiver) = std::sync::mpsc::channel();
-    let tcp_addrs = config.generate_tcp_addrs();
+    let vm_sock = config.generate_vm_sock_addrs();
     let backend = config.backend;
     let max_queue_size = config.max_queue_size;
 
-    for (thread_id, (socket, tcp_addr)) in config
+    for (thread_id, (socket, vm_sock)) in config
         .generate_socket_paths()
         .into_iter()
-        .zip(tcp_addrs.iter())
+        .zip(vm_sock.iter())
         .enumerate()
     {
-        let tcp_addr = tcp_addr.clone();
-        info!("thread_id: {}, socket: {:?}", thread_id, socket);
+        let vm_sock = vm_sock.clone();
+        info!(
+            "thread_id: {}, socket: {:?} mode: {:?} vm_sock: {}",
+            thread_id, socket, backend, vm_sock
+        );
 
-        let name = format!("vhu-console-{}", tcp_addr);
+        let name = format!("vhu-console-{}", vm_sock);
         let sender = senders.clone();
         let handle = Builder::new()
             .name(name.clone())
             .spawn(move || {
                 let result = std::panic::catch_unwind(move || {
-                    start_backend_server(socket, tcp_addr.to_string(), backend, max_queue_size)
+                    start_backend_server(socket, vm_sock.to_string(), backend, max_queue_size)
                 });
 
                 // Notify the main thread that we are done.
@@ -257,16 +273,16 @@ mod tests {
     fn test_backend_start_and_stop(args: ConsoleArgs) -> Result<()> {
         let config = VuConsoleConfig::try_from(args).expect("Wrong config");
 
-        let tcp_addrs = config.generate_tcp_addrs();
+        let vm_sock = config.generate_vm_sock_addrs();
         let backend = config.backend;
         let max_queue_size = config.max_queue_size;
 
-        for (socket, tcp_addr) in config
+        for (socket, vm_sock) in config
             .generate_socket_paths()
             .into_iter()
-            .zip(tcp_addrs.iter())
+            .zip(vm_sock.iter())
         {
-            start_backend_server(socket, tcp_addr.to_string(), backend, max_queue_size)?;
+            start_backend_server(socket, vm_sock.to_string(), backend, max_queue_size)?;
         }
         Ok(())
     }

vhost-device-console/src/console.rs

@@ -15,6 +15,7 @@ pub enum BackendType {
     #[default]
     Nested,
     Network,
+    Uds,
 }
 
 #[derive(Debug)]

vhost-device-console/src/main.rs

@@ -54,11 +54,21 @@ struct ConsoleArgs {
     #[clap(short = 's', long, value_name = "SOCKET")]
     socket_path: PathBuf,
 
+    /// Virtual machine communication endpoint.
+    /// Unix domain socket path (e.g., "/tmp/vm.sock").
+    #[clap(
+        short = 'v',
+        long,
+        value_name = "VM_SOCKET",
+        default_value = "/tmp/vm.sock"
+    )]
+    vm_sock: String,
+
     /// Number of guests (sockets) to connect to.
     #[clap(short = 'c', long, default_value_t = 1)]
     socket_count: u32,
 
-    /// Console backend (Network, Nested) to be used.
+    /// Console backend (Network, Nested, Uds) to be used.
     #[clap(short = 'b', long, value_enum, default_value = "nested")]
     backend: BackendType,
 
@@ -87,14 +97,30 @@ impl TryFrom<ConsoleArgs> for VuConsoleConfig {
 
         let ConsoleArgs {
             socket_path,
+            vm_sock,
             backend,
             tcp_port,
             socket_count,
             max_queue_size,
         } = args;
 
+        // check validation of vm_sock under Uds mode.
+        if backend == BackendType::Uds {
+            if vm_sock.is_empty() {
+                return Err(Error::InvalidUdsFile);
+            }
+
+            let parent = std::path::Path::new(&vm_sock).parent();
+            if let Some(dir) = parent {
+                if !dir.exists() {
+                    return Err(Error::InvalidUdsFile);
+                }
+            }
+        }
+
         Ok(Self {
             socket_path,
+            vm_sock,
             backend,
             tcp_port,
             socket_count,