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,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)
+
+          [Optional] 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

@@ -163,8 +163,17 @@ impl VirglRendererAdapter {
             fence_state.clone(),
         ));
 
-        let renderer = VirglRenderer::init(virglrenderer_flags, fence_handler, None)
-            .expect("Failed to initialize virglrenderer");
+        // Use the GPU device FD if provided (already opened and validated at startup)
+        let render_server_fd = config
+            .flags()
+            .render_server_fd
+            .as_ref()
+            .map(|fd| fd.try_clone())
+            .transpose()
+            .map_err(|e| io::Error::other(format!("Failed to clone GPU device FD: {e}")))?;
+
+        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/lib.rs

@@ -21,7 +21,7 @@ pub(crate) mod testutils;
 
 use std::{
     fmt::{Display, Formatter},
-    path::Path,
+    path::{Path, PathBuf},
 };
 
 use bitflags::bitflags;
@@ -117,20 +117,22 @@ impl GpuCapset {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 /// This structure holds the configuration for the GPU backend
 pub struct GpuConfig {
     gpu_mode: GpuMode,
     capset: GpuCapset,
     flags: GpuFlags,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct GpuFlags {
     pub use_egl: bool,
     pub use_glx: bool,
     pub use_gles: bool,
     pub use_surfaceless: bool,
+    #[cfg(feature = "backend-virgl")]
+    pub render_server_fd: Option<std::os::fd::OwnedFd>,
 }
 
 impl GpuFlags {
@@ -141,6 +143,8 @@ impl GpuFlags {
             use_glx: false,
             use_gles: true,
             use_surfaceless: true,
+            #[cfg(feature = "backend-virgl")]
+            render_server_fd: None,
         }
     }
 }
@@ -157,6 +161,10 @@ 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,
+    #[error("Failed to open GPU device '{0}'")]
+    InvalidGpuDevice(PathBuf),
 }
 
 impl GpuConfig {
@@ -208,6 +216,12 @@ impl GpuConfig {
             return Err(GpuConfigError::GlesRequiredByGfxstream);
         }
 
+        // Validate that render_server_fd is only used with virglrenderer
+        #[cfg(feature = "backend-virgl")]
+        if flags.render_server_fd.is_some() && !matches!(gpu_mode, GpuMode::VirglRenderer) {
+            return Err(GpuConfigError::GpuPathNotSupportedByMode);
+        }
+
         Ok(Self {
             gpu_mode,
             capset,
@@ -240,6 +254,7 @@ pub enum StartError {
 
 pub fn start_backend(socket_path: &Path, config: GpuConfig) -> Result<(), StartError> {
     info!("Starting backend");
+
     let backend = VhostUserGpuBackend::new(config).map_err(StartError::CouldNotCreateBackend)?;
 
     let mut daemon = VhostUserDaemon::new(

vhost-device-gpu/src/main.rs

@@ -4,6 +4,11 @@
 //
 // SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause
 
+#[cfg(feature = "backend-virgl")]
+use std::{
+    fs::File,
+    os::fd::{FromRawFd, IntoRawFd, OwnedFd},
+};
 use std::{path::PathBuf, process::exit};
 
 use clap::{ArgAction, Parser, ValueEnum};
@@ -114,6 +119,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,12 +133,36 @@ impl From<GpuFlagsArgs> for GpuFlags {
             use_glx: args.use_glx,
             use_gles: args.use_gles,
             use_surfaceless: args.use_surfaceless,
+            #[cfg(feature = "backend-virgl")]
+            render_server_fd: None,
         }
     }
 }
 
 pub fn config_from_args(args: GpuArgs) -> Result<(PathBuf, GpuConfig), GpuConfigError> {
-    let flags = GpuFlags::from(args.flags);
+    // Open GPU device file if path was provided
+    #[cfg(feature = "backend-virgl")]
+    let render_server_fd = args
+        .flags
+        .gpu_path
+        .as_ref()
+        .map(|gpu_path| {
+            let file = File::open(gpu_path)
+                .map_err(|_| GpuConfigError::InvalidGpuDevice(gpu_path.clone()))?;
+            // SAFETY: File was just opened successfully
+            Ok(unsafe { OwnedFd::from_raw_fd(file.into_raw_fd()) })
+        })
+        .transpose()?;
+
+    let flags = GpuFlags {
+        use_egl: args.flags.use_egl,
+        use_glx: args.flags.use_glx,
+        use_gles: args.flags.use_gles,
+        use_surfaceless: args.flags.use_surfaceless,
+        #[cfg(feature = "backend-virgl")]
+        render_server_fd,
+    };
+
     let capset = args.capset.map(capset_names_into_capset);
     let config = GpuConfig::new(args.gpu_mode, capset, flags)?;
     Ok((args.socket_path, config))
@@ -185,7 +219,13 @@ mod tests {
         let args: &[&str] = &[];
         let flag_args = GpuFlagsArgs::parse_from(args);
         let flags: GpuFlags = flag_args.into();
-        assert_eq!(flags, GpuFlags::default());
+        let default_flags = GpuFlags::default();
+        assert_eq!(flags.use_egl, default_flags.use_egl);
+        assert_eq!(flags.use_glx, default_flags.use_glx);
+        assert_eq!(flags.use_gles, default_flags.use_gles);
+        assert_eq!(flags.use_surfaceless, default_flags.use_surfaceless);
+        #[cfg(feature = "backend-virgl")]
+        assert!(flags.render_server_fd.is_none());
     }
 
     #[test]
@@ -200,22 +240,46 @@ mod tests {
                 use_glx: true,
                 use_gles: false,
                 use_surfaceless: false,
+                #[cfg(feature = "backend-virgl")]
+                gpu_path: None,
             },
         };
 
         let (socket_path, config) = config_from_args(args).unwrap();
 
         assert_eq!(socket_path, expected_path);
-        assert_eq!(
-            *config.flags(),
-            GpuFlags {
-                use_egl: false,
-                use_glx: true,
-                use_gles: false,
-                use_surfaceless: false,
-            }
-        );
+        let flags = config.flags();
+        assert!(!flags.use_egl);
+        assert!(flags.use_glx);
+        assert!(!flags.use_gles);
+        assert!(!flags.use_surfaceless);
+        #[cfg(feature = "backend-virgl")]
+        assert!(flags.render_server_fd.is_none());
         assert_eq!(config.gpu_mode(), GpuMode::VirglRenderer);
-        assert_eq!(config.capsets(), GpuCapset::VIRGL | GpuCapset::VIRGL2)
+        assert_eq!(config.capsets(), GpuCapset::VIRGL | GpuCapset::VIRGL2);
+
+        // Test with invalid GPU path
+        #[cfg(feature = "backend-virgl")]
+        {
+            let invalid_gpu_path = Path::new("/nonexistent/gpu/device");
+            let invalid_args = GpuArgs {
+                socket_path: expected_path.into(),
+                gpu_mode: GpuMode::VirglRenderer,
+                capset: Some(vec![CapsetName::Virgl]),
+                flags: GpuFlagsArgs {
+                    use_egl: true,
+                    use_glx: false,
+                    use_gles: true,
+                    use_surfaceless: true,
+                    gpu_path: Some(invalid_gpu_path.into()),
+                },
+            };
+
+            let result = config_from_args(invalid_args);
+            assert!(matches!(
+                result,
+                Err(GpuConfigError::InvalidGpuDevice(ref path)) if path == invalid_gpu_path
+            ));
+        }
     }
 }