[PATCH v4 0/5] Support virtio-gpu DRM native context

[PATCH v4 0/5] Support virtio-gpu DRM native context

[Dmitry Osipenko]

This patchset adds DRM native context support to VirtIO-GPU on Qemu.

Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
DRM native context [1] mediates lower level kernel driver UAPI, which
reflects in a less CPU overhead and less/simpler code needed to support it.
DRM context consists of a host and guest parts that have to be implemented
for each GPU driver. On a guest side, DRM context presents a virtual GPU as
a real/native host GPU device for GL/VK applications.

[1] https://www.youtube.com/watch?v=9sFP_yddLLQ

Today there are four known DRM native context drivers existing in a wild:

  - Freedreno (Qualcomm SoC GPUs), completely upstreamed
  - AMDGPU, mostly merged into upstreams
  - Intel (i915), merge requests are opened
  - Asahi (Apple SoC GPUs), WIP status


# How to try out DRM context:

1. DRM context uses host blobs and requires latest developer version 
of Linux kernel [2] that has necessary KVM fixes.

[2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/

2. Use latest libvirglrenderer from upstream git/main for Freedreno
and AMDGPU native contexts. For Intel use patches [3].

[3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384

3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
Mesa patches [4], for Intel [5].

[4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
[5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870

4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
   running Xorg in guest.

[6] https://lore.kernel.org/dri-devel/20241020224725.179937-1-dmitry.osipenko@collabora.com/

Example Qemu cmdline that enables DRM context:

  qemu-system-x86_64 -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
      -machine q35,accel=kvm,memory-backend=mem1 \
      -object memory-backend-memfd,id=mem1,size=8G -m 8G


# Note about known performance problem in Qemu:

DRM contexts are mapping host blobs extensively and these mapping
operations work slowly in Qemu. Exact reason is unknown. Mappings work
fast on Crosvm For DRM contexts this problem is more visible than for
Venus/Virgl.

Changelog:

v4: - Improved SDL2/dmabuf patch by reusing existing Meson X11 config 
      option, better handling EGL error and extending comment telling
      that it's safe to enable SDL2 EGL preference hint. As was suggested
      by Akihiko Odaki.

    - Replaced another QSLIST_FOREACH_SAFE with QSLIST_EMPTY+FIRST in
      the async-fencing patch for more consistency of the code. As was
      suggested by Akihiko Odaki.

    - Added missing braces around if-statement that was spotted by
      Alex Bennée.

    - Renamed 'drm=on' option of virtio-gpu-gl device to 
      'drm_native_context=on' for more clarity as was suggested by 
      Alex Bennée. Haven't added added new context-type option that 
      was also proposed by Alex, might do it with a separate patch.
      This context-type option will duplicate and depecate existing
      options, but in a longer run likely will be worthwhile adding
      it.

    - Dropped Linux headers-update patch as headers has been updated
      in the staging tree.

v3: - Improved EGL presence-check code on X11 systems for the SDL2
      hint that prefers EGL over GLX by using better ifdefs and checking
      Xlib presence at a build time to avoid build failure if lib SDL2
      and system are configured with a disabled X11 support. Also added
      clarifying comment telling that X11 hint doesn't affect Wayland
      systems. Suggested by Akihiko Odaki.

    - Corrected strerror(err) that used negative error where it should
      be positive and vice versa that was caught by Akihiko Odaki. Added
      clarifying comment for the case where we get positive error code
      from virglrenderer that differs from other virglrenderer API functions.

    - Improved QSLIST usage by dropping mutex protecting the async fence
      list and using atomic variant of QSLIST helpers instead. Switched away
      from using FOREACH helper to improve readability of the code, showing
      that we don't precess list in unoptimal way. Like was suggested by
      Akihiko Odaki.

    - Updated patchset base to Venus v18.

v2: - Updated SDL2-dmabuf patch by making use of error_report() and
      checking presense of X11+EGL in the system before making SDL2
      to prefer EGL backend over GLX, suggested by Akihiko Odaki.

    - Improved SDL2's dmabuf-presence check that wasn't done properly
      in v1, where EGL was set up only after first console was fully
      inited, and thus, SDL's display .has_dmabuf callback didn't work
      for the first console. Now dmabuf support status is pre-checked
      before console is registered.

    - Updated commit description of the patch that fixes SDL2's context
      switching logic with a more detailed explanation of the problem.
      Suggested by Akihiko Odaki.

    - Corrected rebase typo in the async-fencing patch and switched
      async-fencing to use a sigle-linked list instead of the double,
      as was suggested by Akihiko Odaki.

    - Replaced "=true" with "=on" in the DRM native context documentation
      example and made virtio_gpu_virgl_init() to fail with a error message
      if DRM context can't be initialized instead of giving a warning
      message, as was suggested by Akihiko Odaki.

    - Added patchew's dependecy tag to the cover letter as was suggested by
      Akihiko Odaki.

Dmitry Osipenko (4):
  ui/sdl2: Restore original context after new context creation
  virtio-gpu: Handle virgl fence creation errors
  virtio-gpu: Support asynchronous fencing
  virtio-gpu: Support DRM native context

Pierre-Eric Pelloux-Prayer (1):
  ui/sdl2: Implement dpy dmabuf functions

 docs/system/devices/virtio-gpu.rst |  11 ++
 hw/display/virtio-gpu-gl.c         |   5 +
 hw/display/virtio-gpu-virgl.c      | 158 ++++++++++++++++++++++++++---
 hw/display/virtio-gpu.c            |  15 +++
 include/hw/virtio/virtio-gpu.h     |  16 +++
 include/ui/sdl2.h                  |   7 ++
 meson.build                        |   6 +-
 ui/sdl2-gl.c                       |  67 ++++++++++++
 ui/sdl2.c                          |  42 ++++++++
 9 files changed, 309 insertions(+), 18 deletions(-)

-- 
2.47.0

[PATCH v4 1/5] ui/sdl2: Restore original context after new context creation

[Dmitry Osipenko]

SDL API changes GL context to a newly created GL context, which differs
from other GL providers that don't switch context. Change SDL backend to
restore the original GL context. This allows Qemu's virtio-gpu to support
new virglrenderer async-fencing feature for Virgl contexts, otherwise
virglrenderer's vrend creates a fence-sync context on the Qemu's
main-loop thread that erroneously stays in-use by the main-loop after
creation, not allowing vrend's fence-sync thread switch to this new
context that belongs to it.

Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
---
 ui/sdl2-gl.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ui/sdl2-gl.c b/ui/sdl2-gl.c
index e01d9ab0c7bf..b1fe96d6af22 100644
--- a/ui/sdl2-gl.c
+++ b/ui/sdl2-gl.c
@@ -168,6 +168,9 @@ QEMUGLContext sdl2_gl_create_context(DisplayGLCtx *dgc,
                             SDL_GL_CONTEXT_PROFILE_ES);
         ctx = SDL_GL_CreateContext(scon->real_window);
     }
+
+    SDL_GL_MakeCurrent(scon->real_window, scon->winctx);
+
     return (QEMUGLContext)ctx;
 }
 
-- 
2.47.0

[PATCH v4 2/5] ui/sdl2: Implement dpy dmabuf functions

[Dmitry Osipenko]

From: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>

If EGL is used, we can rely on dmabuf to import textures without
doing copies.

To get this working on X11, we use the existing SDL hint:
SDL_HINT_VIDEO_X11_FORCE_EGL (because dmabuf can't be used with GLX).

Signed-off-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
---
 include/ui/sdl2.h |  7 ++++++
 meson.build       |  6 ++---
 ui/sdl2-gl.c      | 64 +++++++++++++++++++++++++++++++++++++++++++++++
 ui/sdl2.c         | 42 +++++++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 4 deletions(-)

diff --git a/include/ui/sdl2.h b/include/ui/sdl2.h
index dbe6e3d9739b..9daf5ecffae7 100644
--- a/include/ui/sdl2.h
+++ b/include/ui/sdl2.h
@@ -45,6 +45,7 @@ struct sdl2_console {
     bool gui_keysym;
     SDL_GLContext winctx;
     QKbdState *kbd;
+    bool has_dmabuf;
 #ifdef CONFIG_OPENGL
     QemuGLShader *gls;
     egl_fb guest_fb;
@@ -96,5 +97,11 @@ void sdl2_gl_scanout_texture(DisplayChangeListener *dcl,
                              void *d3d_tex2d);
 void sdl2_gl_scanout_flush(DisplayChangeListener *dcl,
                            uint32_t x, uint32_t y, uint32_t w, uint32_t h);
+void sdl2_gl_scanout_dmabuf(DisplayChangeListener *dcl,
+                            QemuDmaBuf *dmabuf);
+void sdl2_gl_release_dmabuf(DisplayChangeListener *dcl,
+                            QemuDmaBuf *dmabuf);
+bool sdl2_gl_has_dmabuf(DisplayChangeListener *dcl);
+void sdl2_gl_console_init(struct sdl2_console *scon);
 
 #endif /* SDL2_H */
diff --git a/meson.build b/meson.build
index e0b880e4e138..d4bb8a8e2323 100644
--- a/meson.build
+++ b/meson.build
@@ -1937,10 +1937,8 @@ if get_option('gtk') \
   endif
 endif
 
-x11 = not_found
-if gtkx11.found()
-  x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found())
-endif
+x11 = dependency('x11', method: 'pkg-config', required: gtkx11.found())
+
 png = not_found
 if get_option('png').allowed() and have_system
    png = dependency('libpng', version: '>=1.6.34', required: get_option('png'),
diff --git a/ui/sdl2-gl.c b/ui/sdl2-gl.c
index b1fe96d6af22..8d53e340d40d 100644
--- a/ui/sdl2-gl.c
+++ b/ui/sdl2-gl.c
@@ -26,6 +26,8 @@
  */
 
 #include "qemu/osdep.h"
+#include "qemu/main-loop.h"
+#include "qemu/error-report.h"
 #include "ui/console.h"
 #include "ui/input.h"
 #include "ui/sdl2.h"
@@ -249,3 +251,65 @@ void sdl2_gl_scanout_flush(DisplayChangeListener *dcl,
 
     SDL_GL_SwapWindow(scon->real_window);
 }
+
+void sdl2_gl_scanout_dmabuf(DisplayChangeListener *dcl,
+                            QemuDmaBuf *dmabuf)
+{
+    struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
+
+    assert(scon->opengl);
+    SDL_GL_MakeCurrent(scon->real_window, scon->winctx);
+
+    egl_dmabuf_import_texture(dmabuf);
+    if (!qemu_dmabuf_get_texture(dmabuf)) {
+        error_report("%s: failed fd=%d", __func__, qemu_dmabuf_get_fd(dmabuf));
+        return;
+    }
+
+    sdl2_gl_scanout_texture(dcl, qemu_dmabuf_get_texture(dmabuf), false,
+                            qemu_dmabuf_get_width(dmabuf),
+                            qemu_dmabuf_get_height(dmabuf),
+                            0, 0,
+                            qemu_dmabuf_get_width(dmabuf),
+                            qemu_dmabuf_get_height(dmabuf),
+                            NULL);
+
+    if (qemu_dmabuf_get_allow_fences(dmabuf)) {
+        scon->guest_fb.dmabuf = dmabuf;
+    }
+}
+
+void sdl2_gl_release_dmabuf(DisplayChangeListener *dcl,
+                            QemuDmaBuf *dmabuf)
+{
+    egl_dmabuf_release_texture(dmabuf);
+}
+
+bool sdl2_gl_has_dmabuf(DisplayChangeListener *dcl)
+{
+    struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
+
+    return scon->has_dmabuf;
+}
+
+void sdl2_gl_console_init(struct sdl2_console *scon)
+{
+    bool hidden = scon->hidden;
+
+    scon->hidden = true;
+    scon->surface = qemu_create_displaysurface(1, 1);
+    sdl2_window_create(scon);
+
+    /*
+     * QEMU checks whether console supports dma-buf before switching
+     * to the console.  To break this chicken-egg problem we pre-check
+     * dma-buf availability beforehand using a dummy SDL window.
+     */
+    scon->has_dmabuf = qemu_egl_has_dmabuf();
+
+    sdl2_window_destroy(scon);
+    qemu_free_displaysurface(scon->surface);
+
+    scon->surface = NULL;
+    scon->hidden = hidden;
+}
diff --git a/ui/sdl2.c b/ui/sdl2.c
index bd4f5a9da14a..c81f693b8299 100644
--- a/ui/sdl2.c
+++ b/ui/sdl2.c
@@ -35,6 +35,10 @@
 #include "ui/win32-kbd-hook.h"
 #include "qemu/log.h"
 
+#ifdef CONFIG_X11
+#include <X11/Xlib.h>
+#endif
+
 static int sdl2_num_outputs;
 static struct sdl2_console *sdl2_console;
 
@@ -120,6 +124,9 @@ void sdl2_window_create(struct sdl2_console *scon)
         /* The SDL renderer is only used by sdl2-2D, when OpenGL is disabled */
         scon->real_renderer = SDL_CreateRenderer(scon->real_window, -1, 0);
     }
+
+    qemu_egl_display = eglGetCurrentDisplay();
+
     sdl_update_caption(scon);
 }
 
@@ -820,6 +827,10 @@ static const DisplayChangeListenerOps dcl_gl_ops = {
     .dpy_gl_scanout_disable  = sdl2_gl_scanout_disable,
     .dpy_gl_scanout_texture  = sdl2_gl_scanout_texture,
     .dpy_gl_update           = sdl2_gl_scanout_flush,
+
+    .dpy_gl_scanout_dmabuf   = sdl2_gl_scanout_dmabuf,
+    .dpy_gl_release_dmabuf   = sdl2_gl_release_dmabuf,
+    .dpy_has_dmabuf          = sdl2_gl_has_dmabuf,
 };
 
 static bool
@@ -847,6 +858,35 @@ static void sdl2_display_early_init(DisplayOptions *o)
     }
 }
 
