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

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

vhost-device-gpu/README.md

@@ -56,6 +56,12 @@ 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)
+
+          Specifies which GPU device to use for rendering. Only applicable
+          when using the virglrenderer backend.
+
   -h, --help
           Print help (see a summary with '-h')
 
@@ -134,6 +140,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::IoSliceMut,
     os::fd::{AsFd, FromRawFd, IntoRawFd, RawFd},
     sync::{Arc, Mutex},
@@ -159,7 +160,16 @@ impl VirglRendererAdapter {
             fence_state.clone(),
         ));
 
-        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, None)
+        // Open the GPU device if a path was specified
+        let render_server_fd = config.flags().gpu_path.as_ref().map(|path| {
+            File::open(path)
+                .unwrap_or_else(|e| {
+                    panic!("Failed to open GPU device at {}: {}", path.display(), e)
+                })
+                .into()
+        });
+
+        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, render_server_fd)
             .expect("Failed to initialize virglrenderer");
         Self {
             renderer,
@@ -638,6 +648,8 @@ impl Renderer for VirglRendererAdapter {
 mod virgl_cov_tests {
     use std::{
         os::unix::net::UnixStream,
+        panic,
+        path::PathBuf,
         sync::{Arc, Mutex},
     };
 
@@ -925,4 +937,41 @@ mod virgl_cov_tests {
             );
         }
     }
+
+    #[test]
+    fn test_gpu_path_invalid_file_panics() {
+        // Create a config with an invalid gpu_path
+        let cfg = GpuConfig::new(
+            GpuMode::VirglRenderer,
+            Some(GpuCapset::VIRGL),
+            GpuFlags {
+                gpu_path: Some(PathBuf::from("/nonexistent/gpu/device")),
+                ..GpuFlags::default()
+            },
+        )
+        .expect("GpuConfig");
+
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap(),
+        );
+        let (vring, _outs, _call_evt) = create_vring(
+            &mem,
+            &[] as &[TestingDescChainArgs],
+            GuestAddress(0x100),
+            GuestAddress(0x200),
+            16,
+        );
+
+        let backend = dummy_gpu_backend();
+
+        // This should panic when trying to open the nonexistent GPU device
+        let result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+            let _gpu = VirglRendererAdapter::new(&vring, &cfg, backend);
+        }));
+
+        assert!(
+            result.is_err(),
+            "Expected panic when opening invalid GPU device path"
+        );
+    }
 }

vhost-device-gpu/src/lib.rs

@@ -131,6 +131,7 @@ pub struct GpuFlags {
     pub use_glx: bool,
     pub use_gles: bool,
     pub use_surfaceless: bool,
+    pub gpu_path: Option<std::path::PathBuf>,
 }
 
 impl GpuFlags {
@@ -141,6 +142,7 @@ impl GpuFlags {
             use_glx: false,
             use_gles: true,
             use_surfaceless: true,
+            gpu_path: None,
         }
     }
 }
@@ -157,6 +159,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 +212,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,10 @@ 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")]
+    pub gpu_path: Option<PathBuf>,
 }
 
 impl From<GpuFlagsArgs> for GpuFlags {
@@ -123,6 +127,7 @@ impl From<GpuFlagsArgs> for GpuFlags {
             use_glx: args.use_glx,
             use_gles: args.use_gles,
             use_surfaceless: args.use_surfaceless,
+            gpu_path: args.gpu_path,
         }
     }
 }
@@ -200,6 +205,7 @@ mod tests {
                 use_glx: true,
                 use_gles: false,
                 use_surfaceless: false,
+                gpu_path: None,
             },
         };
 
@@ -213,6 +219,7 @@ mod tests {
                 use_glx: true,
                 use_gles: false,
                 use_surfaceless: false,
+                gpu_path: None,
             }
         );
         assert_eq!(config.gpu_mode(), GpuMode::VirglRenderer);