initial webrogue support

Author: Destructor17

include/renderdoc_app.h

@@ -39,6 +39,8 @@
 #define RENDERDOC_CC
 #elif defined(__APPLE__)
 #define RENDERDOC_CC
+#elif defined(__wasi__)
+#define RENDERDOC_CC
 #else
 #error "Unknown platform"
 #endif

meson.build

@@ -416,6 +416,7 @@ with_platform_wayland = _platforms.contains('wayland')
 with_platform_haiku = _platforms.contains('haiku')
 with_platform_windows = _platforms.contains('windows')
 with_platform_macos = _platforms.contains('macos')
+with_platform_webrogue = _platforms.contains('webrogue')
 
 with_glx = get_option('glx')
 if with_glx == 'auto'
@@ -467,7 +468,7 @@ with_xlib_lease = get_option('xlib-lease') \
   .allowed()
 
 with_egl = get_option('egl') \
-  .require(with_platform_windows or with_platform_haiku or with_dri or with_platform_android, error_message : 'EGL requires DRI, Haiku, Windows or Android') \
+  .require(with_platform_windows or with_platform_haiku or with_dri or with_platform_android or with_platform_webrogue, error_message : 'EGL requires DRI, Haiku, Windows, Android or Webrogue') \
   .require(with_glx != 'xlib', error_message :'EGL requires DRI, but GLX is being built with xlib support') \
   .disable_auto_if(with_platform_haiku) \
   .allowed()
@@ -946,7 +947,7 @@ if cc.get_id() == 'gcc' and cc.version().version_compare('< 4.4.6')
 endif
 
 # Support systems without ETIME (e.g. FreeBSD)
-if cc.get_define('ETIME', prefix : '#include <errno.h>') == ''
+if with_platform_webrogue or cc.get_define('ETIME', prefix : '#include <errno.h>') == ''
   pre_args += '-DETIME=ETIMEDOUT'
 endif
 
