gfxstream: Enable the feature upstream via stub backend

This won't be functional at runtime, but does allow us to at
least compile with gfxstream enabled.

BUG=b:244618506
TEST=presubmit

Change-Id: I72a63976310e635964645a1265a22518fc6cb694
Reviewed-on: https://chromium-review.googlesource.com/c/crosvm/crosvm/+/3967431
Reviewed-by: Kaiyi Li <kaiyili@google.com>
Commit-Queue: Dennis Kempin <denniskempin@google.com>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>

Cargo.toml

@@ -171,9 +171,14 @@ gpu = ["devices/gpu", "gpu_display", "vm_control/gpu"]
 ## compatibility with the Android Emulator. The protocol provides the best speed and compatibility
 ## with GL/vulkan versions by forwarding the guest's calls to the host's graphics libraries and GPU.
 ## However, this means the sandbox is not enabled for the virtio-gpu device.
-## Note: This feature is currently not enabled and tested in upstream crosvm.
 gfxstream = ["devices/gfxstream"]
 
+## Adds a stub implementation of gfxstream to allow us to compile the gfxstream feature without
+## access to the gfxstream library.
+## Note that this feature only allows compilation of gfxstream and will not be functional at
+## runtime.
+gfxstream_stub = ["rutabaga_gfx/gfxstream_stub"]
+
 ## Enables 3D acceleration for the guest via the virglrenderer library over virtio-gpu.
 virgl_renderer = ["devices/virgl_renderer"]
 