+static void sdl2_set_hint_x11_force_egl(void)
+{
+#if defined(SDL_HINT_VIDEO_X11_FORCE_EGL) && defined(CONFIG_OPENGL) && \
+    defined(CONFIG_X11)
+    Display *x_disp = XOpenDisplay(NULL);
+    EGLDisplay egl_display;
+
+    if (!x_disp) {
+        return;
+    }
+
+    /* Prefer EGL over GLX to get dma-buf support. */
+    egl_display = eglGetDisplay((EGLNativeDisplayType)x_disp);
+
+    if (egl_display != EGL_NO_DISPLAY) {
+        /*
+         * Setting X11_FORCE_EGL hint doesn't make SDL to prefer X11 over
+         * Wayland. SDL will use Wayland driver even if XWayland presents.
+         * It's always safe to set the hint even if X11 is not used by SDL.
+         * SDL will work regardless of the hint.
+         */
+        SDL_SetHint(SDL_HINT_VIDEO_X11_FORCE_EGL, "1");
+        eglTerminate(egl_display);
+    }
+
+    XCloseDisplay(x_disp);
+#endif
+}
+
 static void sdl2_display_init(DisplayState *ds, DisplayOptions *o)
 {
     uint8_t data = 0;
@@ -877,6 +917,7 @@ static void sdl2_display_init(DisplayState *ds, DisplayOptions *o)
     SDL_SetHint(SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED, "0");
 #endif
     SDL_SetHint(SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4, "1");
+    sdl2_set_hint_x11_force_egl();
     SDL_EnableScreenSaver();
     memset(&info, 0, sizeof(info));
     SDL_VERSION(&info.version);
@@ -923,6 +964,7 @@ static void sdl2_display_init(DisplayState *ds, DisplayOptions *o)
         sdl2_console[i].kbd = qkbd_state_init(con);
         if (display_opengl) {
             qemu_console_set_display_gl_ctx(con, &sdl2_console[i].dgc);
+            sdl2_gl_console_init(&sdl2_console[i]);
         }
         register_displaychangelistener(&sdl2_console[i].dcl);
 
-- 
2.47.0

[PATCH v4 3/5] virtio-gpu: Handle virgl fence creation errors

[Dmitry Osipenko]

Print out error messages when virgl fence creation fails to aid debugging
of the fence-related bugs.

Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
---
 hw/display/virtio-gpu-virgl.c | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/hw/display/virtio-gpu-virgl.c b/hw/display/virtio-gpu-virgl.c
index eedae7357f1a..a875c68a35e5 100644
--- a/hw/display/virtio-gpu-virgl.c
+++ b/hw/display/virtio-gpu-virgl.c
@@ -892,6 +892,7 @@ void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
                                       struct virtio_gpu_ctrl_command *cmd)
 {
     bool cmd_suspended = false;
+    int ret;
 
     VIRTIO_GPU_FILL_CMD(cmd->cmd_hdr);
 
@@ -990,7 +991,17 @@ void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
     }
 
     trace_virtio_gpu_fence_ctrl(cmd->cmd_hdr.fence_id, cmd->cmd_hdr.type);
-    virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, cmd->cmd_hdr.type);
+
+    /*
+     * Unlike other virglrenderer functions, this one returns a positive
+     * error code.
+     */
+    ret = virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, 0);
+    if (ret) {
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "%s: virgl_renderer_create_fence error: %s",
+                      __func__, strerror(ret));
+    }
 }
 
 static void virgl_write_fence(void *opaque, uint32_t fence)
-- 
2.47.0

[PATCH v4 4/5] virtio-gpu: Support asynchronous fencing

[Dmitry Osipenko]

Support asynchronous fencing feature of virglrenderer. It allows Qemu to
handle fence as soon as it's signalled instead of periodically polling
the fence status. This feature is required for enabling DRM context
support in Qemu because legacy fencing mode isn't supported for DRM
contexts in virglrenderer.

Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
---
 hw/display/virtio-gpu-gl.c     |   3 +
 hw/display/virtio-gpu-virgl.c  | 141 ++++++++++++++++++++++++++++-----
 include/hw/virtio/virtio-gpu.h |  13 +++
 3 files changed, 135 insertions(+), 22 deletions(-)

