libkrun: Add vhost-user sound device support

Add support for vhost-user sound devices following
QEMU's vhost-user-snd implementation. This allows
libkrun VMs to use external vhost-user sound backends
(e.g., vhost-device-sound) for audio playback and capture.

The virtio-snd configuration space is read-only and
contains device capabilities (jacks, streams, chmaps, controls).
The implementation uses 4 queues as per the virtio-snd
specification: control, event, TX/playback, and RX/capture.

Note: The ALSA default device in the guest may not work without
additional configuration. Use explicit device specification
(e.g., 'aplay -D hw:0,0 <file>') or create /etc/asound.conf
in the guest to set the default device.

Tested with vhost-device-sound backend using PipeWire.

Signed-off-by: Dorinda Bassey <dbassey@redhat.com>

Author: Dorinda Bassey

examples/chroot_vm.c

@@ -40,6 +40,7 @@ static void print_help(char *const name)
         "              --net=NET_MODE        Set network mode\n"
         "              --passt-socket=PATH   Instead of starting passt, connect to passt socket at PATH\n"
         "              --vhost-user-rng=PATH Use vhost-user RNG backend at socket PATH\n"
+        "              --vhost-user-snd=PATH Use vhost-user sound backend at socket PATH\n"
         "NET_MODE can be either TSI (default) or PASST\n"
         "\n"
         "NEWROOT:      the root directory of the vm\n"
@@ -56,6 +57,7 @@ static const struct option long_options[] = {
     { "net_mode", required_argument, NULL, 'N' },
     { "passt-socket", required_argument, NULL, 'P' },
     { "vhost-user-rng", required_argument, NULL, 'V' },
+    { "vhost-user-snd", required_argument, NULL, 'S' },
     { NULL, 0, NULL, 0 }
 };
 
@@ -66,6 +68,7 @@ struct cmdline {
     enum net_mode net_mode;
     char const *passt_socket_path;
     char const *vhost_user_rng_socket;
+    char const *vhost_user_snd_socket;
     char const *new_root;
     char *const *guest_argv;
 };
@@ -93,6 +96,7 @@ bool parse_cmdline(int argc, char *const argv[], struct cmdline *cmdline)
         .net_mode = NET_MODE_TSI,
         .passt_socket_path = NULL,
         .vhost_user_rng_socket = NULL,
+        .vhost_user_snd_socket = NULL,
         .new_root = NULL,
         .guest_argv = NULL,
         .log_target = KRUN_LOG_TARGET_DEFAULT,
@@ -131,6 +135,9 @@ bool parse_cmdline(int argc, char *const argv[], struct cmdline *cmdline)
         case 'V':
             cmdline->vhost_user_rng_socket = optarg;
             break;
+        case 'S':
+            cmdline->vhost_user_snd_socket = optarg;
+            break;
         case '?':
             return false;
         default:
@@ -270,6 +277,19 @@ int main(int argc, char *const argv[])
         printf("Using vhost-user RNG backend at %s (custom queue size: 512)\n", cmdline.vhost_user_rng_socket);
     }
 
+    // Configure vhost-user sound if requested
+    if (cmdline.vhost_user_snd_socket != NULL) {
+        if (err = krun_add_vhost_user_device(ctx_id, KRUN_VIRTIO_DEVICE_SND,
+                                              cmdline.vhost_user_snd_socket, NULL,
+                                              KRUN_VHOST_USER_SND_NUM_QUEUES,
+                                              KRUN_VHOST_USER_SND_QUEUE_SIZES)) {
+            errno = -err;
+            perror("Error adding vhost-user sound device");
+            return -1;
+        }
+        printf("Using vhost-user sound backend at %s\n", cmdline.vhost_user_snd_socket);
+    }
+
     // Raise RLIMIT_NOFILE to the maximum allowed to create some room for virtio-fs
     getrlimit(RLIMIT_NOFILE, &rlim);
     rlim.rlim_cur = rlim.rlim_max;

include/libkrun.h

@@ -732,6 +732,13 @@ int32_t krun_set_snd_device(uint32_t ctx_id, bool enable);
 #define KRUN_VHOST_USER_RNG_NUM_QUEUES 1
 #define KRUN_VHOST_USER_RNG_QUEUE_SIZES ((uint16_t[]){256})
 