@@ -277,6 +282,8 @@ all-aarch64 = [
     "default",
     "ffmpeg",
     "gdb",
+    "gfxstream",
+    "gfxstream_stub",
     "panic-memfd",
     "power-monitor-powerd",
     "slirp",

rutabaga_gfx/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 
 [features]
 gfxstream = []
+gfxstream_stub = []
 virgl_renderer = []
 virgl_renderer_next = []
 minigbm = []

rutabaga_gfx/build.rs

@@ -172,9 +172,10 @@ fn virglrenderer() -> Result<()> {
     Ok(())
 }
 
-#[cfg(feature = "gfxstream")]
+#[cfg(all(feature = "gfxstream", not(feature = "gfxstream_stub")))]
 fn gfxstream() -> Result<()> {
     let gfxstream_path = std::env::var("GFXSTREAM_PATH")?;
+    println!("cargo:rustc-link-lib=gfxstream_backend");
     println!("cargo:rustc-link-search={}", gfxstream_path);
     Ok(())
 }
@@ -187,7 +188,7 @@ fn main() -> Result<()> {
 
     #[cfg(feature = "virgl_renderer")]
     virglrenderer()?;
-    #[cfg(feature = "gfxstream")]
+    #[cfg(all(feature = "gfxstream", not(feature = "gfxstream_stub")))]
     gfxstream()?;
 
     Ok(())

rutabaga_gfx/src/gfxstream.rs

@@ -81,9 +81,8 @@ pub struct stream_renderer_vulkan_info {
 }
 
 #[allow(non_camel_case_types)]
-type stream_renderer_create_blob = ResourceCreateBlob;
+pub type stream_renderer_create_blob = ResourceCreateBlob;
 
-#[link(name = "gfxstream_backend")]
 extern "C" {
 
     // Function to globally init gfxstream backend's internal state, taking display/renderer

rutabaga_gfx/src/gfxstream_stub.rs

@@ -0,0 +1,192 @@
+// Copyright 2022 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+//! Stub impplementation of the native interface of gfxstream_backend.so.
+//!
+//! This implementation is used to enable the gfxstream feature of crosvm to be compiled without
+//! gfxstream_backend.so available. It is only used for testing purposes and not functional
+//! at runtime.
+
+#![cfg(feature = "gfxstream_stub")]
+
+use std::os::raw::c_char;
+use std::os::raw::c_int;
+use std::os::raw::c_uchar;
+use std::os::raw::c_uint;
+use std::os::raw::c_void;
+
+use crate::generated::virgl_renderer_bindings::iovec;
+use crate::generated::virgl_renderer_bindings::virgl_box;
+use crate::generated::virgl_renderer_bindings::virgl_renderer_resource_create_args;
+use crate::gfxstream::stream_renderer_create_blob;
+use crate::gfxstream::stream_renderer_handle;
+use crate::gfxstream::stream_renderer_vulkan_info;
+use crate::gfxstream::VirglRendererCallbacks;
+
+#[no_mangle]
+extern "C" fn gfxstream_backend_init(
+    _display_width: u32,
+    _display_height: u32,
+    _display_type: u32,
+    _renderer_cookie: *mut c_void,
+    _renderer_flags: i32,
+    _renderer_callbacks: *mut VirglRendererCallbacks,
+    _gfxstream_callbacks: *mut c_void,
+) {
+    unimplemented!();
+}
+
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_resource_create(
+    _args: *mut virgl_renderer_resource_create_args,
+    _iov: *mut iovec,
+    _num_iovs: u32,
+) -> c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_resource_unref(_res_handle: u32) {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_context_destroy(_handle: u32) {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_transfer_read_iov(
+    _handle: u32,
+    _ctx_id: u32,
+    _level: u32,
+    _stride: u32,
+    _layer_stride: u32,
+    _box_: *mut virgl_box,
+    _offset: u64,
+    _iov: *mut iovec,
+    _iovec_cnt: c_int,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_transfer_write_iov(
+    _handle: u32,
+    _ctx_id: u32,
+    _level: c_int,
+    _stride: u32,
+    _layer_stride: u32,
+    _box_: *mut virgl_box,
+    _offset: u64,
+    _iovec: *mut iovec,
+    _iovec_cnt: c_uint,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_submit_cmd(
+    _commands: *mut c_void,
+    _ctx_id: i32,
+    _dword_count: i32,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_resource_attach_iov(
+    _res_handle: c_int,
+    _iov: *mut iovec,
+    _num_iovs: c_int,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_resource_detach_iov(
+    _res_handle: c_int,
+    _iov: *mut *mut iovec,
+    _num_iovs: *mut c_int,
+) {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_create_fence(_client_fence_id: c_int, _ctx_id: u32) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_ctx_attach_resource(_ctx_id: c_int, _res_handle: c_int) {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn pipe_virgl_renderer_ctx_detach_resource(_ctx_id: c_int, _res_handle: c_int) {
+    unimplemented!();
+}
+
+#[no_mangle]
+extern "C" fn stream_renderer_flush_resource_and_readback(
+    _res_handle: u32,
+    _x: u32,
+    _y: u32,
+    _width: u32,
+    _height: u32,
+    _pixels: *mut c_uchar,
+    _max_bytes: u32,
+) {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_create_blob(
+    _ctx_id: u32,
+    _res_handle: u32,
+    _create_blob: *const stream_renderer_create_blob,
+    _iovecs: *const iovec,
+    _num_iovs: u32,
+    _handle: *const stream_renderer_handle,
+) -> c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+extern "C" fn stream_renderer_export_blob(
+    _res_handle: u32,
+    _handle: *mut stream_renderer_handle,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_resource_map(
+    _res_handle: u32,
+    _map: *mut *mut c_void,
+    _out_size: *mut u64,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_resource_unmap(_res_handle: u32) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_resource_map_info(_res_handle: u32, _map_info: *mut u32) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_vulkan_info(
+    _res_handle: u32,
+    _vulkan_info: *mut stream_renderer_vulkan_info,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_context_create(
+    _handle: u32,
+    _nlen: u32,
+    _name: *const c_char,
+    _context_init: u32,
+) -> c_int {
+    unimplemented!();
+}
+#[no_mangle]
+extern "C" fn stream_renderer_context_create_fence(
+    _fence_id: u64,
+    _ctx_id: u32,
+    _ring_idx: u8,
+) -> c_int {
+    unimplemented!();
+}

rutabaga_gfx/src/lib.rs

@@ -8,6 +8,7 @@
 mod cross_domain;
 mod generated;
 mod gfxstream;
+mod gfxstream_stub;
 #[macro_use]
 mod macros;
 #[cfg(any(feature = "gfxstream", feature = "virgl_renderer"))]

src/crosvm/sys/unix/config.rs

@@ -501,13 +501,13 @@ mod tests {
     #[test]
     fn parse_gpu_options_default_vulkan_support() {
         {
-            let gpu_params: GpuParameters = from_key_values("backend=virglrenderer").unwrap();
+            let gpu_params: GpuParameters = parse_gpu_options("backend=virglrenderer").unwrap();
             assert_eq!(gpu_params.use_vulkan, None);
         }
 
         #[cfg(feature = "gfxstream")]
         {
-            let gpu_params: GpuParameters = from_key_values("backend=gfxstream").unwrap();
+            let gpu_params: GpuParameters = parse_gpu_options("backend=gfxstream").unwrap();
             assert_eq!(gpu_params.use_vulkan, Some(true));
         }
     }

tools/health-check

@@ -112,7 +112,6 @@ def check_rust_lockfiles(_: CheckContext):
 KNOWN_DISABLED_FEATURES = [
     "default-no-sandbox",
     "direct",
-    "gfxstream",
     "libvda",
     "whpx",
 ]