diff --git a/hw/display/virtio-gpu-gl.c b/hw/display/virtio-gpu-gl.c
index 7c0e448b4661..53d938f23f20 100644
--- a/hw/display/virtio-gpu-gl.c
+++ b/hw/display/virtio-gpu-gl.c
@@ -170,6 +170,9 @@ static void virtio_gpu_gl_device_unrealize(DeviceState *qdev)
     if (gl->renderer_state >= RS_INITED) {
 #if VIRGL_VERSION_MAJOR >= 1
         qemu_bh_delete(gl->cmdq_resume_bh);
+
+        virtio_gpu_virgl_reset_async_fences(g);
+        qemu_bh_delete(gl->async_fence_bh);
 #endif
         if (virtio_gpu_stats_enabled(g->parent_obj.conf)) {
             timer_free(gl->print_stats);
diff --git a/hw/display/virtio-gpu-virgl.c b/hw/display/virtio-gpu-virgl.c
index a875c68a35e5..d59c7b6d48ed 100644
--- a/hw/display/virtio-gpu-virgl.c
+++ b/hw/display/virtio-gpu-virgl.c
@@ -891,6 +891,7 @@ static void virgl_cmd_set_scanout_blob(VirtIOGPU *g,
 void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
                                       struct virtio_gpu_ctrl_command *cmd)
 {
+    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
     bool cmd_suspended = false;
     int ret;
 
@@ -992,35 +993,73 @@ void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
 
     trace_virtio_gpu_fence_ctrl(cmd->cmd_hdr.fence_id, cmd->cmd_hdr.type);
 
-    /*
-     * Unlike other virglrenderer functions, this one returns a positive
-     * error code.
-     */
-    ret = virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, 0);
-    if (ret) {
-        qemu_log_mask(LOG_GUEST_ERROR,
-                      "%s: virgl_renderer_create_fence error: %s",
-                      __func__, strerror(ret));
+    if (gl->context_fence_enabled &&
+        (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_INFO_RING_IDX)) {
+        uint32_t flags = 0;
+
+        ret = virgl_renderer_context_create_fence(cmd->cmd_hdr.ctx_id, flags,
+                                                  cmd->cmd_hdr.ring_idx,
+                                                  cmd->cmd_hdr.fence_id);
+        if (ret) {
+            qemu_log_mask(LOG_GUEST_ERROR,
+                          "%s: virgl_renderer_context_create_fence error: %s",
+                          __func__, strerror(-ret));
+        }
+    } else {
+        /*
+         * Unlike other virglrenderer functions, this one returns a positive
+         * error code.
+         */
+        ret = virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, 0);
+        if (ret) {
+            qemu_log_mask(LOG_GUEST_ERROR,
+                          "%s: virgl_renderer_create_fence error: %s",
+                          __func__, strerror(ret));
+        }
     }
 }
 
-static void virgl_write_fence(void *opaque, uint32_t fence)
+static void virtio_gpu_virgl_async_fence_bh(void *opaque)
 {
-    VirtIOGPU *g = opaque;
+    QSLIST_HEAD(, virtio_gpu_virgl_context_fence) async_fenceq;
     struct virtio_gpu_ctrl_command *cmd, *tmp;
+    struct virtio_gpu_virgl_context_fence *f;
+    VirtIOGPU *g = opaque;
+    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
 
-    QTAILQ_FOREACH_SAFE(cmd, &g->fenceq, next, tmp) {
-        /*
-         * the guest can end up emitting fences out of order
-         * so we should check all fenced cmds not just the first one.
-         */
-        if (cmd->cmd_hdr.fence_id > fence) {
-            continue;
+    QSLIST_MOVE_ATOMIC(&async_fenceq, &gl->async_fenceq);
+
+    while (!QSLIST_EMPTY(&async_fenceq)) {
+        f = QSLIST_FIRST(&async_fenceq);
+
+        QSLIST_REMOVE_HEAD(&async_fenceq, next);
+
+        QTAILQ_FOREACH_SAFE(cmd, &g->fenceq, next, tmp) {
+            /*
+             * the guest can end up emitting fences out of order
+             * so we should check all fenced cmds not just the first one.
+             */
+            if (cmd->cmd_hdr.fence_id > f->fence_id) {
+                continue;
+            }
+            if (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_INFO_RING_IDX) {
+                if (cmd->cmd_hdr.ring_idx != f->ring_idx) {
+                    continue;
+                }
+                if (cmd->cmd_hdr.ctx_id != f->ctx_id) {
+                    continue;
+                }
+            } else if (f->ring_idx >= 0) {
+                /* ctx0 GL-query fences don't have ring info */
+                continue;
+            }
+            virtio_gpu_ctrl_response_nodata(g, cmd, VIRTIO_GPU_RESP_OK_NODATA);
+            QTAILQ_REMOVE(&g->fenceq, cmd, next);
+            g_free(cmd);
         }
-        trace_virtio_gpu_fence_resp(cmd->cmd_hdr.fence_id);
-        virtio_gpu_ctrl_response_nodata(g, cmd, VIRTIO_GPU_RESP_OK_NODATA);
-        QTAILQ_REMOVE(&g->fenceq, cmd, next);
-        g_free(cmd);
+
+        trace_virtio_gpu_fence_resp(f->fence_id);
+        g_free(f);
         g->inflight--;
         if (virtio_gpu_stats_enabled(g->parent_obj.conf)) {
             trace_virtio_gpu_dec_inflight_fences(g->inflight);
@@ -1028,6 +1067,52 @@ static void virgl_write_fence(void *opaque, uint32_t fence)
     }
 }
 
+void virtio_gpu_virgl_reset_async_fences(VirtIOGPU *g)
+{
+    struct virtio_gpu_virgl_context_fence *f;
+    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
+
+    while (!QSLIST_EMPTY(&gl->async_fenceq)) {
+        f = QSLIST_FIRST(&gl->async_fenceq);
+
+        QSLIST_REMOVE_HEAD(&gl->async_fenceq, next);
+
+        g_free(f);
+    }
+}
+
+static void
+virtio_gpu_virgl_push_async_fence(VirtIOGPU *g, uint32_t ctx_id,
+                                  int64_t ring_idx, uint64_t fence_id)
+{
+    struct virtio_gpu_virgl_context_fence *f;
+    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
+
+    f = g_new(struct virtio_gpu_virgl_context_fence, 1);
+    f->ctx_id = ctx_id;
+    f->ring_idx = ring_idx;
+    f->fence_id = fence_id;
+
+    QSLIST_INSERT_HEAD_ATOMIC(&gl->async_fenceq, f, next);
+
+    qemu_bh_schedule(gl->async_fence_bh);
+}
+
+static void virgl_write_fence(void *opaque, uint32_t fence)
+{
+    VirtIOGPU *g = opaque;
+
+    virtio_gpu_virgl_push_async_fence(g, 0, -1, fence);
+}
+
+static void virgl_write_context_fence(void *opaque, uint32_t ctx_id,
+                                      uint32_t ring_idx, uint64_t fence)
+{
+    VirtIOGPU *g = opaque;
+
+    virtio_gpu_virgl_push_async_fence(g, ctx_id, ring_idx, fence);
+}
+
 static virgl_renderer_gl_context
 virgl_create_context(void *opaque, int scanout_idx,
                      struct virgl_renderer_gl_ctx_param *params)
@@ -1115,6 +1200,8 @@ void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g)
         dpy_gfx_replace_surface(g->parent_obj.scanout[i].con, NULL);
         dpy_gl_scanout_disable(g->parent_obj.scanout[i].con);
     }
+
+    virtio_gpu_virgl_reset_async_fences(g);
 }
 
 void virtio_gpu_virgl_reset(VirtIOGPU *g)
@@ -1132,6 +1219,12 @@ int virtio_gpu_virgl_init(VirtIOGPU *g)
     if (qemu_egl_display) {
         virtio_gpu_3d_cbs.version = 4;
         virtio_gpu_3d_cbs.get_egl_display = virgl_get_egl_display;
+#if VIRGL_VERSION_MAJOR >= 1
+        virtio_gpu_3d_cbs.write_context_fence = virgl_write_context_fence;
+        flags |= VIRGL_RENDERER_ASYNC_FENCE_CB;
+        flags |= VIRGL_RENDERER_THREAD_SYNC;
+        gl->context_fence_enabled = true;
+#endif
     }
 #endif
 #ifdef VIRGL_RENDERER_D3D11_SHARE_TEXTURE
@@ -1165,6 +1258,10 @@ int virtio_gpu_virgl_init(VirtIOGPU *g)
     gl->cmdq_resume_bh = aio_bh_new(qemu_get_aio_context(),
                                     virtio_gpu_virgl_resume_cmdq_bh,
                                     g);
+
+    gl->async_fence_bh = aio_bh_new(qemu_get_aio_context(),
+                                    virtio_gpu_virgl_async_fence_bh,
+                                    g);
 #endif
 
     return 0;
diff --git a/include/hw/virtio/virtio-gpu.h b/include/hw/virtio/virtio-gpu.h
index 553799b8cc72..99cc6286f473 100644
--- a/include/hw/virtio/virtio-gpu.h
+++ b/include/hw/virtio/virtio-gpu.h
@@ -227,6 +227,13 @@ struct VirtIOGPUClass {
                              Error **errp);
 };
 
