gpu: add new gfxstream initialization flags

BUG=b:233676779
TEST=presubmit

Change-Id: I02103077006c2ac4bc8b3b21bf186de9743530e7
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/3668930
Auto-Submit: Kaiyi Li <kaiyili@google.com>
Reviewed-by: Jason Macnak <natsu@google.com>
Commit-Queue: Kaiyi Li <kaiyili@google.com>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>

devices/src/virtio/gpu/mod.rs

@@ -1025,6 +1025,7 @@ impl Gpu {
             .set_use_vulkan(gpu_parameters.use_vulkan)
             .set_use_syncfd(gpu_parameters.gfxstream_use_syncfd)
             .set_use_guest_angle(gpu_parameters.gfxstream_use_guest_angle)
+            .set_wsi(gpu_parameters.wsi.as_ref())
             .set_use_external_blob(external_blob)
             .set_use_render_server(render_server_fd.is_some());
 

devices/src/virtio/gpu/parameters.rs

@@ -5,6 +5,7 @@
 //! Definitions and utilities for GPU related parameters.
 
 use super::GpuMode;
+use rutabaga_gfx::RutabagaWsi;
 
 use serde::{Deserialize, Serialize};
 
@@ -37,6 +38,8 @@ pub struct GpuParameters {
     pub gfxstream_use_guest_angle: bool,
     pub gfxstream_use_syncfd: bool,
     pub use_vulkan: bool,
+    pub gfxstream_support_gles31: bool,
+    pub wsi: Option<RutabagaWsi>,
     pub udmabuf: bool,
     pub mode: GpuMode,
     pub cache_path: Option<String>,
@@ -60,6 +63,8 @@ impl Default for GpuParameters {
             } else {
                 GpuMode::Mode2D
             },
+            gfxstream_support_gles31: true,
+            wsi: None,
             cache_path: None,
             cache_size: None,
             udmabuf: false,

rutabaga_gfx/Cargo.toml

@@ -21,6 +21,7 @@ base = { path = "../base" }
 remain = "*"
 sync = { path = "../common/sync" }
 thiserror = "*"
+serde = { version = "1", features = [ "derive" ] }
 #vulkano = {git = "https:/github.com/vulkano-rs/vulkano.git", optional = true}
 
 [build-dependencies]

rutabaga_gfx/src/rutabaga_core.rs

@@ -855,6 +855,12 @@ impl RutabagaBuilder {
         self
     }
 
+    /// Use the Vulkan swapchain to draw on the host window for gfxstream.
+    pub fn set_wsi(mut self, v: Option<&RutabagaWsi>) -> RutabagaBuilder {
+        self.gfxstream_flags = self.gfxstream_flags.set_wsi(v);
+        self
+    }
+
     /// Set rutabaga channels for the RutabagaBuilder
     pub fn set_rutabaga_channels(
         mut self,

rutabaga_gfx/src/rutabaga_utils.rs

@@ -13,6 +13,7 @@ use std::str::Utf8Error;
 use base::{Error as BaseError, ExternalMappingError, SafeDescriptor};
 use data_model::VolatileMemoryError;
 use remain::sorted;
+use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 #[cfg(feature = "vulkano")]
@@ -409,12 +410,18 @@ const GFXSTREAM_RENDERER_FLAGS_USE_GLES: u32 = 1 << 4;
 const GFXSTREAM_RENDERER_FLAGS_NO_VK_BIT: u32 = 1 << 5;
 const GFXSTREAM_RENDERER_FLAGS_NO_SYNCFD_BIT: u32 = 1 << 20;
 const GFXSTREAM_RENDERER_FLAGS_GUEST_USES_ANGLE: u32 = 1 << 21;
+const GFXSTREAM_RENDERER_FLAGS_VULKAN_NATIVE_SWAPCHAIN_BIT: u32 = 1 << 22;
 pub const GFXSTREAM_RENDERER_FLAGS_ASYNC_FENCE_CB: u32 = 1 << 23;
 
 /// gfxstream flag struct.
 #[derive(Copy, Clone, Default)]
 pub struct GfxstreamFlags(u32);
 
+#[derive(Debug, Serialize, Deserialize)]
+pub enum RutabagaWsi {
+    Vulkan,
+}
+
 impl GfxstreamFlags {
     /// Create new gfxstream flags.
     pub fn new() -> GfxstreamFlags {
@@ -468,6 +475,15 @@ impl GfxstreamFlags {
     pub fn use_async_fence_cb(self, v: bool) -> GfxstreamFlags {
         self.set_flag(GFXSTREAM_RENDERER_FLAGS_ASYNC_FENCE_CB, v)
     }
+
+    /// Use the Vulkan swapchain to draw on the host window.
+    pub fn set_wsi(self, v: Option<&RutabagaWsi>) -> GfxstreamFlags {
+        let use_vulkan_swapchain = matches!(v, Some(RutabagaWsi::Vulkan));
+        self.set_flag(
+            GFXSTREAM_RENDERER_FLAGS_VULKAN_NATIVE_SWAPCHAIN_BIT,
+            use_vulkan_swapchain,
+        )
+    }
 }
 
 impl From<GfxstreamFlags> for u32 {

src/main.rs

@@ -72,7 +72,8 @@ use vm_control::{
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 use x86_64::{set_enable_pnp_data_msr_config, set_itmt_msr_config};
 
-use rutabaga_gfx::calculate_context_mask;
+#[cfg(feature = "gpu")]
+use rutabaga_gfx::{calculate_context_mask, RutabagaWsi};
 
 const ONE_MB: u64 = 1 << 20;
 const MB_ALIGNED: u64 = ONE_MB - 1;
@@ -389,6 +390,17 @@ fn parse_gpu_options(s: Option<&str>, gpu_params: &mut GpuParameters) -> argumen
                         }
                     }
                 }
+                "wsi" => match v {
+                    "vk" => {
+                        gpu_params.wsi = Some(RutabagaWsi::Vulkan);
+                    }
+                    _ => {
+                        return Err(argument::Error::InvalidValue {
+                            value: v.to_string(),
+                            expected: String::from("gpu parameter 'wsi' should be vk"),
+                        });
+                    }
+                },
                 "width" => {
                     let width = v
                         .parse::<u32>()
@@ -3850,6 +3862,32 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "gpu")]
+    #[test]
+    fn parse_gpu_options_gfxstream_with_wsi_specified() {
+        let mut gpu_params: GpuParameters = Default::default();
+        assert!(parse_gpu_options(Some("backend=virglrenderer,wsi=vk"), &mut gpu_params).is_ok());
+        assert!(matches!(gpu_params.wsi, Some(RutabagaWsi::Vulkan)));
+
+        let mut gpu_params: GpuParameters = Default::default();
+        assert!(parse_gpu_options(Some("wsi=vk,backend=virglrenderer"), &mut gpu_params).is_ok());
+        assert!(matches!(gpu_params.wsi, Some(RutabagaWsi::Vulkan)));
+
+        let mut gpu_params: GpuParameters = Default::default();
+        assert!(parse_gpu_options(
+            Some("backend=virglrenderer,wsi=invalid_value"),
+            &mut gpu_params
+        )
+        .is_err());
+
+        let mut gpu_params: GpuParameters = Default::default();
+        assert!(parse_gpu_options(
+            Some("wsi=invalid_value,backend=virglrenderer"),
+            &mut gpu_params
+        )
+        .is_err());
+    }
+
     #[test]
     fn parse_battery_vaild() {
         parse_battery_options(Some("type=goldfish")).expect("parse should have succeded");

src/sys/unix/main.rs

@@ -218,6 +218,8 @@ pub fn get_arguments() -> Vec<Argument> {
 
                               vulkan[=true|=false] - If the backend should support vulkan
 
+                              wsi=vk - If the gfxstream backend should use the Vulkan swapchain to draw on a window
+
                               cache-path=PATH - The path to the virtio-gpu device shader cache.
 
                               cache-size=SIZE - The maximum size of the shader cache."),