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,27 @@ 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
+        let render_server_fd = config.flags().gpu_path.as_ref().and_then(|path| {
+            File::open(path)
+                .map(|f| f.into())
+                .map_err(|e| {
+                    warn!(
+                        "Failed to open GPU device at {}: {}. Virglrenderer will automatically select an available GPU.",
+                        path.display(),
+                        e
+                    );
+                })
+                .ok()
+        });
+
+        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, render_server_fd)
+            .map_err(|e| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("Failed to initialize virglrenderer: {:?}", e),
+                )
+            })?;
         Ok(Self {
             renderer,
             gpu_backend,

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,

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);