+struct virtio_gpu_virgl_context_fence {
+    uint32_t ctx_id;
+    int64_t ring_idx;
+    uint64_t fence_id;
+    QSLIST_ENTRY(virtio_gpu_virgl_context_fence) next;
+};
+
 /* VirtIOGPUGL renderer states */
 typedef enum {
     RS_START,       /* starting state */
@@ -244,6 +251,11 @@ struct VirtIOGPUGL {
     QEMUTimer *print_stats;
 
     QEMUBH *cmdq_resume_bh;
+
+    QEMUBH *async_fence_bh;
+    QSLIST_HEAD(, virtio_gpu_virgl_context_fence) async_fenceq;
+
+    bool context_fence_enabled;
 };
 
 struct VhostUserGPU {
@@ -358,5 +370,6 @@ void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g);
 void virtio_gpu_virgl_reset(VirtIOGPU *g);
 int virtio_gpu_virgl_init(VirtIOGPU *g);
 GArray *virtio_gpu_virgl_get_capsets(VirtIOGPU *g);
+void virtio_gpu_virgl_reset_async_fences(VirtIOGPU *g);
 
 #endif
-- 
2.47.0

Re: [PATCH v4 4/5] virtio-gpu: Support asynchronous fencing

[Alex Bennée]

Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:

> Support asynchronous fencing feature of virglrenderer. It allows Qemu to
> handle fence as soon as it's signalled instead of periodically polling
> the fence status. This feature is required for enabling DRM context
> support in Qemu because legacy fencing mode isn't supported for DRM
> contexts in virglrenderer.
>
> Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
> ---
>  hw/display/virtio-gpu-gl.c     |   3 +
>  hw/display/virtio-gpu-virgl.c  | 141 ++++++++++++++++++++++++++++-----
>  include/hw/virtio/virtio-gpu.h |  13 +++
>  3 files changed, 135 insertions(+), 22 deletions(-)
>
> diff --git a/hw/display/virtio-gpu-gl.c b/hw/display/virtio-gpu-gl.c
> index 7c0e448b4661..53d938f23f20 100644
> --- a/hw/display/virtio-gpu-gl.c
> +++ b/hw/display/virtio-gpu-gl.c
> @@ -170,6 +170,9 @@ static void virtio_gpu_gl_device_unrealize(DeviceState *qdev)
>      if (gl->renderer_state >= RS_INITED) {
>  #if VIRGL_VERSION_MAJOR >= 1
>          qemu_bh_delete(gl->cmdq_resume_bh);
> +
> +        virtio_gpu_virgl_reset_async_fences(g);
> +        qemu_bh_delete(gl->async_fence_bh);
>  #endif
>          if (virtio_gpu_stats_enabled(g->parent_obj.conf)) {
>              timer_free(gl->print_stats);
> diff --git a/hw/display/virtio-gpu-virgl.c b/hw/display/virtio-gpu-virgl.c
> index a875c68a35e5..d59c7b6d48ed 100644
> --- a/hw/display/virtio-gpu-virgl.c
> +++ b/hw/display/virtio-gpu-virgl.c
> @@ -891,6 +891,7 @@ static void virgl_cmd_set_scanout_blob(VirtIOGPU *g,
>  void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
>                                        struct virtio_gpu_ctrl_command *cmd)
>  {
> +    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
>      bool cmd_suspended = false;
>      int ret;
>  
> @@ -992,35 +993,73 @@ void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
>  
>      trace_virtio_gpu_fence_ctrl(cmd->cmd_hdr.fence_id, cmd->cmd_hdr.type);
>  
> -    /*
> -     * Unlike other virglrenderer functions, this one returns a positive
> -     * error code.
> -     */
> -    ret = virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, 0);
> -    if (ret) {
> -        qemu_log_mask(LOG_GUEST_ERROR,
> -                      "%s: virgl_renderer_create_fence error: %s",
> -                      __func__, strerror(ret));
> +    if (gl->context_fence_enabled &&
> +        (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_INFO_RING_IDX)) {
> +        uint32_t flags = 0;
> +
> +        ret = virgl_renderer_context_create_fence(cmd->cmd_hdr.ctx_id, flags,
> +                                                  cmd->cmd_hdr.ring_idx,
> +                                                  cmd->cmd_hdr.fence_id);
> +        if (ret) {
> +            qemu_log_mask(LOG_GUEST_ERROR,
> +                          "%s: virgl_renderer_context_create_fence error: %s",
> +                          __func__, strerror(-ret));
> +        }
> +    } else {
> +        /*
> +         * Unlike other virglrenderer functions, this one returns a positive
> +         * error code.
> +         */
> +        ret = virgl_renderer_create_fence(cmd->cmd_hdr.fence_id, 0);
> +        if (ret) {
> +            qemu_log_mask(LOG_GUEST_ERROR,
> +                          "%s: virgl_renderer_create_fence error: %s",
> +                          __func__, strerror(ret));
> +        }
>      }
>  }

This needs to be gated on support from virglrenderer:

  /display/virtio-gpu-virgl.c
  ../../hw/display/virtio-gpu-virgl.c: In function ‘virtio_gpu_virgl_process_cmd’:
  ../../hw/display/virtio-gpu-virgl.c:980:15: error: implicit declaration of function ‘virgl_renderer_context_create_fence’; did you mean ‘virgl_renderer_context_create’? [-Werror=implicit-function-declaration]
    980 |         ret = virgl_renderer_context_create_fence(cmd->cmd_hdr.ctx_id, flags,
        |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        |               virgl_renderer_context_create
  ../../hw/display/virtio-gpu-virgl.c:980:15: error: nested extern declaration of ‘virgl_renderer_context_create_fence’ [-Werror=nested-externs]
  ../../hw/display/virtio-gpu-virgl.c: At top level:
  ../../hw/display/virtio-gpu-virgl.c:1088:13: error: ‘virgl_write_context_fence’ defined but not used [-Werror=unused-function]
   1088 | static void virgl_write_context_fence(void *opaque, uint32_t ctx_id,
        |             ^~~~~~~~~~~~~~~~~~~~~~~~~
  ../../hw/display/virtio-gpu-virgl.c:1002:13: error: ‘virtio_gpu_virgl_async_fence_bh’ defined but not used [-Werror=unused-function]
   1002 | static void virtio_gpu_virgl_async_fence_bh(void *opaque)
        |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  cc1: all warnings being treated as errors

>  
> -static void virgl_write_fence(void *opaque, uint32_t fence)
> +static void virtio_gpu_virgl_async_fence_bh(void *opaque)
>  {
> -    VirtIOGPU *g = opaque;
> +    QSLIST_HEAD(, virtio_gpu_virgl_context_fence) async_fenceq;
>      struct virtio_gpu_ctrl_command *cmd, *tmp;
> +    struct virtio_gpu_virgl_context_fence *f;
> +    VirtIOGPU *g = opaque;
> +    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
>  
> -    QTAILQ_FOREACH_SAFE(cmd, &g->fenceq, next, tmp) {
> -        /*
> -         * the guest can end up emitting fences out of order
> -         * so we should check all fenced cmds not just the first one.
> -         */
> -        if (cmd->cmd_hdr.fence_id > fence) {
> -            continue;
> +    QSLIST_MOVE_ATOMIC(&async_fenceq, &gl->async_fenceq);
> +
> +    while (!QSLIST_EMPTY(&async_fenceq)) {
> +        f = QSLIST_FIRST(&async_fenceq);
> +
> +        QSLIST_REMOVE_HEAD(&async_fenceq, next);
> +
> +        QTAILQ_FOREACH_SAFE(cmd, &g->fenceq, next, tmp) {
> +            /*
> +             * the guest can end up emitting fences out of order
> +             * so we should check all fenced cmds not just the first one.
> +             */
> +            if (cmd->cmd_hdr.fence_id > f->fence_id) {
> +                continue;
> +            }
> +            if (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_INFO_RING_IDX) {
> +                if (cmd->cmd_hdr.ring_idx != f->ring_idx) {
> +                    continue;
> +                }
> +                if (cmd->cmd_hdr.ctx_id != f->ctx_id) {
> +                    continue;
> +                }
> +            } else if (f->ring_idx >= 0) {
> +                /* ctx0 GL-query fences don't have ring info */
> +                continue;
> +            }
> +            virtio_gpu_ctrl_response_nodata(g, cmd, VIRTIO_GPU_RESP_OK_NODATA);
> +            QTAILQ_REMOVE(&g->fenceq, cmd, next);
> +            g_free(cmd);
>          }
> -        trace_virtio_gpu_fence_resp(cmd->cmd_hdr.fence_id);
> -        virtio_gpu_ctrl_response_nodata(g, cmd, VIRTIO_GPU_RESP_OK_NODATA);
> -        QTAILQ_REMOVE(&g->fenceq, cmd, next);
> -        g_free(cmd);
> +
> +        trace_virtio_gpu_fence_resp(f->fence_id);
> +        g_free(f);
>          g->inflight--;
>          if (virtio_gpu_stats_enabled(g->parent_obj.conf)) {
>              trace_virtio_gpu_dec_inflight_fences(g->inflight);
> @@ -1028,6 +1067,52 @@ static void virgl_write_fence(void *opaque, uint32_t fence)
>      }
>  }
>  
> +void virtio_gpu_virgl_reset_async_fences(VirtIOGPU *g)
> +{
> +    struct virtio_gpu_virgl_context_fence *f;
> +    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
> +
> +    while (!QSLIST_EMPTY(&gl->async_fenceq)) {
> +        f = QSLIST_FIRST(&gl->async_fenceq);
> +
> +        QSLIST_REMOVE_HEAD(&gl->async_fenceq, next);
> +
> +        g_free(f);
> +    }
> +}
> +
> +static void
> +virtio_gpu_virgl_push_async_fence(VirtIOGPU *g, uint32_t ctx_id,
> +                                  int64_t ring_idx, uint64_t fence_id)
> +{
> +    struct virtio_gpu_virgl_context_fence *f;
> +    VirtIOGPUGL *gl = VIRTIO_GPU_GL(g);
> +
> +    f = g_new(struct virtio_gpu_virgl_context_fence, 1);
> +    f->ctx_id = ctx_id;
> +    f->ring_idx = ring_idx;
> +    f->fence_id = fence_id;
> +
> +    QSLIST_INSERT_HEAD_ATOMIC(&gl->async_fenceq, f, next);
> +
> +    qemu_bh_schedule(gl->async_fence_bh);
> +}
> +
> +static void virgl_write_fence(void *opaque, uint32_t fence)
> +{
> +    VirtIOGPU *g = opaque;
> +
> +    virtio_gpu_virgl_push_async_fence(g, 0, -1, fence);
> +}
> +
> +static void virgl_write_context_fence(void *opaque, uint32_t ctx_id,
> +                                      uint32_t ring_idx, uint64_t fence)
> +{
> +    VirtIOGPU *g = opaque;
> +
> +    virtio_gpu_virgl_push_async_fence(g, ctx_id, ring_idx, fence);
> +}
> +
>  static virgl_renderer_gl_context
>  virgl_create_context(void *opaque, int scanout_idx,
>                       struct virgl_renderer_gl_ctx_param *params)
> @@ -1115,6 +1200,8 @@ void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g)
>          dpy_gfx_replace_surface(g->parent_obj.scanout[i].con, NULL);
>          dpy_gl_scanout_disable(g->parent_obj.scanout[i].con);
>      }
> +
> +    virtio_gpu_virgl_reset_async_fences(g);
>  }
>  
>  void virtio_gpu_virgl_reset(VirtIOGPU *g)
> @@ -1132,6 +1219,12 @@ int virtio_gpu_virgl_init(VirtIOGPU *g)
>      if (qemu_egl_display) {
>          virtio_gpu_3d_cbs.version = 4;
>          virtio_gpu_3d_cbs.get_egl_display = virgl_get_egl_display;
> +#if VIRGL_VERSION_MAJOR >= 1
> +        virtio_gpu_3d_cbs.write_context_fence = virgl_write_context_fence;
> +        flags |= VIRGL_RENDERER_ASYNC_FENCE_CB;
> +        flags |= VIRGL_RENDERER_THREAD_SYNC;
> +        gl->context_fence_enabled = true;
> +#endif
>      }
>  #endif
>  #ifdef VIRGL_RENDERER_D3D11_SHARE_TEXTURE
> @@ -1165,6 +1258,10 @@ int virtio_gpu_virgl_init(VirtIOGPU *g)
>      gl->cmdq_resume_bh = aio_bh_new(qemu_get_aio_context(),
>                                      virtio_gpu_virgl_resume_cmdq_bh,
>                                      g);
> +
> +    gl->async_fence_bh = aio_bh_new(qemu_get_aio_context(),
> +                                    virtio_gpu_virgl_async_fence_bh,
> +                                    g);
>  #endif
>  
>      return 0;
> diff --git a/include/hw/virtio/virtio-gpu.h b/include/hw/virtio/virtio-gpu.h
> index 553799b8cc72..99cc6286f473 100644
> --- a/include/hw/virtio/virtio-gpu.h
> +++ b/include/hw/virtio/virtio-gpu.h
> @@ -227,6 +227,13 @@ struct VirtIOGPUClass {
>                               Error **errp);
>  };
>  
> +struct virtio_gpu_virgl_context_fence {
> +    uint32_t ctx_id;
> +    int64_t ring_idx;
> +    uint64_t fence_id;
> +    QSLIST_ENTRY(virtio_gpu_virgl_context_fence) next;
> +};
> +
>  /* VirtIOGPUGL renderer states */
>  typedef enum {
>      RS_START,       /* starting state */
> @@ -244,6 +251,11 @@ struct VirtIOGPUGL {
>      QEMUTimer *print_stats;
>  
>      QEMUBH *cmdq_resume_bh;
> +
> +    QEMUBH *async_fence_bh;
> +    QSLIST_HEAD(, virtio_gpu_virgl_context_fence) async_fenceq;
> +
> +    bool context_fence_enabled;
>  };
>  
>  struct VhostUserGPU {
> @@ -358,5 +370,6 @@ void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g);
>  void virtio_gpu_virgl_reset(VirtIOGPU *g);
>  int virtio_gpu_virgl_init(VirtIOGPU *g);
>  GArray *virtio_gpu_virgl_get_capsets(VirtIOGPU *g);
> +void virtio_gpu_virgl_reset_async_fences(VirtIOGPU *g);
>  
>  #endif

-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro

Re: [PATCH v4 4/5] virtio-gpu: Support asynchronous fencing

[Dmitry Osipenko]

On 1/14/25 01:00, Alex Bennée wrote:
...
> This needs to be gated on support from virglrenderer:
> 
>   /display/virtio-gpu-virgl.c
>   ../../hw/display/virtio-gpu-virgl.c: In function ‘virtio_gpu_virgl_process_cmd’:
>   ../../hw/display/virtio-gpu-virgl.c:980:15: error: implicit declaration of function ‘virgl_renderer_context_create_fence’; did you mean ‘virgl_renderer_context_create’? [-Werror=implicit-function-declaration]
>     980 |         ret = virgl_renderer_context_create_fence(cmd->cmd_hdr.ctx_id, flags,
>         |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>         |               virgl_renderer_context_create
>   ../../hw/display/virtio-gpu-virgl.c:980:15: error: nested extern declaration of ‘virgl_renderer_context_create_fence’ [-Werror=nested-externs]
>   ../../hw/display/virtio-gpu-virgl.c: At top level:
>   ../../hw/display/virtio-gpu-virgl.c:1088:13: error: ‘virgl_write_context_fence’ defined but not used [-Werror=unused-function]
>    1088 | static void virgl_write_context_fence(void *opaque, uint32_t ctx_id,
>         |             ^~~~~~~~~~~~~~~~~~~~~~~~~
>   ../../hw/display/virtio-gpu-virgl.c:1002:13: error: ‘virtio_gpu_virgl_async_fence_bh’ defined but not used [-Werror=unused-function]
>    1002 | static void virtio_gpu_virgl_async_fence_bh(void *opaque)
>         |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>   cc1: all warnings being treated as errors

Good catch, will address in v5. Thanks!

-- 
Best regards,
Dmitry

[PATCH v4 5/5] virtio-gpu: Support DRM native context

[Dmitry Osipenko]

Add support for DRM native contexts to VirtIO-GPU. DRM context is enabled
using a new virtio-gpu-gl device option "drm_native_context=on".

Unlike Virgl and Venus contexts that operate on application API level,
DRM native contexts work on a kernel UAPI level. This lower level results
in a lightweight context implementations that yield better performance.

Signed-off-by: Dmitry Osipenko <dmitry.osipenko@collabora.com>
---
 docs/system/devices/virtio-gpu.rst | 11 +++++++++++
 hw/display/virtio-gpu-gl.c         |  2 ++
 hw/display/virtio-gpu-virgl.c      | 22 ++++++++++++++++++++++
 hw/display/virtio-gpu.c            | 15 +++++++++++++++
 include/hw/virtio/virtio-gpu.h     |  3 +++
 5 files changed, 53 insertions(+)

diff --git a/docs/system/devices/virtio-gpu.rst b/docs/system/devices/virtio-gpu.rst
index b7eb0fc0e727..f20c60016376 100644
--- a/docs/system/devices/virtio-gpu.rst
+++ b/docs/system/devices/virtio-gpu.rst
@@ -82,6 +82,17 @@ of virtio-gpu host memory window. This is typically between 256M and 8G.
 
 .. _venus: https://gitlab.freedesktop.org/virgl/venus-protocol/
 
+DRM native context is supported since release of `virglrenderer`_ v1.0.0
+using `drm`_ protocol.  ``DRM`` virtio-gpu capability set ("capset") requires
+host blob support (``hostmem`` and ``blob`` fields) and should be enabled
+using ``drm_native_context`` field.  The ``hostmem`` field specifies the size
+of virtio-gpu host memory window. This is typically between 256M and 8G.
+
+.. parsed-literal::
+    -device virtio-gpu-gl,hostmem=8G,blob=on,drm_native_context=on
+
+.. _drm: https://gitlab.freedesktop.org/virgl/virglrenderer/-/tree/main/src/drm
+
 virtio-gpu rutabaga
 -------------------
 
diff --git a/hw/display/virtio-gpu-gl.c b/hw/display/virtio-gpu-gl.c
index 53d938f23f20..23533fd8f35b 100644
--- a/hw/display/virtio-gpu-gl.c
+++ b/hw/display/virtio-gpu-gl.c
@@ -159,6 +159,8 @@ static Property virtio_gpu_gl_properties[] = {
                     VIRTIO_GPU_FLAG_STATS_ENABLED, false),
     DEFINE_PROP_BIT("venus", VirtIOGPU, parent_obj.conf.flags,
                     VIRTIO_GPU_FLAG_VENUS_ENABLED, false),
+    DEFINE_PROP_BIT("drm_native_context", VirtIOGPU, parent_obj.conf.flags,
+                    VIRTIO_GPU_FLAG_DRM_ENABLED, false),
     DEFINE_PROP_END_OF_LIST(),
 };
 
diff --git a/hw/display/virtio-gpu-virgl.c b/hw/display/virtio-gpu-virgl.c
index d59c7b6d48ed..5090dd717184 100644
--- a/hw/display/virtio-gpu-virgl.c
+++ b/hw/display/virtio-gpu-virgl.c
@@ -1236,6 +1236,19 @@ int virtio_gpu_virgl_init(VirtIOGPU *g)
     if (virtio_gpu_venus_enabled(g->parent_obj.conf)) {
         flags |= VIRGL_RENDERER_VENUS | VIRGL_RENDERER_RENDER_SERVER;
     }
+    if (virtio_gpu_drm_enabled(g->parent_obj.conf)) {
+        flags |= VIRGL_RENDERER_DRM;
+
+        if (!gl->context_fence_enabled) {
+            /*
+             * Virglrenderer skips enabling DRM context support without
+             * enabled async-fence feature. VirtIO-GPU will initialize
+             * successfully, but DRM context won't be available in guest.
+             */
+            error_report("DRM native context requires EGL display");
+            return -EINVAL;
+        }
+    }
 #endif
 
     ret = virgl_renderer_init(g, flags, &virtio_gpu_3d_cbs);
@@ -1298,5 +1311,14 @@ GArray *virtio_gpu_virgl_get_capsets(VirtIOGPU *g)
         }
     }
 
+    if (virtio_gpu_drm_enabled(g->parent_obj.conf)) {
+        virgl_renderer_get_cap_set(VIRTIO_GPU_CAPSET_DRM,
+                                   &capset_max_ver,
+                                   &capset_max_size);
+        if (capset_max_size) {
+            virtio_gpu_virgl_add_capset(capset_ids, VIRTIO_GPU_CAPSET_DRM);
+        }
+    }
+
     return capset_ids;
 }
diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c
index c0570ef8565a..c1acafe6246b 100644
--- a/hw/display/virtio-gpu.c
+++ b/hw/display/virtio-gpu.c
@@ -1492,6 +1492,21 @@ void virtio_gpu_device_realize(DeviceState *qdev, Error **errp)
 #endif
     }
 
+    if (virtio_gpu_drm_enabled(g->parent_obj.conf)) {
+#ifdef VIRGL_VERSION_MAJOR
+    #if VIRGL_VERSION_MAJOR >= 1
+        if (!virtio_gpu_blob_enabled(g->parent_obj.conf) ||
+            !virtio_gpu_hostmem_enabled(g->parent_obj.conf)) {
+            error_setg(errp, "drm requires enabled blob and hostmem options");
+            return;
+        }
+    #else
+        error_setg(errp, "old virglrenderer, drm unsupported");
+        return;
+    #endif
+#endif
+    }
+
     if (!virtio_gpu_base_device_realize(qdev,
                                         virtio_gpu_handle_ctrl_cb,
                                         virtio_gpu_handle_cursor_cb,
diff --git a/include/hw/virtio/virtio-gpu.h b/include/hw/virtio/virtio-gpu.h
index 99cc6286f473..f1799fcb6eee 100644
--- a/include/hw/virtio/virtio-gpu.h
+++ b/include/hw/virtio/virtio-gpu.h
@@ -98,6 +98,7 @@ enum virtio_gpu_base_conf_flags {
     VIRTIO_GPU_FLAG_CONTEXT_INIT_ENABLED,
     VIRTIO_GPU_FLAG_RUTABAGA_ENABLED,
     VIRTIO_GPU_FLAG_VENUS_ENABLED,
+    VIRTIO_GPU_FLAG_DRM_ENABLED,
 };
 
 #define virtio_gpu_virgl_enabled(_cfg) \
@@ -118,6 +119,8 @@ enum virtio_gpu_base_conf_flags {
     (_cfg.hostmem > 0)
 #define virtio_gpu_venus_enabled(_cfg) \
     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_VENUS_ENABLED))
+#define virtio_gpu_drm_enabled(_cfg) \
+    (_cfg.flags & (1 << VIRTIO_GPU_FLAG_DRM_ENABLED))
 
 struct virtio_gpu_base_conf {
     uint32_t max_outputs;
-- 
2.47.0

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Akihiko Odaki]

On 2024/11/11 7:18, Dmitry Osipenko wrote:
> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
> 
> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
> DRM native context [1] mediates lower level kernel driver UAPI, which
> reflects in a less CPU overhead and less/simpler code needed to support it.
> DRM context consists of a host and guest parts that have to be implemented
> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
> a real/native host GPU device for GL/VK applications.
> 
> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
> 
> Today there are four known DRM native context drivers existing in a wild:
> 
>    - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>    - AMDGPU, mostly merged into upstreams
>    - Intel (i915), merge requests are opened
>    - Asahi (Apple SoC GPUs), WIP status
> 
> 
> # How to try out DRM context:
> 
> 1. DRM context uses host blobs and requires latest developer version
> of Linux kernel [2] that has necessary KVM fixes.
> 
> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
> 
> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
> and AMDGPU native contexts. For Intel use patches [3].
> 
> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
> 
> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
> Mesa patches [4], for Intel [5].
> 
> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
> 
> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>     running Xorg in guest.
> 
> [6] https://lore.kernel.org/dri-devel/20241020224725.179937-1-dmitry.osipenko@collabora.com/
> 
> Example Qemu cmdline that enables DRM context:
> 
>    qemu-system-x86_64 -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
>        -machine q35,accel=kvm,memory-backend=mem1 \
>        -object memory-backend-memfd,id=mem1,size=8G -m 8G
> 
> 
> # Note about known performance problem in Qemu:
> 
> DRM contexts are mapping host blobs extensively and these mapping
> operations work slowly in Qemu. Exact reason is unknown. Mappings work
> fast on Crosvm For DRM contexts this problem is more visible than for
> Venus/Virgl.
> 
> Changelog:
> 
> v4: - Improved SDL2/dmabuf patch by reusing existing Meson X11 config
>        option, better handling EGL error and extending comment telling
>        that it's safe to enable SDL2 EGL preference hint. As was suggested
>        by Akihiko Odaki.
> 
>      - Replaced another QSLIST_FOREACH_SAFE with QSLIST_EMPTY+FIRST in
>        the async-fencing patch for more consistency of the code. As was
>        suggested by Akihiko Odaki.
> 
>      - Added missing braces around if-statement that was spotted by
>        Alex Bennée.
> 
>      - Renamed 'drm=on' option of virtio-gpu-gl device to
>        'drm_native_context=on' for more clarity as was suggested by
>        Alex Bennée. Haven't added added new context-type option that
>        was also proposed by Alex, might do it with a separate patch.
>        This context-type option will duplicate and depecate existing
>        options, but in a longer run likely will be worthwhile adding
>        it.
> 
>      - Dropped Linux headers-update patch as headers has been updated
>        in the staging tree.
> 
> v3: - Improved EGL presence-check code on X11 systems for the SDL2
>        hint that prefers EGL over GLX by using better ifdefs and checking
>        Xlib presence at a build time to avoid build failure if lib SDL2
>        and system are configured with a disabled X11 support. Also added
>        clarifying comment telling that X11 hint doesn't affect Wayland
>        systems. Suggested by Akihiko Odaki.
> 
>      - Corrected strerror(err) that used negative error where it should
>        be positive and vice versa that was caught by Akihiko Odaki. Added
>        clarifying comment for the case where we get positive error code
>        from virglrenderer that differs from other virglrenderer API functions.
> 
>      - Improved QSLIST usage by dropping mutex protecting the async fence
>        list and using atomic variant of QSLIST helpers instead. Switched away
>        from using FOREACH helper to improve readability of the code, showing
>        that we don't precess list in unoptimal way. Like was suggested by
>        Akihiko Odaki.
> 
>      - Updated patchset base to Venus v18.
> 
> v2: - Updated SDL2-dmabuf patch by making use of error_report() and
>        checking presense of X11+EGL in the system before making SDL2
>        to prefer EGL backend over GLX, suggested by Akihiko Odaki.
> 
>      - Improved SDL2's dmabuf-presence check that wasn't done properly
>        in v1, where EGL was set up only after first console was fully
>        inited, and thus, SDL's display .has_dmabuf callback didn't work
>        for the first console. Now dmabuf support status is pre-checked
>        before console is registered.
> 
>      - Updated commit description of the patch that fixes SDL2's context
>        switching logic with a more detailed explanation of the problem.
>        Suggested by Akihiko Odaki.
> 
>      - Corrected rebase typo in the async-fencing patch and switched
>        async-fencing to use a sigle-linked list instead of the double,
>        as was suggested by Akihiko Odaki.
> 
>      - Replaced "=true" with "=on" in the DRM native context documentation
>        example and made virtio_gpu_virgl_init() to fail with a error message
>        if DRM context can't be initialized instead of giving a warning
>        message, as was suggested by Akihiko Odaki.
> 
>      - Added patchew's dependecy tag to the cover letter as was suggested by
>        Akihiko Odaki.
> 
> Dmitry Osipenko (4):
>    ui/sdl2: Restore original context after new context creation
>    virtio-gpu: Handle virgl fence creation errors
>    virtio-gpu: Support asynchronous fencing
>    virtio-gpu: Support DRM native context
> 
> Pierre-Eric Pelloux-Prayer (1):
>    ui/sdl2: Implement dpy dmabuf functions
> 
>   docs/system/devices/virtio-gpu.rst |  11 ++
>   hw/display/virtio-gpu-gl.c         |   5 +
>   hw/display/virtio-gpu-virgl.c      | 158 ++++++++++++++++++++++++++---
>   hw/display/virtio-gpu.c            |  15 +++
>   include/hw/virtio/virtio-gpu.h     |  16 +++
>   include/ui/sdl2.h                  |   7 ++
>   meson.build                        |   6 +-
>   ui/sdl2-gl.c                       |  67 ++++++++++++
>   ui/sdl2.c                          |  42 ++++++++
>   9 files changed, 309 insertions(+), 18 deletions(-)
> 

Now this series looks good to me.

Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com>

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Michael S. Tsirkin]

On Mon, Nov 11, 2024 at 01:18:32AM +0300, Dmitry Osipenko wrote:
> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
> 
> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
> DRM native context [1] mediates lower level kernel driver UAPI, which
> reflects in a less CPU overhead and less/simpler code needed to support it.
> DRM context consists of a host and guest parts that have to be implemented
> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
> a real/native host GPU device for GL/VK applications.
> 
> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
> 
> Today there are four known DRM native context drivers existing in a wild:
> 
>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>   - AMDGPU, mostly merged into upstreams
>   - Intel (i915), merge requests are opened
>   - Asahi (Apple SoC GPUs), WIP status

Took a quick look, looks ok

Acked-by: Michael S. Tsirkin <mst@redhat.com>

Gerd, you gonnu pick this up?

Dmitry, if you will post a rebase, I can apply too.

> 
> # How to try out DRM context:
> 
> 1. DRM context uses host blobs and requires latest developer version 
> of Linux kernel [2] that has necessary KVM fixes.
> 
> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
> 
> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
> and AMDGPU native contexts. For Intel use patches [3].
> 
> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
> 
> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
> Mesa patches [4], for Intel [5].
> 
> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
> 
> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>    running Xorg in guest.
> 
> [6] https://lore.kernel.org/dri-devel/20241020224725.179937-1-dmitry.osipenko@collabora.com/
> 
> Example Qemu cmdline that enables DRM context:
> 
>   qemu-system-x86_64 -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
>       -machine q35,accel=kvm,memory-backend=mem1 \
>       -object memory-backend-memfd,id=mem1,size=8G -m 8G
> 
> 
> # Note about known performance problem in Qemu:
> 
> DRM contexts are mapping host blobs extensively and these mapping
> operations work slowly in Qemu. Exact reason is unknown. Mappings work
> fast on Crosvm For DRM contexts this problem is more visible than for
> Venus/Virgl.
> 
> Changelog:
> 
> v4: - Improved SDL2/dmabuf patch by reusing existing Meson X11 config 
>       option, better handling EGL error and extending comment telling
>       that it's safe to enable SDL2 EGL preference hint. As was suggested
>       by Akihiko Odaki.
> 
>     - Replaced another QSLIST_FOREACH_SAFE with QSLIST_EMPTY+FIRST in
>       the async-fencing patch for more consistency of the code. As was
>       suggested by Akihiko Odaki.
> 
>     - Added missing braces around if-statement that was spotted by
>       Alex Bennée.
> 
>     - Renamed 'drm=on' option of virtio-gpu-gl device to 
>       'drm_native_context=on' for more clarity as was suggested by 
>       Alex Bennée. Haven't added added new context-type option that 
>       was also proposed by Alex, might do it with a separate patch.
>       This context-type option will duplicate and depecate existing
>       options, but in a longer run likely will be worthwhile adding
>       it.
> 
>     - Dropped Linux headers-update patch as headers has been updated
>       in the staging tree.
> 
> v3: - Improved EGL presence-check code on X11 systems for the SDL2
>       hint that prefers EGL over GLX by using better ifdefs and checking
>       Xlib presence at a build time to avoid build failure if lib SDL2
>       and system are configured with a disabled X11 support. Also added
>       clarifying comment telling that X11 hint doesn't affect Wayland
>       systems. Suggested by Akihiko Odaki.
> 
>     - Corrected strerror(err) that used negative error where it should
>       be positive and vice versa that was caught by Akihiko Odaki. Added
>       clarifying comment for the case where we get positive error code
>       from virglrenderer that differs from other virglrenderer API functions.
> 
>     - Improved QSLIST usage by dropping mutex protecting the async fence
>       list and using atomic variant of QSLIST helpers instead. Switched away
>       from using FOREACH helper to improve readability of the code, showing
>       that we don't precess list in unoptimal way. Like was suggested by
>       Akihiko Odaki.
> 
>     - Updated patchset base to Venus v18.
> 
> v2: - Updated SDL2-dmabuf patch by making use of error_report() and
>       checking presense of X11+EGL in the system before making SDL2
>       to prefer EGL backend over GLX, suggested by Akihiko Odaki.
> 
>     - Improved SDL2's dmabuf-presence check that wasn't done properly
>       in v1, where EGL was set up only after first console was fully
>       inited, and thus, SDL's display .has_dmabuf callback didn't work
>       for the first console. Now dmabuf support status is pre-checked
>       before console is registered.
> 
>     - Updated commit description of the patch that fixes SDL2's context
>       switching logic with a more detailed explanation of the problem.
>       Suggested by Akihiko Odaki.
> 
>     - Corrected rebase typo in the async-fencing patch and switched
>       async-fencing to use a sigle-linked list instead of the double,
>       as was suggested by Akihiko Odaki.
> 
>     - Replaced "=true" with "=on" in the DRM native context documentation
>       example and made virtio_gpu_virgl_init() to fail with a error message
>       if DRM context can't be initialized instead of giving a warning
>       message, as was suggested by Akihiko Odaki.
> 
>     - Added patchew's dependecy tag to the cover letter as was suggested by
>       Akihiko Odaki.
> 
> Dmitry Osipenko (4):
>   ui/sdl2: Restore original context after new context creation
>   virtio-gpu: Handle virgl fence creation errors
>   virtio-gpu: Support asynchronous fencing
>   virtio-gpu: Support DRM native context
> 
> Pierre-Eric Pelloux-Prayer (1):
>   ui/sdl2: Implement dpy dmabuf functions
> 
>  docs/system/devices/virtio-gpu.rst |  11 ++
>  hw/display/virtio-gpu-gl.c         |   5 +
>  hw/display/virtio-gpu-virgl.c      | 158 ++++++++++++++++++++++++++---
>  hw/display/virtio-gpu.c            |  15 +++
>  include/hw/virtio/virtio-gpu.h     |  16 +++
>  include/ui/sdl2.h                  |   7 ++
>  meson.build                        |   6 +-
>  ui/sdl2-gl.c                       |  67 ++++++++++++
>  ui/sdl2.c                          |  42 ++++++++
>  9 files changed, 309 insertions(+), 18 deletions(-)
> 
> -- 
> 2.47.0

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Dmitry Osipenko]

On 1/8/25 16:14, Michael S. Tsirkin wrote:
> On Mon, Nov 11, 2024 at 01:18:32AM +0300, Dmitry Osipenko wrote:
>> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>>
>> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
>> DRM native context [1] mediates lower level kernel driver UAPI, which
>> reflects in a less CPU overhead and less/simpler code needed to support it.
>> DRM context consists of a host and guest parts that have to be implemented
>> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
>> a real/native host GPU device for GL/VK applications.
>>
>> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>>
>> Today there are four known DRM native context drivers existing in a wild:
>>
>>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>>   - AMDGPU, mostly merged into upstreams
>>   - Intel (i915), merge requests are opened
>>   - Asahi (Apple SoC GPUs), WIP status
> 
> Took a quick look, looks ok
> 
> Acked-by: Michael S. Tsirkin <mst@redhat.com>
> 
> Gerd, you gonnu pick this up?
> 
> Dmitry, if you will post a rebase, I can apply too.

Thanks! The plan was that Alex will test this patchset on his setup and
then either he or you will apply it. Will post the rebased version too,
there is a minor merge conflict with the latest Qemu tree now.

-- 
Best regards,
Dmitry

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Alex Bennée]

Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:

> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>
> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
> DRM native context [1] mediates lower level kernel driver UAPI, which
> reflects in a less CPU overhead and less/simpler code needed to support it.
> DRM context consists of a host and guest parts that have to be implemented
> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
> a real/native host GPU device for GL/VK applications.
>
> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>
> Today there are four known DRM native context drivers existing in a wild:
>
>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>   - AMDGPU, mostly merged into upstreams
>   - Intel (i915), merge requests are opened
>   - Asahi (Apple SoC GPUs), WIP status
>
>
> # How to try out DRM context:
>
> 1. DRM context uses host blobs and requires latest developer version 
> of Linux kernel [2] that has necessary KVM fixes.
>
> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
>
> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
> and AMDGPU native contexts. For Intel use patches [3].
>
> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
>

Can we detect if virglrenderer has support at build time?

  [drm] pci: virtio-gpu-pci detected at 0000:00:02.0
  [drm] Host memory window: 0x8000000000 +0x100000000
  [drm] features: +virgl +edid +resource_blob +host_visible
  [drm] features: +context_init
  [drm] number of scanouts: 1
  [drm] number of cap sets: 2
  DRM native context support was not enabled in virglrenderer
  qemu: virgl could not be initialized: -1
  [drm:virtio_gpu_init] *ERROR* timed out waiting for cap set 0