+/**
+ * Vhost-user sound device default queue configuration.
+ * Sound device uses 4 queues: control (idx 0), event (idx 1), TX/playback (idx 2), RX/capture (idx 3).
+ */
+#define KRUN_VHOST_USER_SND_NUM_QUEUES 4
+#define KRUN_VHOST_USER_SND_QUEUE_SIZES ((uint16_t[]){64, 64, 64, 64})
+
 /**
  * Add a vhost-user device to the VM.
  *

src/devices/src/virtio/vhost_user/device.rs

@@ -13,6 +13,7 @@ use std::thread;
 
 use log::{debug, error};
 use utils::eventfd::EventFd;
+use vhost::vhost_user::message::VhostUserConfigFlags;
 use vhost::vhost_user::{Frontend, VhostUserFrontend, VhostUserProtocolFeatures};
 use vhost::{VhostBackend, VhostUserMemoryRegionInfo, VringConfigData};
 use vm_memory::{Address, GuestMemory, GuestMemoryMmap, GuestMemoryRegion};
@@ -54,6 +55,12 @@ pub struct VhostUserDevice {
 
     /// Device state
     device_state: DeviceState,
+
+    /// Cached device configuration space
+    config_space: Arc<Mutex<Vec<u8>>>,
+
+    /// Device-specific configuration space size
+    config_size: u32,
 }
 
 impl VhostUserDevice {
@@ -138,14 +145,6 @@ impl VhostUserDevice {
             num_queues as usize
         };
 
-        debug!(
-            "{}: using {} queues (requested: {}, sizes provided: {})",
-            device_name,
-            actual_num_queues,
-            num_queues,
-            queue_sizes.len()
-        );
-
         let default_size = queue_sizes.last().copied().unwrap_or(256);
         let queue_configs: Vec<_> = (0..actual_num_queues)
             .map(|i| {
@@ -154,6 +153,12 @@ impl VhostUserDevice {
             })
             .collect();
 
+        const VIRTIO_ID_SOUND: u32 = 25;
+        let config_size = match device_type {
+            VIRTIO_ID_SOUND => 16, // sizeof(struct virtio_snd_config)
+            _ => 256,
+        };
+
         Ok(VhostUserDevice {
             frontend: Arc::new(Mutex::new(frontend)),
             device_type,
@@ -163,6 +168,8 @@ impl VhostUserDevice {
             has_protocol_features,
             acked_features: 0,
             device_state: DeviceState::Inactive,
+            config_space: Arc::new(Mutex::new(Vec::new())),
+            config_size,
         })
     }
 
@@ -390,10 +397,55 @@ impl VirtioDevice for VhostUserDevice {
     }
 
     fn read_config(&self, offset: u64, data: &mut [u8]) {
-        // For now, configuration space reads are not supported
-        // This can be extended using VHOST_USER_GET_CONFIG
+        let offset_usize = offset as usize;
+        let end = offset_usize + data.len();
+
+        {
+            let config_cache = self.config_space.lock().unwrap();
+            if !config_cache.is_empty() && end <= config_cache.len() {
+                data.copy_from_slice(&config_cache[offset_usize..end]);
+                return;
+            }
+        }
+
+        // Fetch from backend if not cached
+        if self.has_protocol_features && self.config_size > 0 {
+            if let Ok(mut frontend) = self.frontend.lock() {
+                let mut config_buf = vec![0u8; self.config_size as usize];
+
+                match frontend.get_config(
+                    0,
+                    self.config_size,
+                    VhostUserConfigFlags::empty(),
+                    &mut config_buf,
+                ) {
+                    Ok((_, returned_buf)) => {
+                        let mut config_cache = self.config_space.lock().unwrap();
+                        *config_cache = returned_buf;
+
+                        if end <= config_cache.len() {
+                            data.copy_from_slice(&config_cache[offset_usize..end]);
+                            debug!(
+                                "{}: fetched config on-demand, read {} bytes at offset {}",
+                                self.device_name,
+                                data.len(),
+                                offset
+                            );
+                            return;
+                        }
+                    }
+                    Err(e) => {
+                        debug!(
+                            "{}: failed to fetch config from backend: {:?}",
+                            self.device_name, e
+                        );
+                    }
+                }
+            }
+        }
+
         debug!(
-            "{}: config read at offset {} (not yet implemented)",
+            "{}: config read at offset {} returning zeros (cache empty or read failed)",
             self.device_name, offset
         );
         data.fill(0);