@@ -1279,7 +1280,7 @@ if cc.compiles('''#include <stdint.h>
   #
   # This can happen for 64-bit atomic operations on 32-bit architectures such
   # as ARM.
-  if not cc.links('''#include <stdint.h>
+  if host_machine.cpu_family() != 'wasm' and not cc.links('''#include <stdint.h>
                      int main() {
                        struct {
                          uint64_t *v;
@@ -1521,7 +1522,7 @@ ld_args_build_id = cc.get_supported_link_arguments('-Wl,--build-id=sha1')
 
 # check for dl support
 dep_dl = null_dep
-if host_machine.system() != 'windows'
+if host_machine.cpu_family() != 'wasm' and host_machine.system() != 'windows'
   if not cc.has_function('dlopen')
     dep_dl = cc.find_library('dl', required : true)
   endif
@@ -1542,7 +1543,7 @@ if with_any_intel and ['x86', 'x86_64'].contains(host_machine.cpu_family())
 endif
 
 # Determine whether or not the rt library is needed for time functions
-if host_machine.system() == 'windows' or cc.has_function('clock_gettime')
+if host_machine.system() == 'windows' or host_machine.cpu_family() == 'wasm' or cc.has_function('clock_gettime')
   dep_clock = null_dep
 else
   dep_clock = cc.find_library('rt')

meson.options

@@ -12,7 +12,7 @@ option(
   type : 'array',
   value : ['auto'],
   choices : [
-    'auto', 'x11', 'wayland', 'haiku', 'android', 'windows', 'macos',
+    'auto', 'x11', 'wayland', 'haiku', 'android', 'windows', 'macos', 'webrogue',
   ],
   description : 'window systems to support. If this is set to `auto`, all ' +
                 'platforms applicable will be enabled.'

src/c11/impl/threads_posix.c

@@ -284,7 +284,8 @@ _Noreturn
 void
 thrd_exit(int res)
 {
-    pthread_exit((void*)(intptr_t)res);
+    abort();
+    // pthread_exit((void*)(intptr_t)res);
 }
 
 // 7.25.5.6

src/gfxstream/guest/connection-manager/GfxStreamConnectionManager.cpp

@@ -40,6 +40,7 @@ bool GfxStreamConnectionManager::initialize() {
             break;
         }
 #endif
+#ifndef DETECT_OS_WASI
         case GFXSTREAM_TRANSPORT_QEMU_PIPE: {
             mStream = new QemuPipeStream(STREAM_BUFFER_SIZE);
             if (mStream->connect() < 0) {
@@ -84,6 +85,17 @@ bool GfxStreamConnectionManager::initialize() {
 
             break;
         }
+#else
+case GFXSTREAM_TRANSPORT_WEBROGUE: {
+    mStream = new makeWebrogueStream(STREAM_BUFFER_SIZE);
+    if (mStream->connect() < 0) {
+        mesa_loge("Failed to connect to host (makeWebrogueStream)\n");
+        return false;
+    }
+
+    break;
+}
+#endif
         default:
             return false;
     }

src/gfxstream/guest/connection-manager/GfxStreamConnectionManager.h

@@ -25,6 +25,7 @@ enum GfxStreamTransportType {
     GFXSTREAM_TRANSPORT_ADDRESS_SPACE = 2,
     GFXSTREAM_TRANSPORT_VIRTIO_GPU_PIPE = 3,
     GFXSTREAM_TRANSPORT_VIRTIO_GPU_ADDRESS_SPACE = 4,
+    GFXSTREAM_TRANSPORT_WEBROGUE = 5,
 };
 
 class GfxStreamConnectionManager {

src/gfxstream/guest/connection-manager/WebrogueStream.cpp

@@ -0,0 +1,77 @@
+#include "WebrogueStream.h"
+#include <cstdint>
+
+__attribute__((import_name("commit_buffer")))
+__attribute__((import_module("webrogue_gfx")))
+void imported_webrogue_gfx_commit_buffer(const void* buf, uint32_t len);
+
+
+__attribute__((import_name("ret_buffer_read")))
+__attribute__((import_module("webrogue_gfx"))) void
+imported_webrogue_gfx_ret_buffer_read(const void* buf, uint32_t len);
+
+
+int WebrogueStream::connect(const char* serviceName = nullptr) {
+    return 0;
+}
+
+class WebrogueStream : public gfxstream::IOStream {
+public:
+    explicit WebrogueStream(size_t bufsize):
+        gfxstream::IOStream(bufsize) {}
+    
+    ~WebrogueStream() {};
+
+    virtual void* allocBuffer(size_t minSize) {
+        size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize);
+        if (!m_buf) {
+            m_buf = (unsigned char *)malloc(allocSize);
+        }
+        else if (m_bufsize < allocSize) {
+            unsigned char *p = (unsigned char *)realloc(m_buf, allocSize);
+            if (p != NULL) {
+                m_buf = p;
+                m_bufsize = allocSize;
+            } else {
+                free(m_buf);
+                m_buf = NULL;
+                m_bufsize = 0;
+            }
+        }
+
+        return m_buf;
+    }
+    virtual int commitBuffer(size_t size) { 
+        if (size == 0) return 0;
+        return writeFully(m_buf, size);
+    }
+    virtual const unsigned char* readFully(void* buf, size_t len) { 
+        imported_webrogue_gfx_ret_buffer_read(buf, len);
+        return (const unsigned char*)buf;
+    }
+    virtual int writeFully(const void* buf, size_t len) {
+        imported_webrogue_gfx_commit_buffer(buf, len);
+        return len;
+    }
+
+    virtual void* getDmaForReading(uint64_t guest_paddr) { return nullptr; }
+    virtual void unlockDma(uint64_t guest_paddr) {}
+
+    virtual void onSave(gfxstream::guest::Stream* stream) { 
+        printf("WebrogueStream::onSave not implemented\n");
+        abort();
+    }
+    virtual unsigned char* onLoad(gfxstream::guest::Stream* stream) { 
+        printf("WebrogueStream::onLoad not implemented\n");
+        abort();
+    }
+
+    virtual const unsigned char *readRaw(void *buf, size_t *inout_len) { 
+        printf("WebrogueStream::readRaw not implemented\n");
+        abort();
+    }
+};
+
+gfxstream::IOStream* makeWebrogueStream(int bufferSize) {
+    return new WebrogueStream(bufferSize);
+}

src/gfxstream/guest/connection-manager/WebrogueStream.h

@@ -0,0 +1,27 @@
+
+#pragma once
+
+#include <stdlib.h>
+
+#include "gfxstream/guest/IOStream.h"
+
+class WebrogueStream : public gfxstream::guest::IOStream {
+   public:
+    explicit WebrogueStream(size_t bufsize, int32_t descriptor);
+    ~WebrogueStream();
+
+    virtual int connect(const char* serviceName = nullptr);
+    virtual uint64_t processPipeInit();
+
+    virtual void* allocBuffer(size_t minSize);
+    virtual int commitBuffer(size_t size);
+    virtual const unsigned char* readFully(void* buf, size_t len);
+    virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
+    virtual const unsigned char* read(void* buf, size_t* inout_len);
+
+    bool valid();
+    int getRendernodeFd();
+    int recv(void* buf, size_t len);
+
+    virtual int writeFully(const void* buf, size_t len);
+};

src/gfxstream/guest/connection-manager/meson.build

@@ -8,6 +8,7 @@ files_libconnection_manager = files(
   'GfxStreamConnection.cpp',
   'QemuPipeStreamStub.cpp',
   'VirtioGpuPipeStream.cpp',
+  'WebrogueStream.cpp',
 )
 
 libconnection_manager = static_library(

src/gfxstream/guest/vulkan-mapper/GfxStreamVulkanMapper.cpp

@@ -245,7 +245,11 @@ int32_t GfxStreamVulkanMapper::map(struct VulkanMapperData* mapData) {
     };
 #endif
 
+#if DETECT_OS_WASI
+    abort();
+#else
     mai.pNext = reinterpret_cast<void*>(&importInfo);
+#endif
 
     VkResult result = mVk.AllocateMemory(mDevice, &mai, nullptr, &mapData->memory);
     if (result != VK_SUCCESS) {