is a poor failure mode at runtime.

> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
> Mesa patches [4], for Intel [5].
>
> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
>
> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>    running Xorg in guest.
>
> [6] https://lore.kernel.org/dri-devel/20241020224725.179937-1-dmitry.osipenko@collabora.com/
>
> Example Qemu cmdline that enables DRM context:
>
>   qemu-system-x86_64 -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
>       -machine q35,accel=kvm,memory-backend=mem1 \
>       -object memory-backend-memfd,id=mem1,size=8G -m 8G
>
>
> # Note about known performance problem in Qemu:
>
> DRM contexts are mapping host blobs extensively and these mapping
> operations work slowly in Qemu. Exact reason is unknown. Mappings work
> fast on Crosvm For DRM contexts this problem is more visible than for
> Venus/Virgl.
>
> Changelog:
>
> v4: - Improved SDL2/dmabuf patch by reusing existing Meson X11 config 
>       option, better handling EGL error and extending comment telling
>       that it's safe to enable SDL2 EGL preference hint. As was suggested
>       by Akihiko Odaki.
>
>     - Replaced another QSLIST_FOREACH_SAFE with QSLIST_EMPTY+FIRST in
>       the async-fencing patch for more consistency of the code. As was
>       suggested by Akihiko Odaki.
>
>     - Added missing braces around if-statement that was spotted by
>       Alex Bennée.
>
>     - Renamed 'drm=on' option of virtio-gpu-gl device to 
>       'drm_native_context=on' for more clarity as was suggested by 
>       Alex Bennée. Haven't added added new context-type option that 
>       was also proposed by Alex, might do it with a separate patch.
>       This context-type option will duplicate and depecate existing
>       options, but in a longer run likely will be worthwhile adding
>       it.
>
>     - Dropped Linux headers-update patch as headers has been updated
>       in the staging tree.
>
> v3: - Improved EGL presence-check code on X11 systems for the SDL2
>       hint that prefers EGL over GLX by using better ifdefs and checking
>       Xlib presence at a build time to avoid build failure if lib SDL2
>       and system are configured with a disabled X11 support. Also added
>       clarifying comment telling that X11 hint doesn't affect Wayland
>       systems. Suggested by Akihiko Odaki.
>
>     - Corrected strerror(err) that used negative error where it should
>       be positive and vice versa that was caught by Akihiko Odaki. Added
>       clarifying comment for the case where we get positive error code
>       from virglrenderer that differs from other virglrenderer API functions.
>
>     - Improved QSLIST usage by dropping mutex protecting the async fence
>       list and using atomic variant of QSLIST helpers instead. Switched away
>       from using FOREACH helper to improve readability of the code, showing
>       that we don't precess list in unoptimal way. Like was suggested by
>       Akihiko Odaki.
>
>     - Updated patchset base to Venus v18.
>
> v2: - Updated SDL2-dmabuf patch by making use of error_report() and
>       checking presense of X11+EGL in the system before making SDL2
>       to prefer EGL backend over GLX, suggested by Akihiko Odaki.
>
>     - Improved SDL2's dmabuf-presence check that wasn't done properly
>       in v1, where EGL was set up only after first console was fully
>       inited, and thus, SDL's display .has_dmabuf callback didn't work
>       for the first console. Now dmabuf support status is pre-checked
>       before console is registered.
>
>     - Updated commit description of the patch that fixes SDL2's context
>       switching logic with a more detailed explanation of the problem.
>       Suggested by Akihiko Odaki.
>
>     - Corrected rebase typo in the async-fencing patch and switched
>       async-fencing to use a sigle-linked list instead of the double,
>       as was suggested by Akihiko Odaki.
>
>     - Replaced "=true" with "=on" in the DRM native context documentation
>       example and made virtio_gpu_virgl_init() to fail with a error message
>       if DRM context can't be initialized instead of giving a warning
>       message, as was suggested by Akihiko Odaki.
>
>     - Added patchew's dependecy tag to the cover letter as was suggested by
>       Akihiko Odaki.
>
> Dmitry Osipenko (4):
>   ui/sdl2: Restore original context after new context creation
>   virtio-gpu: Handle virgl fence creation errors
>   virtio-gpu: Support asynchronous fencing
>   virtio-gpu: Support DRM native context
>
> Pierre-Eric Pelloux-Prayer (1):
>   ui/sdl2: Implement dpy dmabuf functions
>
>  docs/system/devices/virtio-gpu.rst |  11 ++
>  hw/display/virtio-gpu-gl.c         |   5 +
>  hw/display/virtio-gpu-virgl.c      | 158 ++++++++++++++++++++++++++---
>  hw/display/virtio-gpu.c            |  15 +++
>  include/hw/virtio/virtio-gpu.h     |  16 +++
>  include/ui/sdl2.h                  |   7 ++
>  meson.build                        |   6 +-
>  ui/sdl2-gl.c                       |  67 ++++++++++++
>  ui/sdl2.c                          |  42 ++++++++
>  9 files changed, 309 insertions(+), 18 deletions(-)

