vhost-device-gpu: Add support for GPU device path

Add a new --gpu-path CLI argument that allows users
to specify which GPU device to use for rendering
when using the virglrenderer backend.
This is useful for systems with multiple GPUs where
a specific device needs to be selected.

Signed-off-by: Dorinda Bassey <[email protected]>

Author: Dorinda Bassey

vhost-device-gpu/CHANGELOG.md

@@ -3,6 +3,8 @@
 
 ### Added
 
+- [[#903]] (https://github.com/rust-vmm/vhost-device/pull/903) vhost-device-gpu: Add support for GPU device path
+
 ### Changed
 
 - [[#852]] (https://github.com/rust-vmm/vhost-device/pull/890) vhost-device-gpu: Refactor vhost-device-gpu

vhost-device-gpu/README.md

@@ -56,6 +56,13 @@ A virtio-gpu device using the vhost-user protocol.
           [default: true]
           [possible values: true, false]
 
+      --gpu-path <PATH>
+          GPU device path (e.g., /dev/dri/renderD128)
+
+          [Optional] Specifies which GPU device to use for rendering. Only
+          applicable when using the virglrenderer backend. If not specified,
+          virglrenderer will automatically select the default GPU device.
+
   -h, --help
           Print help (see a summary with '-h')
 
@@ -134,6 +141,12 @@ First start the daemon on the host machine using one of the available gpu modes:
 host# vhost-device-gpu --socket-path /tmp/gpu.socket --gpu-mode virglrenderer
 ```
 
+To specify a particular GPU device (e.g., when you have multiple GPUs):
+
+```shell
+host# vhost-device-gpu --socket-path /tmp/gpu.socket --gpu-mode virglrenderer --gpu-path /dev/dri/renderD128
+```
+
 With QEMU, there are two device front-ends you can use with this device.
 You can either use `vhost-user-gpu-pci` or `vhost-user-vga`, which also
 implements VGA, that allows you to see boot messages before the guest

vhost-device-gpu/src/backend/virgl.rs

@@ -6,6 +6,7 @@
 
 use std::{
     collections::BTreeMap,
+    fs::File,
     io::{self, IoSliceMut},
     os::fd::{AsFd, FromRawFd, IntoRawFd, RawFd},
     sync::{Arc, Mutex},
@@ -163,8 +164,16 @@ impl VirglRendererAdapter {
             fence_state.clone(),
         ));
 
-        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, None)
-            .expect("Failed to initialize virglrenderer");
+        // Open the GPU device if a path was specified
+        // Note: The path is validated early in start_backend(), so this should not fail
+        let render_server_fd = config
+            .flags()
+            .gpu_path
+            .as_ref()
+            .map(|path| File::open(path).map(|f| f.into()).unwrap());
+
+        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, render_server_fd)
+            .map_err(|e| io::Error::other(format!("Failed to initialize virglrenderer: {e:?}")))?;
         Ok(Self {
             renderer,
             gpu_backend,

vhost-device-gpu/src/device.rs

@@ -110,6 +110,8 @@ pub enum Error {
     NotificationFailed(io::Error),
     #[error("Failed to create new EventFd")]
     EventFdFailed,
+    #[error("Invalid GPU device path: {0}")]
+    InvalidGpuDevice(io::Error),
     #[error("Failed to create an iterator over a descriptor chain: {0}")]
     CreateIteratorDescChain(virtio_queue::Error),
     #[error("Failed to create descriptor chain Reader: {0}")]

vhost-device-gpu/src/lib.rs

@@ -131,6 +131,8 @@ pub struct GpuFlags {
     pub use_glx: bool,
     pub use_gles: bool,
     pub use_surfaceless: bool,
+    #[cfg(feature = "backend-virgl")]
+    pub gpu_path: Option<std::path::PathBuf>,
 }
 
 impl GpuFlags {
@@ -141,6 +143,8 @@ impl GpuFlags {
             use_glx: false,
             use_gles: true,
             use_surfaceless: true,
+            #[cfg(feature = "backend-virgl")]
+            gpu_path: None,
         }
     }
 }
@@ -157,6 +161,8 @@ pub enum GpuConfigError {
     CapsetUnsupportedByMode(GpuMode, GpuCapset),
     #[error("Requested gfxstream-gles capset, but gles is disabled")]
     GlesRequiredByGfxstream,
+    #[error("GPU path can only be specified when using virglrenderer mode")]
+    GpuPathNotSupportedByMode,
 }
 
 impl GpuConfig {
@@ -208,6 +214,12 @@ impl GpuConfig {
             return Err(GpuConfigError::GlesRequiredByGfxstream);
         }
 
+        // Validate that gpu_path is only used with virglrenderer
+        #[cfg(feature = "backend-virgl")]
+        if flags.gpu_path.is_some() && !matches!(gpu_mode, GpuMode::VirglRenderer) {
+            return Err(GpuConfigError::GpuPathNotSupportedByMode);
+        }
+
         Ok(Self {
             gpu_mode,
             capset,
@@ -240,6 +252,15 @@ pub enum StartError {
 
 pub fn start_backend(socket_path: &Path, config: GpuConfig) -> Result<(), StartError> {
     info!("Starting backend");
+
+    // Validate GPU device path early if provided (virgl backend only)
+    #[cfg(feature = "backend-virgl")]
+    if let Some(gpu_path) = config.flags().gpu_path.as_ref() {
+        use std::fs::File;
+        File::open(gpu_path)
+            .map_err(|e| StartError::CouldNotCreateBackend(device::Error::InvalidGpuDevice(e)))?;
+    }
+
     let backend = VhostUserGpuBackend::new(config).map_err(StartError::CouldNotCreateBackend)?;
 
     let mut daemon = VhostUserDaemon::new(

vhost-device-gpu/src/main.rs

@@ -114,6 +114,11 @@ pub struct GpuFlagsArgs {
             default_value_t = GpuFlags::new_default().use_surfaceless
     )]
     pub use_surfaceless: bool,
+
+    /// GPU device path (e.g., /dev/dri/renderD128)
+    #[clap(long, value_name = "PATH")]
+    #[cfg(feature = "backend-virgl")]
+    pub gpu_path: Option<PathBuf>,
 }
 
 impl From<GpuFlagsArgs> for GpuFlags {
@@ -123,6 +128,8 @@ impl From<GpuFlagsArgs> for GpuFlags {
             use_glx: args.use_glx,
             use_gles: args.use_gles,
             use_surfaceless: args.use_surfaceless,
+            #[cfg(feature = "backend-virgl")]
+            gpu_path: args.gpu_path,
         }
     }
 }
@@ -200,6 +207,8 @@ mod tests {
                 use_glx: true,
                 use_gles: false,
                 use_surfaceless: false,
+                #[cfg(feature = "backend-virgl")]
+                gpu_path: None,
             },
         };
 
@@ -213,6 +222,8 @@ mod tests {
                 use_glx: true,
                 use_gles: false,
                 use_surfaceless: false,
+                #[cfg(feature = "backend-virgl")]
+                gpu_path: None,
             }
         );
         assert_eq!(config.gpu_mode(), GpuMode::VirglRenderer);