-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Dmitry Osipenko]

On 1/10/25 15:16, Alex Bennée wrote:
> Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:
> 
>> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>>
>> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
>> DRM native context [1] mediates lower level kernel driver UAPI, which
>> reflects in a less CPU overhead and less/simpler code needed to support it.
>> DRM context consists of a host and guest parts that have to be implemented
>> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
>> a real/native host GPU device for GL/VK applications.
>>
>> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>>
>> Today there are four known DRM native context drivers existing in a wild:
>>
>>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>>   - AMDGPU, mostly merged into upstreams
>>   - Intel (i915), merge requests are opened
>>   - Asahi (Apple SoC GPUs), WIP status
>>
>>
>> # How to try out DRM context:
>>
>> 1. DRM context uses host blobs and requires latest developer version 
>> of Linux kernel [2] that has necessary KVM fixes.
>>
>> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
>>
>> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
>> and AMDGPU native contexts. For Intel use patches [3].
>>
>> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
>>
> 
> Can we detect if virglrenderer has support at build time?
> 
>   [drm] pci: virtio-gpu-pci detected at 0000:00:02.0
>   [drm] Host memory window: 0x8000000000 +0x100000000
>   [drm] features: +virgl +edid +resource_blob +host_visible
>   [drm] features: +context_init
>   [drm] number of scanouts: 1
>   [drm] number of cap sets: 2
>   DRM native context support was not enabled in virglrenderer
>   qemu: virgl could not be initialized: -1
>   [drm:virtio_gpu_init] *ERROR* timed out waiting for cap set 0
> 
> is a poor failure mode at runtime.

It's not possible to check at a build time whether virglrenderer is
built with DRM support, there are no flags for that. There is no
build-time dependency on DRM for Qemu, hence such flags were never
needed. You can rebuild virglrenderer with enabled DRM support,
rebuilding Qemu isn't needed in that case.

In general, it should be up to a package maintainer to enable required
virglrenderer features. It's more a Qemu's design problem that it can't
initialize virglrenderer earlier, before starting VM, IMO. Overall,
don't see a problem to address here.

-- 
Best regards,
Dmitry

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Alex Bennée]

Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:

> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>
> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
> DRM native context [1] mediates lower level kernel driver UAPI, which
> reflects in a less CPU overhead and less/simpler code needed to support it.
> DRM context consists of a host and guest parts that have to be implemented
> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
> a real/native host GPU device for GL/VK applications.
>
> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>
> Today there are four known DRM native context drivers existing in a wild:
>
>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>   - AMDGPU, mostly merged into upstreams
>   - Intel (i915), merge requests are opened
>   - Asahi (Apple SoC GPUs), WIP status
>
>
> # How to try out DRM context:
>
> 1. DRM context uses host blobs and requires latest developer version 
> of Linux kernel [2] that has necessary KVM fixes.
>
> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
>
> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
> and AMDGPU native contexts. For Intel use patches [3].
>
> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
>
> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
> Mesa patches [4], for Intel [5].
>
> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
>
> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>    running Xorg in guest.

Have you seen this failure before:

  ➜  ./qemu-system-x86_64 \
                    -machine type=q35,accel=kvm,kernel-irqchip=split \
                    -cpu host \
                    -smp 4 \
                    -device virtio-net-pci,netdev=unet \
                    -netdev user,id=unet,hostfwd=tcp::2222-:22 \
                    -drive driver=qcow2,file=trixie-x86_64.qcow2 \
                    -serial mon:stdio \
                    -m 24G \
                    -object memory-backend-memfd,id=mem,size=24G,share=on \
                    -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
                    -display gtk,gl=on,show-cursor=on \
                    -device virtio-tablet-pci -device virtio-keyboard-pci \
                    -d guest_errors,unimp,trace:virtio_gpu_cmd_get_display_info
  vmport: unknown command 56
  virtio_gpu_cmd_get_display_info 
  context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
  vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
  context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
  vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
  context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
  vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
  error: kvm run failed Bad address
  RAX=00007fb1e8fbefa0 RBX=00005649f1f4fb34 RCX=00000000fffffffc RDX=0000000000000004
  RSI=0000000000000000 RDI=0000000000100000 RBP=00005649f2063710 RSP=00007ffe221807d0
  R8 =0000000000000003 R9 =00007ffe22180808 R10=0000000000000302 R11=0000000000000000
  R12=0000000000000001 R13=00007ffe22180800 R14=0000000000000002 R15=0000000000000001
  RIP=00007fb20bfc3f7f RFL=00010202 [-------] CPL=3 II=0 A20=1 SMM=0 HLT=0
  ES =0000 0000000000000000 ffffffff 00c00000
  CS =0033 0000000000000000 ffffffff 00a0fb00 DPL=3 CS64 [-RA]
  SS =002b 0000000000000000 ffffffff 00c0f300 DPL=3 DS   [-WA]
  DS =0000 0000000000000000 ffffffff 00c00000
  FS =0000 00007fb203aace80 ffffffff 00c00000
  GS =0000 0000000000000000 ffffffff 00c00000
  LDT=0000 0000000000000000 ffffffff 00c00000
  TR =0040 fffffe67eec85000 00004087 00008b00 DPL=0 TSS64-busy
  GDT=     fffffe67eec83000 0000007f
  IDT=     fffffe0000000000 00000fff
  CR0=80050033 CR2=00005646b7f7d018 CR3=000000012852a000 CR4=00750ef0
  DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000 
  DR6=00000000ffff0ff0 DR7=0000000000000400
  EFER=0000000000000d01
  Code=f3 0f 11 40 58 f3 0f 10 43 08 f3 0f 11 40 5c f3 0f 10 43 0c <f3> 0f 11 78 64 f3 0f 11 50 68 f3 44 0f 11 40 6c f3 0f 11 48 70 f3 0f 11 60 74 f3 0f 11 40

-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Dmitry Osipenko]

On 1/10/25 16:38, Alex Bennée wrote:
> Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:
> 
>> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>>
>> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
>> DRM native context [1] mediates lower level kernel driver UAPI, which
>> reflects in a less CPU overhead and less/simpler code needed to support it.
>> DRM context consists of a host and guest parts that have to be implemented
>> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
>> a real/native host GPU device for GL/VK applications.
>>
>> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>>
>> Today there are four known DRM native context drivers existing in a wild:
>>
>>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>>   - AMDGPU, mostly merged into upstreams
>>   - Intel (i915), merge requests are opened
>>   - Asahi (Apple SoC GPUs), WIP status
>>
>>
>> # How to try out DRM context:
>>
>> 1. DRM context uses host blobs and requires latest developer version 
>> of Linux kernel [2] that has necessary KVM fixes.
>>
>> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
>>
>> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
>> and AMDGPU native contexts. For Intel use patches [3].
>>
>> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
>>
>> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
>> Mesa patches [4], for Intel [5].
>>
>> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
>> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
>>
>> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>>    running Xorg in guest.
> 
> Have you seen this failure before:
> 
>   ➜  ./qemu-system-x86_64 \
>                     -machine type=q35,accel=kvm,kernel-irqchip=split \
>                     -cpu host \
>                     -smp 4 \
>                     -device virtio-net-pci,netdev=unet \
>                     -netdev user,id=unet,hostfwd=tcp::2222-:22 \
>                     -drive driver=qcow2,file=trixie-x86_64.qcow2 \
>                     -serial mon:stdio \
>                     -m 24G \
>                     -object memory-backend-memfd,id=mem,size=24G,share=on \
>                     -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
>                     -display gtk,gl=on,show-cursor=on \
>                     -device virtio-tablet-pci -device virtio-keyboard-pci \
>                     -d guest_errors,unimp,trace:virtio_gpu_cmd_get_display_info
>   vmport: unknown command 56
>   virtio_gpu_cmd_get_display_info 
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   error: kvm run failed Bad address
>   RAX=00007fb1e8fbefa0 RBX=00005649f1f4fb34 RCX=00000000fffffffc RDX=0000000000000004
>   RSI=0000000000000000 RDI=0000000000100000 RBP=00005649f2063710 RSP=00007ffe221807d0
>   R8 =0000000000000003 R9 =00007ffe22180808 R10=0000000000000302 R11=0000000000000000
>   R12=0000000000000001 R13=00007ffe22180800 R14=0000000000000002 R15=0000000000000001
>   RIP=00007fb20bfc3f7f RFL=00010202 [-------] CPL=3 II=0 A20=1 SMM=0 HLT=0
>   ES =0000 0000000000000000 ffffffff 00c00000
>   CS =0033 0000000000000000 ffffffff 00a0fb00 DPL=3 CS64 [-RA]
>   SS =002b 0000000000000000 ffffffff 00c0f300 DPL=3 DS   [-WA]
>   DS =0000 0000000000000000 ffffffff 00c00000
>   FS =0000 00007fb203aace80 ffffffff 00c00000
>   GS =0000 0000000000000000 ffffffff 00c00000
>   LDT=0000 0000000000000000 ffffffff 00c00000
>   TR =0040 fffffe67eec85000 00004087 00008b00 DPL=0 TSS64-busy
>   GDT=     fffffe67eec83000 0000007f
>   IDT=     fffffe0000000000 00000fff
>   CR0=80050033 CR2=00005646b7f7d018 CR3=000000012852a000 CR4=00750ef0
>   DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000 
>   DR6=00000000ffff0ff0 DR7=0000000000000400
>   EFER=0000000000000d01
>   Code=f3 0f 11 40 58 f3 0f 10 43 08 f3 0f 11 40 5c f3 0f 10 43 0c <f3> 0f 11 78 64 f3 0f 11 50 68 f3 44 0f 11 40 6c f3 0f 11 48 70 f3 0f 11 60 74 f3 0f 11 40
> 

The Qemu args look sane.

Don't remember ever seeing "vmport: unknown command 56" messages.

The CREATE_VIDEO_BUFFER errors are fine, VAAPI is disabled by default in
virglrenderer.

The "kvm run failed Bad address" will happen if you're running older
pre-6.13 host kernel that don't have KVM patches. Any chance that you
booted with a stock distro kernel by accident?

-- 
Best regards,
Dmitry

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Alex Bennée]

Alex Bennée <alex.bennee@linaro.org> writes:

> Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:
>
>> This patchset adds DRM native context support to VirtIO-GPU on Qemu.
>>
>> Contarary to Virgl and Venus contexts which mediate high level GFX APIs,
>> DRM native context [1] mediates lower level kernel driver UAPI, which
>> reflects in a less CPU overhead and less/simpler code needed to support it.
>> DRM context consists of a host and guest parts that have to be implemented
>> for each GPU driver. On a guest side, DRM context presents a virtual GPU as
>> a real/native host GPU device for GL/VK applications.
>>
>> [1] https://www.youtube.com/watch?v=9sFP_yddLLQ
>>
>> Today there are four known DRM native context drivers existing in a wild:
>>
>>   - Freedreno (Qualcomm SoC GPUs), completely upstreamed
>>   - AMDGPU, mostly merged into upstreams
>>   - Intel (i915), merge requests are opened
>>   - Asahi (Apple SoC GPUs), WIP status
>>
>>
>> # How to try out DRM context:
>>
>> 1. DRM context uses host blobs and requires latest developer version 
>> of Linux kernel [2] that has necessary KVM fixes.
>>
>> [2] https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/
>>
>> 2. Use latest libvirglrenderer from upstream git/main for Freedreno
>> and AMDGPU native contexts. For Intel use patches [3].
>>
>> [3] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1384
>>
>> 3. On guest, use latest Mesa version for Freedreno. For AMDGPU use
>> Mesa patches [4], for Intel [5].
>>
>> [4] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21658
>> [5] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29870
>>
>> 4. On guest, use latest Linux kernel v6.6+. Apply patch [6] if you're
>>    running Xorg in guest.
>
> Have you seen this failure before:
>
>   ➜  ./qemu-system-x86_64 \
>                     -machine type=q35,accel=kvm,kernel-irqchip=split \
>                     -cpu host \
>                     -smp 4 \
>                     -device virtio-net-pci,netdev=unet \
>                     -netdev user,id=unet,hostfwd=tcp::2222-:22 \
>                     -drive driver=qcow2,file=trixie-x86_64.qcow2 \
>                     -serial mon:stdio \
>                     -m 24G \
>                     -object memory-backend-memfd,id=mem,size=24G,share=on \
>                     -device virtio-vga-gl,hostmem=4G,blob=on,drm_native_context=on \
>                     -display gtk,gl=on,show-cursor=on \
>                     -device virtio-tablet-pci -device virtio-keyboard-pci \
>                     -d guest_errors,unimp,trace:virtio_gpu_cmd_get_display_info
>   vmport: unknown command 56
>   virtio_gpu_cmd_get_display_info 
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   context 4 failed to dispatch CREATE_VIDEO_BUFFER: 22
>   vrend_decode_ctx_submit_cmd: context error reported 4 "gst-plugin-scan" Illegal command buffer 327735
>   error: kvm run failed Bad address
>   RAX=00007fb1e8fbefa0 RBX=00005649f1f4fb34 RCX=00000000fffffffc RDX=0000000000000004
>   RSI=0000000000000000 RDI=0000000000100000 RBP=00005649f2063710 RSP=00007ffe221807d0
>   R8 =0000000000000003 R9 =00007ffe22180808 R10=0000000000000302 R11=0000000000000000
>   R12=0000000000000001 R13=00007ffe22180800 R14=0000000000000002 R15=0000000000000001
>   RIP=00007fb20bfc3f7f RFL=00010202 [-------] CPL=3 II=0 A20=1 SMM=0 HLT=0
>   ES =0000 0000000000000000 ffffffff 00c00000
>   CS =0033 0000000000000000 ffffffff 00a0fb00 DPL=3 CS64 [-RA]
>   SS =002b 0000000000000000 ffffffff 00c0f300 DPL=3 DS   [-WA]
>   DS =0000 0000000000000000 ffffffff 00c00000
>   FS =0000 00007fb203aace80 ffffffff 00c00000
>   GS =0000 0000000000000000 ffffffff 00c00000
>   LDT=0000 0000000000000000 ffffffff 00c00000
>   TR =0040 fffffe67eec85000 00004087 00008b00 DPL=0 TSS64-busy
>   GDT=     fffffe67eec83000 0000007f
>   IDT=     fffffe0000000000 00000fff
>   CR0=80050033 CR2=00005646b7f7d018 CR3=000000012852a000 CR4=00750ef0
>   DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000 
>   DR6=00000000ffff0ff0 DR7=0000000000000400
>   EFER=0000000000000d01
>   Code=f3 0f 11 40 58 f3 0f 10 43 08 f3 0f 11 40 5c f3 0f 10 43 0c <f3> 0f 11 78 64 f3 0f 11 50 68 f3 44 0f 11 40 6c f3 0f 11 48 70 f3 0f 11 60 74 f3 0f 11 40

So this goes away with:

  Linux draig 6.13.0-rc6-ajb-00144-g8c8d54116fa2-dirty #27 SMP PREEMPT_DYNAMIC Fri Jan 10 16:57:29 GMT 2025 x86_64 GNU/Linux

So I think is an artefact of the PFN page locking failing. I guess
native context is more prone to issues? It is a bit odd as I have loads
of memory and I think the intel graphics are unified memory but I don't
know how you would check.

-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Dmitry Osipenko]

On 1/12/25 19:14, Alex Bennée wrote:
> So this goes away with:
> 
>   Linux draig 6.13.0-rc6-ajb-00144-g8c8d54116fa2-dirty #27 SMP PREEMPT_DYNAMIC Fri Jan 10 16:57:29 GMT 2025 x86_64 GNU/Linux
> 
> So I think is an artefact of the PFN page locking failing. I guess
> native context is more prone to issues? It is a bit odd as I have loads
> of memory and I think the intel graphics are unified memory but I don't
> know how you would check.

Native context is about same prone as Venus. For Intel GFX it doesn't
matter much whether it's dGPU or iGPU. i915 driver would use huge pages
for UMA which is affected by the same KVM/PFN issue. In a case of UMA,
you may explicitly disable transparent huge pages to work around the
problem, but this is no necessary anymore using 6.13+ kernel. Glad it
was an easy fix!

-- 
Best regards,
Dmitry

Re: [PATCH v4 0/5] Support virtio-gpu DRM native context

[Alex Bennée]

Dmitry Osipenko <dmitry.osipenko@collabora.com> writes:

> On 1/12/25 19:14, Alex Bennée wrote:
>> So this goes away with:
>> 
>>   Linux draig 6.13.0-rc6-ajb-00144-g8c8d54116fa2-dirty #27 SMP PREEMPT_DYNAMIC Fri Jan 10 16:57:29 GMT 2025 x86_64 GNU/Linux
>> 
>> So I think is an artefact of the PFN page locking failing. I guess
>> native context is more prone to issues? It is a bit odd as I have loads
>> of memory and I think the intel graphics are unified memory but I don't
>> know how you would check.
>
> Native context is about same prone as Venus. For Intel GFX it doesn't
> matter much whether it's dGPU or iGPU. i915 driver would use huge pages
> for UMA which is affected by the same KVM/PFN issue. In a case of UMA,
> you may explicitly disable transparent huge pages to work around the
> problem, but this is no necessary anymore using 6.13+ kernel. Glad it
> was an easy fix!

I still can't get vulkaninfo to see anything (Error
vk::Instance:enumeratePhysicalDevices: ErrorInitializationFailed).

I've got your mesa native-context-iris set up with VK_ICD_FILENAMES
pointing at the virtio_icd.x86_64.json

VK_LOADER_DEBUG=1 doesn't show anything


-- 
Alex Bennée
Virtualisation Tech Lead @ Linaro