[Qemu-devel] [PATCH v2 00/12] spice: add opengl/virgl/dmabuf support

[Qemu-devel] [PATCH v2 00/12] spice: add opengl/virgl/dmabuf support

[Gerd Hoffmann]

  Hi,

This patch series adds support for opengl and dma-buf passing to spice.
With this in place you can use virtio-gpu in 3d (virgl) mode with spice.

In v2 I've reordered the patches a bit, cherry-picked the forgotton
monitor-config patch, addressed the review comments from Marc.

Merge plan:  Patches 1-6 should be (almost) ready for merge and are
needed for initial support.  They go probably first, so the work
higher up the stack (libvirt etc) can start.

The remaining patches will hopefully follow before 2.6 release too,
but they probably need some more discussion and coordination with
spice-server.  I expect they will go into a separate pull request.

Patch #12 will be squashed, either patch #11 or patch #9, depending
on the merge ordering, so I kept it separate for now.

please review,
  Gerd

Gerd Hoffmann (11):
  spice: init dcl before registering qxl interface
  configure: add dma-buf support detection.
  egl-helpers: add functions for render nodes and dma-buf passing
  spice: add opengl/virgl/dmabuf support
  spice: add unblock timer
  spice: tweak debug messages.
  console: track gl_block state in QemuConsole
  spice/gl: render DisplaySurface via opengl
  spice/gl: create dummy primary surface (RfC)
  spice: add & use qemu_spice_gl_monitor_config
  [fixup] spice: qemu_spice_gl_monitor_config + surface

Marc-André Lureau (1):
  spice: reset cursor on resize

 configure                  |  20 +++-
 include/ui/console.h       |   1 +
 include/ui/egl-helpers.h   |  13 +++
 include/ui/spice-display.h |  19 ++++
 qemu-options.hx            |   4 +
 ui/console.c               |  15 ++-
 ui/egl-helpers.c           | 129 ++++++++++++++++++++++
 ui/spice-core.c            |  15 ++-
 ui/spice-display.c         | 263 +++++++++++++++++++++++++++++++++++++++++++--
 9 files changed, 463 insertions(+), 16 deletions(-)

-- 
1.8.3.1

[Qemu-devel] [PATCH v2 01/12] spice: init dcl before registering qxl interface

[Gerd Hoffmann]

Without this spice might callback into qemu before ssd->dcl.con is
initialized, resulting in a segfault due to NULL pointer dereference.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 ui/spice-display.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ui/spice-display.c b/ui/spice-display.c
index 8a5b325..cdbc78d 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -775,14 +775,14 @@ static void qemu_spice_display_init_one(QemuConsole *con)
 
     qemu_spice_display_init_common(ssd);
 
+    ssd->dcl.ops = &display_listener_ops;
+    ssd->dcl.con = con;
+
     ssd->qxl.base.sif = &dpy_interface.base;
     qemu_spice_add_display_interface(&ssd->qxl, con);
     assert(ssd->worker);
-
     qemu_spice_create_host_memslot(ssd);
 
-    ssd->dcl.ops = &display_listener_ops;
-    ssd->dcl.con = con;
     register_displaychangelistener(&ssd->dcl);
 }
 
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 02/12] configure: add dma-buf support detection.

[Gerd Hoffmann]

Set CONFIG_OPENGL_DMABUF in case both mesa and libepoxy are
new enough to have support for dma-buf import/export.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
 configure | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/configure b/configure
index 0aa249b..0c0472a 100755
--- a/configure
+++ b/configure
@@ -279,6 +279,7 @@ smartcard=""
 libusb=""
 usb_redir=""
 opengl=""
+opengl_dmabuf="no"
 zlib="yes"
 lzo=""
 snappy=""
@@ -3274,7 +3275,7 @@ libs_softmmu="$libs_softmmu $fdt_libs"
 # opengl probe (for sdl2, gtk, milkymist-tmu2)
 
 if test "$opengl" != "no" ; then
-  opengl_pkgs="epoxy"
+  opengl_pkgs="epoxy libdrm gbm"
   if $pkg_config $opengl_pkgs x11; then
     opengl_cflags="$($pkg_config --cflags $opengl_pkgs) $x11_cflags"
     opengl_libs="$($pkg_config --libs $opengl_pkgs) $x11_libs"
@@ -3292,6 +3293,18 @@ if test "$opengl" != "no" ; then
   fi
 fi
 
+if test "$opengl" = "yes"; then
+  cat > $TMPC << EOF
+#include <epoxy/egl.h>
+#ifndef EGL_MESA_image_dma_buf_export
+# error mesa/epoxy lacks support for dmabufs (mesa 10.6+)
+#endif
+int main(void) { return 0; }
+EOF
+  if compile_prog "" "" ; then
+    opengl_dmabuf=yes
+  fi
+fi
 
 ##########################################
 # archipelago probe
@@ -4752,6 +4765,7 @@ echo "smartcard support $smartcard"
 echo "libusb            $libusb"
 echo "usb net redir     $usb_redir"
 echo "OpenGL support    $opengl"
+echo "OpenGL dmabufs    $opengl_dmabuf"
 echo "libiscsi support  $libiscsi"
 echo "libnfs support    $libnfs"
 echo "build guest agent $guest_agent"
@@ -5050,6 +5064,7 @@ if test "$gtk" = "yes" ; then
   echo "CONFIG_GTK=y" >> $config_host_mak
   echo "CONFIG_GTKABI=$gtkabi" >> $config_host_mak
   echo "GTK_CFLAGS=$gtk_cflags" >> $config_host_mak
+  echo "GTK_LIBS=$gtk_libs" >> $config_host_mak
   if test "$gtk_gl" = "yes" ; then
     echo "CONFIG_GTK_GL=y" >> $config_host_mak
   fi
@@ -5158,6 +5173,9 @@ if test "$opengl" = "yes" ; then
   echo "CONFIG_OPENGL=y" >> $config_host_mak
   echo "OPENGL_CFLAGS=$opengl_cflags" >> $config_host_mak
   echo "OPENGL_LIBS=$opengl_libs" >> $config_host_mak
+  if test "$opengl_dmabuf" = "yes" ; then
+    echo "CONFIG_OPENGL_DMABUF=y" >> $config_host_mak
+  fi
 fi
 
 if test "$lzo" = "yes" ; then
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 03/12] egl-helpers: add functions for render nodes and dma-buf passing

[Gerd Hoffmann]

Adds helpers to open a drm render node and create a opengl
context for it.  Also add a helper to export a texture as
dma-buf.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
 include/ui/egl-helpers.h |  13 +++++
 ui/egl-helpers.c         | 129 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 142 insertions(+)

diff --git a/include/ui/egl-helpers.h b/include/ui/egl-helpers.h
index 8c84398..03fcf4b 100644
--- a/include/ui/egl-helpers.h
+++ b/include/ui/egl-helpers.h
@@ -3,10 +3,23 @@
 
 #include <epoxy/gl.h>
 #include <epoxy/egl.h>
+#include <gbm.h>
 
 extern EGLDisplay *qemu_egl_display;
 extern EGLConfig qemu_egl_config;
 
+#ifdef CONFIG_OPENGL_DMABUF
+
+extern int qemu_egl_rn_fd;
+extern struct gbm_device *qemu_egl_rn_gbm_dev;
+extern EGLContext qemu_egl_rn_ctx;
+
+int qemu_egl_rendernode_open(void);
+int egl_rendernode_init(void);
+int egl_get_fd_for_texture(uint32_t tex_id, EGLint *stride, EGLint *fourcc);
+
+#endif
+
 EGLSurface qemu_egl_init_surface_x11(EGLContext ectx, Window win);
 
 int qemu_egl_init_dpy(EGLNativeDisplayType dpy, bool gles, bool debug);
diff --git a/ui/egl-helpers.c b/ui/egl-helpers.c
index 4c83834..54be44c 100644
--- a/ui/egl-helpers.c
+++ b/ui/egl-helpers.c
@@ -1,6 +1,8 @@
 #include "qemu/osdep.h"
 #include <glob.h>
+#include <dirent.h>
 
+#include "config-host.h"
 #include "ui/egl-helpers.h"
 
 EGLDisplay *qemu_egl_display;
@@ -20,6 +22,133 @@ static int egl_debug;
 
 /* ---------------------------------------------------------------------- */
 
+#ifdef CONFIG_OPENGL_DMABUF
+
+int qemu_egl_rn_fd;
+struct gbm_device *qemu_egl_rn_gbm_dev;
+EGLContext qemu_egl_rn_ctx;
+
+int qemu_egl_rendernode_open(void)
+{
+    DIR *dir;
+    struct dirent *e;
+    int r, fd;
+    char *p;
+
+    dir = opendir("/dev/dri");
+    if (!dir) {
+        return -1;
+    }
+
+    fd = -1;
+    while ((e = readdir(dir))) {
+        if (e->d_type != DT_CHR) {
+            continue;
+        }
+
+        if (strncmp(e->d_name, "renderD", 7)) {
+            continue;
+        }
+
+        r = asprintf(&p, "/dev/dri/%s", e->d_name);
+        if (r < 0) {
+            return -1;
+        }
+
+        r = open(p, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
+        if (r < 0) {
+            free(p);
+            continue;
+        }
+        fd = r;
+        free(p);
+        break;
+    }
+
+    closedir(dir);
+    if (fd < 0) {
+        return -1;
+    }
+    return fd;
+}
+
+int egl_rendernode_init(void)
+{
+    qemu_egl_rn_fd = -1;
+
+    qemu_egl_rn_fd = qemu_egl_rendernode_open();
+    if (qemu_egl_rn_fd == -1) {
+        fprintf(stderr, "egl: no drm render node available\n");
+        goto err;
+    }
+
+    qemu_egl_rn_gbm_dev = gbm_create_device(qemu_egl_rn_fd);
+    if (!qemu_egl_rn_gbm_dev) {
+        fprintf(stderr, "egl: gbm_create_device failed\n");
+        goto err;
+    }
+
+    qemu_egl_init_dpy((EGLNativeDisplayType)qemu_egl_rn_gbm_dev, false, false);
+
+    if (!epoxy_has_egl_extension(qemu_egl_display,
+                                 "EGL_KHR_surfaceless_context")) {
+        fprintf(stderr, "egl: EGL_KHR_surfaceless_context not supported\n");
+        goto err;
+    }
+    if (!epoxy_has_egl_extension(qemu_egl_display,
+                                 "EGL_MESA_image_dma_buf_export")) {
+        fprintf(stderr, "egl: EGL_MESA_image_dma_buf_export not supported\n");
+        goto err;
+    }
+
+    qemu_egl_rn_ctx = qemu_egl_init_ctx();
+    if (!qemu_egl_rn_ctx) {
+        fprintf(stderr, "egl: egl_init_ctx failed\n");
+        goto err;
+    }
+
+    return 0;
+
+err:
+    if (qemu_egl_rn_gbm_dev) {
+        gbm_device_destroy(qemu_egl_rn_gbm_dev);
+    }
+    if (qemu_egl_rn_fd != -1) {
+        close(qemu_egl_rn_fd);
+    }
+
+    return -1;
+}
+
+int egl_get_fd_for_texture(uint32_t tex_id, EGLint *stride, EGLint *fourcc)
+{
+    EGLImageKHR image;
+    EGLint num_planes, fd;
+
+    image = eglCreateImageKHR(qemu_egl_display, eglGetCurrentContext(),
+                              EGL_GL_TEXTURE_2D_KHR,
+                              (EGLClientBuffer)(unsigned long)tex_id,
+                              NULL);
+    if (!image) {
+        return -1;
+    }
+
+    eglExportDMABUFImageQueryMESA(qemu_egl_display, image, fourcc,
+                                  &num_planes, NULL);
+    if (num_planes != 1) {
+        eglDestroyImageKHR(qemu_egl_display, image);
+        return -1;
+    }
+    eglExportDMABUFImageMESA(qemu_egl_display, image, &fd, stride, NULL);
+    eglDestroyImageKHR(qemu_egl_display, image);
+
+    return fd;
+}
+
+#endif /* CONFIG_OPENGL_DMABUF */
+
+/* ---------------------------------------------------------------------- */
+
 EGLSurface qemu_egl_init_surface_x11(EGLContext ectx, Window win)
 {
     EGLSurface esurface;
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 04/12] spice: reset cursor on resize

[Gerd Hoffmann]

From: Marc-André Lureau <marcandre.lureau@redhat.com>

Spice server will clear the cursor on resize. QXL driver reset it after
resize, however, virtio and other devices do not. Teach qemu to set it
back.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 ui/spice-display.c | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/ui/spice-display.c b/ui/spice-display.c
index cdbc78d..4e5c8a2 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -460,6 +460,13 @@ void qemu_spice_display_switch(SimpleSpiceDisplay *ssd,
 
     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
     ssd->notify++;
+
+    qemu_mutex_lock(&ssd->lock);
+    if (ssd->cursor) {
+        g_free(ssd->ptr_define);
+        ssd->ptr_define = qemu_spice_create_cursor_update(ssd, ssd->cursor, 0);
+    }
+    qemu_mutex_unlock(&ssd->lock);
 }
 
 static void qemu_spice_cursor_refresh_unlocked(SimpleSpiceDisplay *ssd)
@@ -467,8 +474,6 @@ static void qemu_spice_cursor_refresh_unlocked(SimpleSpiceDisplay *ssd)
     if (ssd->cursor) {
         assert(ssd->dcl.con);
         dpy_cursor_define(ssd->dcl.con, ssd->cursor);
-        cursor_put(ssd->cursor);
-        ssd->cursor = NULL;
     }
     if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
         assert(ssd->dcl.con);
@@ -750,6 +755,11 @@ static void display_mouse_define(DisplayChangeListener *dcl,
     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
 
     qemu_mutex_lock(&ssd->lock);
+    if (c) {
+        cursor_get(c);
+    }
+    cursor_put(ssd->cursor);
+    ssd->cursor = c;
     ssd->hot_x = c->hot_x;
     ssd->hot_y = c->hot_y;
     g_free(ssd->ptr_move);
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 05/12] spice: add opengl/virgl/dmabuf support

[Gerd Hoffmann]

This adds support for dma-buf passing to spice.  This makes virtio-gpu
with 3d acceleration work with spice.

Workflow:
 * virglrenderer renders the guest command stream into a texture.
 * qemu exports the texture as dma-buf and passes on that dma-buf
   to spice-server.
 * spice-server passes the dma-buf to spice-client, using unix
   socket file descriptor passing.
 * spice-client asks the window systems composer to render the
   dma-buf to the screen.

Requires cutting edge spice (server) and spice-gtk (client) builds,
from git master branch.

Also requires libvirt managing your qemu instance, and using
"virt-viewer --attach $guest".  libvirt will connect spice-server and
spice-client using unix sockets instead of tcp sockets then, which
is required for file descriptor passing.

Works for the local case (spice server and client on the same machine)
only.  Supporting remote too is planned (by feeding the dma-bufs into
gpu-assisted video encoder), but not there yet.

gl mode is turned off by default, use "-spice gl=on,$otherargs" to
enable it.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 include/ui/spice-display.h |  15 +++++++
 qemu-options.hx            |   4 ++
 ui/spice-core.c            |  15 ++++++-
 ui/spice-display.c         | 110 +++++++++++++++++++++++++++++++++++++++++++--
 4 files changed, 140 insertions(+), 4 deletions(-)

diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
index b25328a..48dc8c4 100644
--- a/include/ui/spice-display.h
+++ b/include/ui/spice-display.h
@@ -24,6 +24,14 @@
 #include "ui/console.h"
 #include "sysemu/sysemu.h"
 
+#if defined(CONFIG_OPENGL_DMABUF)
+# if SPICE_SERVER_VERSION >= 0x000d00 /* release 0.13.0 */
+#  define HAVE_SPICE_GL 1
+#  include "ui/egl-helpers.h"
+#  include "ui/egl-context.h"
+# endif
+#endif
+
 #define NUM_MEMSLOTS 8
 #define MEMSLOT_GENERATION_BITS 8
 #define MEMSLOT_SLOT_BITS 8
@@ -50,6 +58,7 @@ enum {
     QXL_COOKIE_TYPE_IO,
     QXL_COOKIE_TYPE_RENDER_UPDATE_AREA,
     QXL_COOKIE_TYPE_POST_LOAD_MONITORS_CONFIG,
+    QXL_COOKIE_TYPE_GL_DRAW_DONE,
 };
 
 typedef struct QXLCookie {
@@ -104,6 +113,12 @@ struct SimpleSpiceDisplay {
     QEMUCursor *cursor;
     int mouse_x, mouse_y;
     QEMUBH *cursor_bh;
+
+#ifdef HAVE_SPICE_GL
+    /* opengl rendering */
+    QEMUBH *gl_unblock_bh;
+    int dmabuf_fd;
+#endif
 };
 
 struct SimpleSpiceUpdate {
diff --git a/qemu-options.hx b/qemu-options.hx
index 2f0465e..f528405 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -1051,6 +1051,7 @@ DEF("spice", HAS_ARG, QEMU_OPTION_spice,
     "       [,streaming-video=[off|all|filter]][,disable-copy-paste]\n"
     "       [,disable-agent-file-xfer][,agent-mouse=[on|off]]\n"
     "       [,playback-compression=[on|off]][,seamless-migration=[on|off]]\n"
+    "       [,gl=[on|off]]\n"
     "   enable spice\n"
     "   at least one of {port, tls-port} is mandatory\n",
     QEMU_ARCH_ALL)
@@ -1142,6 +1143,9 @@ Enable/disable audio stream compression (using celt 0.5.1).  Default is on.
 @item seamless-migration=[on|off]
 Enable/disable spice seamless migration. Default is off.
 
+@item gl=[on|off]
+Enable/disable OpenGL context. Default is off.
+
 @end table
 ETEXI
 
diff --git a/ui/spice-core.c b/ui/spice-core.c
index 4dbd99a..5abec17 100644
--- a/ui/spice-core.c
+++ b/ui/spice-core.c
@@ -494,9 +494,14 @@ static QemuOptsList qemu_spice_opts = {
         },{
             .name = "playback-compression",
             .type = QEMU_OPT_BOOL,
-        }, {
+        },{
             .name = "seamless-migration",
             .type = QEMU_OPT_BOOL,
+#ifdef HAVE_SPICE_GL
+        },{
+            .name = "gl",
+            .type = QEMU_OPT_BOOL,
+#endif
         },
         { /* end of list */ }
     },
@@ -819,6 +824,14 @@ void qemu_spice_init(void)
 #if SPICE_SERVER_VERSION >= 0x000c02
     qemu_spice_register_ports();
 #endif
+
+#ifdef HAVE_SPICE_GL
+    if (qemu_opt_get_bool(opts, "gl", 0)) {
+        if (egl_rendernode_init() == 0) {
+            display_opengl = 1;
+        }
+    }
+#endif
 }
 
 int qemu_spice_add_interface(SpiceBaseInstance *sin)
diff --git a/ui/spice-display.c b/ui/spice-display.c
index 4e5c8a2..904fb33 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -650,9 +650,23 @@ static void interface_update_area_complete(QXLInstance *sin,
 /* called from spice server thread context only */
 static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
 {
-    /* should never be called, used in qxl native mode only */
-    fprintf(stderr, "%s: abort()\n", __func__);
-    abort();
+    QXLCookie *cookie = (QXLCookie *)(uintptr_t)cookie_token;
+
+    switch (cookie->type) {
+#ifdef HAVE_SPICE_GL
+    case QXL_COOKIE_TYPE_GL_DRAW_DONE:
+    {
+        SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
+        qemu_bh_schedule(ssd->gl_unblock_bh);
+        break;
+    }
+#endif
+    default:
+        /* should never be called, used in qxl native mode only */
+        fprintf(stderr, "%s: abort()\n", __func__);
+        abort();
+    }
+    g_free(cookie);
 }
 
 static void interface_set_client_capabilities(QXLInstance *sin,
@@ -779,6 +793,89 @@ static const DisplayChangeListenerOps display_listener_ops = {
     .dpy_cursor_define    = display_mouse_define,
 };
 
+#ifdef HAVE_SPICE_GL
+
+static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
+{
+    graphic_hw_gl_block(ssd->dcl.con, block);
+}
+
+static void qemu_spice_gl_unblock_bh(void *opaque)
+{
+    SimpleSpiceDisplay *ssd = opaque;
+
+    qemu_spice_gl_block(ssd, false);
+}
+
+static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
+                                                  QEMUGLParams *params)
+{
+    eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                   qemu_egl_rn_ctx);
+    return qemu_egl_create_context(dcl, params);
+}
+
+static void qemu_spice_gl_scanout(DisplayChangeListener *dcl,
+                                  uint32_t tex_id,
+                                  bool y_0_top,
+                                  uint32_t x, uint32_t y,
+                                  uint32_t w, uint32_t h)
+{
+    SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
+    EGLint stride = 0, fourcc = 0;
+    int fd = -1;
+
+    if (tex_id) {
+        fd = egl_get_fd_for_texture(tex_id, &stride, &fourcc);
+        if (fd < 0) {
+            fprintf(stderr, "%s: failed to get fd for texture\n", __func__);
+            return;
+        }
+    }
+    dprint(0, "%s: %dx%d (stride %d, fourcc 0x%x)\n", __func__,
+           w, h, stride, fourcc);
+
+    assert(!tex_id || fd >= 0);
+
+    /* note: spice server will close the fd */
+    spice_qxl_gl_scanout(&ssd->qxl, fd,
+                         surface_width(ssd->ds),
+                         surface_height(ssd->ds),
+                         stride, fourcc, y_0_top);
+}
+
+static void qemu_spice_gl_update(DisplayChangeListener *dcl,
+                                 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
+{
+    SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
+    uint64_t cookie;
+
+    dprint(1, "%s\n", __func__);
+    qemu_spice_gl_block(ssd, true);
+    cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
+    spice_qxl_gl_draw_async(&ssd->qxl, x, y, w, h, cookie);
+}
+
+static const DisplayChangeListenerOps display_listener_gl_ops = {
+    .dpy_name             = "spice-egl",
+    .dpy_gfx_update       = display_update,
+    .dpy_gfx_switch       = display_switch,
+    .dpy_gfx_check_format = qemu_pixman_check_format,
+    .dpy_refresh          = display_refresh,
+    .dpy_mouse_set        = display_mouse_set,
+    .dpy_cursor_define    = display_mouse_define,
+
+    .dpy_gl_ctx_create       = qemu_spice_gl_create_context,
+    .dpy_gl_ctx_destroy      = qemu_egl_destroy_context,
+    .dpy_gl_ctx_make_current = qemu_egl_make_context_current,
+    .dpy_gl_ctx_get_current  = qemu_egl_get_current_context,
+
+    .dpy_gl_scanout          = qemu_spice_gl_scanout,
+    .dpy_gl_update           = qemu_spice_gl_update,
+};
+
+#endif /* HAVE_SPICE_GL */
+
 static void qemu_spice_display_init_one(QemuConsole *con)
 {
     SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
@@ -786,6 +883,13 @@ static void qemu_spice_display_init_one(QemuConsole *con)
     qemu_spice_display_init_common(ssd);
 
     ssd->dcl.ops = &display_listener_ops;
+#ifdef HAVE_SPICE_GL
+    if (display_opengl) {
+        ssd->dcl.ops = &display_listener_gl_ops;
+        ssd->dmabuf_fd = -1;
+        ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
+    }
+#endif
     ssd->dcl.con = con;
 
     ssd->qxl.base.sif = &dpy_interface.base;
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 06/12] spice: add unblock timer

[Gerd Hoffmann]

Pure debug aid, print a warning in case unblocking
doesn't happen within one second.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 include/ui/spice-display.h |  1 +
 ui/spice-display.c         | 16 ++++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
index 48dc8c4..69a222b 100644
--- a/include/ui/spice-display.h
+++ b/include/ui/spice-display.h
@@ -117,6 +117,7 @@ struct SimpleSpiceDisplay {
 #ifdef HAVE_SPICE_GL
     /* opengl rendering */
     QEMUBH *gl_unblock_bh;
+    QEMUTimer *gl_unblock_timer;
     int dmabuf_fd;
 #endif
 };
diff --git a/ui/spice-display.c b/ui/spice-display.c
index 904fb33..d6e31e4 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -797,6 +797,15 @@ static const DisplayChangeListenerOps display_listener_ops = {
 
 static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
 {
+    uint64_t timeout;
+
+    if (block) {
+        timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
+        timeout += 1000; /* one sec */
+        timer_mod(ssd->gl_unblock_timer, timeout);
+    } else {
+        timer_del(ssd->gl_unblock_timer);
+    }
     graphic_hw_gl_block(ssd->dcl.con, block);
 }
 
@@ -807,6 +816,11 @@ static void qemu_spice_gl_unblock_bh(void *opaque)
     qemu_spice_gl_block(ssd, false);
 }
 
+static void qemu_spice_gl_block_timer(void *opaque)
+{
+    fprintf(stderr, "WARNING: spice: no gl-draw-done within one second\n");
+}
+
 static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
                                                   QEMUGLParams *params)
 {
@@ -888,6 +902,8 @@ static void qemu_spice_display_init_one(QemuConsole *con)
         ssd->dcl.ops = &display_listener_gl_ops;
         ssd->dmabuf_fd = -1;
         ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
+        ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
+                                             qemu_spice_gl_block_timer, ssd);
     }
 #endif
     ssd->dcl.con = con;
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 07/12] spice: tweak debug messages.

[Gerd Hoffmann]

Adjust message levels, make messages more verbose.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 ui/spice-display.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/ui/spice-display.c b/ui/spice-display.c
index d6e31e4..242ab5f 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -568,7 +568,7 @@ static int interface_get_command(QXLInstance *sin, QXLCommandExt *ext)
 
 static int interface_req_cmd_notification(QXLInstance *sin)
 {
-    dprint(1, "%s/%d:\n", __func__, sin->id);
+    dprint(2, "%s/%d:\n", __func__, sin->id);
     return 1;
 }
 
@@ -621,7 +621,7 @@ static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)
 
 static int interface_req_cursor_notification(QXLInstance *sin)
 {
-    dprint(1, "%s:\n", __FUNCTION__);
+    dprint(2, "%s:\n", __func__);
     return 1;
 }
 
@@ -845,9 +845,11 @@ static void qemu_spice_gl_scanout(DisplayChangeListener *dcl,
             fprintf(stderr, "%s: failed to get fd for texture\n", __func__);
             return;
         }
+        dprint(1, "%s: %dx%d (stride %d, fourcc 0x%x)\n", __func__,
+               w, h, stride, fourcc);
+    } else {
+        dprint(1, "%s: no texture (no framebuffer)\n", __func__);
     }
-    dprint(0, "%s: %dx%d (stride %d, fourcc 0x%x)\n", __func__,
-           w, h, stride, fourcc);
 
     assert(!tex_id || fd >= 0);
 
@@ -864,7 +866,7 @@ static void qemu_spice_gl_update(DisplayChangeListener *dcl,
     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
     uint64_t cookie;
 
-    dprint(1, "%s\n", __func__);
+    dprint(2, "%s: %dx%d+%d+%d\n", __func__, w, h, x, y);
     qemu_spice_gl_block(ssd, true);
     cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
     spice_qxl_gl_draw_async(&ssd->qxl, x, y, w, h, cookie);
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 08/12] console: track gl_block state in QemuConsole

[Gerd Hoffmann]

Keep track of gl_block state (added in bba19b8 console: block rendering
until client is done) in QemuConsole and allow to query it.  This way
we can avoid state inconsistencies in case different code paths make use
of this.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
 include/ui/console.h |  1 +
 ui/console.c         | 15 +++++++++++----
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/include/ui/console.h b/include/ui/console.h
index c8f9f7e..9672ad9 100644
--- a/include/ui/console.h
+++ b/include/ui/console.h
@@ -382,6 +382,7 @@ QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head);
 bool qemu_console_is_visible(QemuConsole *con);
 bool qemu_console_is_graphic(QemuConsole *con);
 bool qemu_console_is_fixedsize(QemuConsole *con);
+bool qemu_console_is_gl_blocked(QemuConsole *con);
 char *qemu_console_get_label(QemuConsole *con);
 int qemu_console_get_index(QemuConsole *con);
 uint32_t qemu_console_get_head(QemuConsole *con);
diff --git a/ui/console.c b/ui/console.c
index b739ae9..215c98d 100644
--- a/ui/console.c
+++ b/ui/console.c
@@ -123,6 +123,7 @@ struct QemuConsole {
     DisplaySurface *surface;
     int dcls;
     DisplayChangeListener *gl;
+    bool gl_block;
 
     /* Graphic console state.  */
     Object *device;
@@ -264,10 +265,10 @@ void graphic_hw_update(QemuConsole *con)
 
 void graphic_hw_gl_block(QemuConsole *con, bool block)
 {
-    if (!con) {
-        con = active_console;
-    }
-    if (con && con->hw_ops->gl_block) {
+    assert(con != NULL);
+
+    con->gl_block = block;
+    if (con->hw_ops->gl_block) {
         con->hw_ops->gl_block(con->hw, block);
     }
 }
@@ -1811,6 +1812,12 @@ bool qemu_console_is_fixedsize(QemuConsole *con)
     return con && (con->console_type != TEXT_CONSOLE);
 }
 
+bool qemu_console_is_gl_blocked(QemuConsole *con)
+{
+    assert(con != NULL);
+    return con->gl_block;
+}
+
 char *qemu_console_get_label(QemuConsole *con)
 {
     if (con->console_type == GRAPHIC_CONSOLE) {
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 09/12] spice/gl: render DisplaySurface via opengl

[Gerd Hoffmann]

This switches over spice (in opengl mode) to render DisplaySurface
updates into a opengl texture, using the helper functions in
ui/console-gl.c.  With this patch applied spice (with gl=on) will
stop using qxl rendering ops, it will use dma-buf passing all the
time, i.e. for bios/bootloader (before virtio-gpu driver is loaded)
too.

This should improve performance even using spice (with gl=on) with
non-accelerated stdvga because we stop squeezing all display updates
through a unix/tcp socket and basically using a shared memory transport
instead.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 include/ui/spice-display.h |  2 ++
 ui/spice-display.c         | 77 +++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 72 insertions(+), 7 deletions(-)

diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
index 69a222b..dd9cf6f 100644
--- a/include/ui/spice-display.h
+++ b/include/ui/spice-display.h
@@ -119,6 +119,8 @@ struct SimpleSpiceDisplay {
     QEMUBH *gl_unblock_bh;
     QEMUTimer *gl_unblock_timer;
     int dmabuf_fd;
+    ConsoleGLState *gls;
+    int gl_updates;
 #endif
 };
 
diff --git a/ui/spice-display.c b/ui/spice-display.c
index 242ab5f..15d7906 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -821,6 +821,68 @@ static void qemu_spice_gl_block_timer(void *opaque)
     fprintf(stderr, "WARNING: spice: no gl-draw-done within one second\n");
 }
 
+static void spice_gl_refresh(DisplayChangeListener *dcl)
+{
+    SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
+    uint64_t cookie;
+
+    if (!ssd->ds || qemu_console_is_gl_blocked(ssd->dcl.con)) {
+        return;
+    }
+
+    graphic_hw_update(dcl->con);
+    if (ssd->gl_updates) {
+        qemu_spice_gl_block(ssd, true);
+        cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
+        spice_qxl_gl_draw_async(&ssd->qxl, 0, 0,
+                                surface_width(ssd->ds),
+                                surface_height(ssd->ds),
+                                cookie);
+        ssd->gl_updates = 0;
+    }
+}
+
+static void spice_gl_update(DisplayChangeListener *dcl,
+                            int x, int y, int w, int h)
+{
+    SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
+
+    surface_gl_update_texture(ssd->gls, ssd->ds, x, y, w, h);
+    ssd->gl_updates++;
+}
+
+static void spice_gl_switch(DisplayChangeListener *dcl,
+                            struct DisplaySurface *new_surface)
+{
+    SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
+    EGLint stride, fourcc;
+    int fd;
+
+    if (ssd->ds) {
+        surface_gl_destroy_texture(ssd->gls, ssd->ds);
+    }
+    ssd->ds = new_surface;
+    if (ssd->ds) {
+        surface_gl_create_texture(ssd->gls, ssd->ds);
+        fd = egl_get_fd_for_texture(ssd->ds->texture,
+                                    &stride, &fourcc);
+        if (fd < 0) {
+            surface_gl_destroy_texture(ssd->gls, ssd->ds);
+            return;
+        }
+
+        dprint(1, "%s: %dx%d (stride %d/%d, fourcc 0x%x)\n", __func__,
+               surface_width(ssd->ds), surface_height(ssd->ds),
+               surface_stride(ssd->ds), stride, fourcc);
+
+        /* note: spice server will close the fd */
+        spice_qxl_gl_scanout(&ssd->qxl, fd,
+                             surface_width(ssd->ds),
+                             surface_height(ssd->ds),
+                             stride, fourcc, false);
+    }
+}
+
 static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
                                                   QEMUGLParams *params)
 {
@@ -873,13 +935,13 @@ static void qemu_spice_gl_update(DisplayChangeListener *dcl,
 }
 
 static const DisplayChangeListenerOps display_listener_gl_ops = {
-    .dpy_name             = "spice-egl",
-    .dpy_gfx_update       = display_update,
-    .dpy_gfx_switch       = display_switch,
-    .dpy_gfx_check_format = qemu_pixman_check_format,
-    .dpy_refresh          = display_refresh,
-    .dpy_mouse_set        = display_mouse_set,
-    .dpy_cursor_define    = display_mouse_define,
+    .dpy_name                = "spice-egl",
+    .dpy_gfx_update          = spice_gl_update,
+    .dpy_gfx_switch          = spice_gl_switch,
+    .dpy_gfx_check_format    = console_gl_check_format,
+    .dpy_refresh             = spice_gl_refresh,
+    .dpy_mouse_set           = display_mouse_set,
+    .dpy_cursor_define       = display_mouse_define,
 
     .dpy_gl_ctx_create       = qemu_spice_gl_create_context,
     .dpy_gl_ctx_destroy      = qemu_egl_destroy_context,
@@ -906,6 +968,7 @@ static void qemu_spice_display_init_one(QemuConsole *con)
         ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
         ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
                                              qemu_spice_gl_block_timer, ssd);
+        ssd->gls = console_gl_init_context();
     }
 #endif
     ssd->dcl.con = con;
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Gerd Hoffmann]

Current spice client expects we create a primary surface,
even if we do display updates using dma-bufs exclusively.

So just do that to get things going.

Not fully clear whenever that is intentional or a bug on
the spice side, so I keep this as separate patch for now.

I think this should either be squashed into the previous
patch, or dropped after fixing things on the spice side.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 ui/spice-display.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/ui/spice-display.c b/ui/spice-display.c
index 15d7906..96beb02 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -856,13 +856,27 @@ static void spice_gl_switch(DisplayChangeListener *dcl,
 {
     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
     EGLint stride, fourcc;
+    bool resize = true;
     int fd;
 
+    if (ssd->ds && new_surface &&
+        surface_width(ssd->ds)  == surface_width(new_surface)  &&
+        surface_height(ssd->ds) == surface_height(new_surface) &&
+        surface_format(ssd->ds) == surface_format(new_surface)) {
+        resize = false;
+    }
+
     if (ssd->ds) {
         surface_gl_destroy_texture(ssd->gls, ssd->ds);
+        if (resize) {
+            qemu_spice_destroy_host_primary(ssd);
+        }
     }
     ssd->ds = new_surface;
     if (ssd->ds) {
+        if (resize) {
+            qemu_spice_create_host_primary(ssd);
+        }
         surface_gl_create_texture(ssd->gls, ssd->ds);
         fd = egl_get_fd_for_texture(ssd->ds->texture,
                                     &stride, &fourcc);
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 11/12] spice: add & use qemu_spice_gl_monitor_config

[Gerd Hoffmann]

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 include/ui/spice-display.h |  1 +
 ui/spice-display.c         | 30 ++++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
index dd9cf6f..f9388c2 100644
--- a/include/ui/spice-display.h
+++ b/include/ui/spice-display.h
@@ -71,6 +71,7 @@ typedef struct QXLCookie {
             QXLRect area;
             int redraw;
         } render;
+        void *data;
     } u;
 } QXLCookie;
 
diff --git a/ui/spice-display.c b/ui/spice-display.c
index 96beb02..34e6d51 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -660,6 +660,11 @@ static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
         qemu_bh_schedule(ssd->gl_unblock_bh);
         break;
     }
+    case QXL_COOKIE_TYPE_IO:
+        if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
+            g_free(cookie->u.data);
+        }
+        break;
 #endif
     default:
         /* should never be called, used in qxl native mode only */
@@ -795,6 +800,29 @@ static const DisplayChangeListenerOps display_listener_ops = {
 
 #ifdef HAVE_SPICE_GL
 
+static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
+                                         int x, int y, int w, int h)
+{
+    QXLMonitorsConfig *config;
+    QXLCookie *cookie;
+
+    config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
+    config->count = 1;
+    config->max_allowed = 1;
+    config->heads[0].x = x;
+    config->heads[0].y = y;
+    config->heads[0].width = w;
+    config->heads[0].height = h;
+    cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
+                            QXL_IO_MONITORS_CONFIG_ASYNC);
+    cookie->u.data = config;
+
+    spice_qxl_monitors_config_async(&ssd->qxl,
+                                    (uintptr_t)config,
+                                    MEMSLOT_GROUP_HOST,
+                                    (uintptr_t)cookie);
+}
+
 static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
 {
     uint64_t timeout;
@@ -934,6 +962,8 @@ static void qemu_spice_gl_scanout(DisplayChangeListener *dcl,
                          surface_width(ssd->ds),
                          surface_height(ssd->ds),
                          stride, fourcc, y_0_top);
+
+    qemu_spice_gl_monitor_config(ssd, x, y, w, h);
 }
 
 static void qemu_spice_gl_update(DisplayChangeListener *dcl,
-- 
1.8.3.1

[Qemu-devel] [PATCH v2 12/12] [fixup] spice: qemu_spice_gl_monitor_config + surface

[Gerd Hoffmann]

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
---
 ui/spice-display.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/ui/spice-display.c b/ui/spice-display.c
index 34e6d51..806851f 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -922,6 +922,10 @@ static void spice_gl_switch(DisplayChangeListener *dcl,
                              surface_width(ssd->ds),
                              surface_height(ssd->ds),
                              stride, fourcc, false);
+
+        qemu_spice_gl_monitor_config(ssd, 0, 0,
+                                     surface_width(ssd->ds),
+                                     surface_height(ssd->ds));
     }
 }
 
-- 
1.8.3.1

Re: [Qemu-devel] [PATCH v2 01/12] spice: init dcl before registering qxl interface

[Marc-André Lureau]

Hi

On Fri, Feb 19, 2016 at 10:14 AM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> Without this spice might callback into qemu before ssd->dcl.con is
> initialized, resulting in a segfault due to NULL pointer dereference.
>
> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>

-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 11/12] spice: add & use qemu_spice_gl_monitor_config

[Marc-André Lureau]

Hi

On Fri, Feb 19, 2016 at 10:14 AM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
> ---
>  include/ui/spice-display.h |  1 +
>  ui/spice-display.c         | 30 ++++++++++++++++++++++++++++++
>  2 files changed, 31 insertions(+)
>

Could eventually be squashed with "add opengl/virgl/dmabuf support" patch

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>

> diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
> index dd9cf6f..f9388c2 100644
> --- a/include/ui/spice-display.h
> +++ b/include/ui/spice-display.h
> @@ -71,6 +71,7 @@ typedef struct QXLCookie {
>              QXLRect area;
>              int redraw;
>          } render;
> +        void *data;
>      } u;
>  } QXLCookie;
>
> diff --git a/ui/spice-display.c b/ui/spice-display.c
> index 96beb02..34e6d51 100644
> --- a/ui/spice-display.c
> +++ b/ui/spice-display.c
> @@ -660,6 +660,11 @@ static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
>          qemu_bh_schedule(ssd->gl_unblock_bh);
>          break;
>      }
> +    case QXL_COOKIE_TYPE_IO:
> +        if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
> +            g_free(cookie->u.data);
> +        }
> +        break;
>  #endif
>      default:
>          /* should never be called, used in qxl native mode only */
> @@ -795,6 +800,29 @@ static const DisplayChangeListenerOps display_listener_ops = {
>
>  #ifdef HAVE_SPICE_GL
>
> +static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
> +                                         int x, int y, int w, int h)
> +{
> +    QXLMonitorsConfig *config;
> +    QXLCookie *cookie;
> +
> +    config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
> +    config->count = 1;
> +    config->max_allowed = 1;
> +    config->heads[0].x = x;
> +    config->heads[0].y = y;
> +    config->heads[0].width = w;
> +    config->heads[0].height = h;
> +    cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
> +                            QXL_IO_MONITORS_CONFIG_ASYNC);
> +    cookie->u.data = config;
> +
> +    spice_qxl_monitors_config_async(&ssd->qxl,
> +                                    (uintptr_t)config,
> +                                    MEMSLOT_GROUP_HOST,
> +                                    (uintptr_t)cookie);
> +}
> +
>  static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
>  {
>      uint64_t timeout;
> @@ -934,6 +962,8 @@ static void qemu_spice_gl_scanout(DisplayChangeListener *dcl,
>                           surface_width(ssd->ds),
>                           surface_height(ssd->ds),
>                           stride, fourcc, y_0_top);
> +
> +    qemu_spice_gl_monitor_config(ssd, x, y, w, h);
>  }
>
>  static void qemu_spice_gl_update(DisplayChangeListener *dcl,
> --
> 1.8.3.1
>



-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 06/12] spice: add unblock timer

[Marc-André Lureau]

Hi

On Fri, Feb 19, 2016 at 10:14 AM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> Pure debug aid, print a warning in case unblocking
> doesn't happen within one second.
>
> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
> ---

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>

>  include/ui/spice-display.h |  1 +
>  ui/spice-display.c         | 16 ++++++++++++++++
>  2 files changed, 17 insertions(+)
>
> diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
> index 48dc8c4..69a222b 100644
> --- a/include/ui/spice-display.h
> +++ b/include/ui/spice-display.h
> @@ -117,6 +117,7 @@ struct SimpleSpiceDisplay {
>  #ifdef HAVE_SPICE_GL
>      /* opengl rendering */
>      QEMUBH *gl_unblock_bh;
> +    QEMUTimer *gl_unblock_timer;
>      int dmabuf_fd;
>  #endif
>  };
> diff --git a/ui/spice-display.c b/ui/spice-display.c
> index 904fb33..d6e31e4 100644
> --- a/ui/spice-display.c
> +++ b/ui/spice-display.c
> @@ -797,6 +797,15 @@ static const DisplayChangeListenerOps display_listener_ops = {
>
>  static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
>  {
> +    uint64_t timeout;
> +
> +    if (block) {
> +        timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
> +        timeout += 1000; /* one sec */
> +        timer_mod(ssd->gl_unblock_timer, timeout);
> +    } else {
> +        timer_del(ssd->gl_unblock_timer);
> +    }
>      graphic_hw_gl_block(ssd->dcl.con, block);
>  }
>
> @@ -807,6 +816,11 @@ static void qemu_spice_gl_unblock_bh(void *opaque)
>      qemu_spice_gl_block(ssd, false);
>  }
>
> +static void qemu_spice_gl_block_timer(void *opaque)
> +{
> +    fprintf(stderr, "WARNING: spice: no gl-draw-done within one second\n");
> +}
> +
>  static QEMUGLContext qemu_spice_gl_create_context(DisplayChangeListener *dcl,
>                                                    QEMUGLParams *params)
>  {
> @@ -888,6 +902,8 @@ static void qemu_spice_display_init_one(QemuConsole *con)
>          ssd->dcl.ops = &display_listener_gl_ops;
>          ssd->dmabuf_fd = -1;
>          ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
> +        ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
> +                                             qemu_spice_gl_block_timer, ssd);
>      }
>  #endif
>      ssd->dcl.con = con;
> --
> 1.8.3.1
>



-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Gerd Hoffmann]

On Fr, 2016-02-19 at 10:14 +0100, Gerd Hoffmann wrote:
> Current spice client expects we create a primary surface,
> even if we do display updates using dma-bufs exclusively.
> 
> So just do that to get things going.
> 
> Not fully clear whenever that is intentional or a bug on
> the spice side, so I keep this as separate patch for now.
> 
> I think this should either be squashed into the previous
> patch, or dropped after fixing things on the spice side.

Ping Marc?  Any comment on this?

thanks,
  Gerd

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Marc-André Lureau]

Hi

On Fri, Mar 18, 2016 at 2:17 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> Ping Marc?  Any comment on this?


Could you send a rebased series, for the patches that lead to the
issue? I assume "render DisplaySurface via opengl" patch?

-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Gerd Hoffmann]

On Fr, 2016-03-18 at 14:45 +0100, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Mar 18, 2016 at 2:17 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> > Ping Marc?  Any comment on this?
> 
> 
> Could you send a rebased series, for the patches that lead to the
> issue?

Update pushed to https://www.kraxel.org/cgit/qemu/log/?h=work/virgl
with some cherry-picks to fix nettle build issue and to sidestep
conflict with in-flight pull request.

That work better for testing.  I'll resent the patch series once the
temporary issues with master are settled.  There hasn't changed much in
the code though, other than rebasing and minor tweaks to adapt to the
include changes.

>  I assume "render DisplaySurface via opengl" patch?

Yes, that one.

cheers,
  Gerd

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Marc-André Lureau]

Hi

On Mon, Mar 21, 2016 at 11:24 AM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> On Fr, 2016-03-18 at 14:45 +0100, Marc-André Lureau wrote:
>> Hi
>>
>> On Fri, Mar 18, 2016 at 2:17 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
>> > Ping Marc?  Any comment on this?
>>
>>
>> Could you send a rebased series, for the patches that lead to the
>> issue?
>
> Update pushed to https://www.kraxel.org/cgit/qemu/log/?h=work/virgl
> with some cherry-picks to fix nettle build issue and to sidestep
> conflict with in-flight pull request.
>
> That work better for testing.  I'll resent the patch series once the
> temporary issues with master are settled.  There hasn't changed much in
> the code though, other than rebasing and minor tweaks to adapt to the
> include changes.
>
>>  I assume "render DisplaySurface via opengl" patch?
>
> Yes, that one.

I have done some more testing and sent a series for spice-gtk fixing
display with gl scanout-only case. And a minor patch to spice server
to solve a cursor initialization when there is no canvas. Your series
works ok with that, only when doing a reboot, virtio_gpu_virgl_reset()
calls spice_qxl_gl_scanout( fd = -1), and later spice_gl_refresh()
calls spice_qxl_gl_draw_async() and reaches the following error:

(process:21117): Spice-CRITICAL **:
red-qxl.c:900:spice_qxl_gl_draw_async: condition
`qxl_state->scanout.drm_dma_buf_fd != -1' failed


-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 11/12] spice: add & use qemu_spice_gl_monitor_config

[Marc-André Lureau]

Hi Gerd

On Fri, Feb 19, 2016 at 1:32 PM, Marc-André Lureau
<marcandre.lureau@gmail.com> wrote:
> Hi
>
> On Fri, Feb 19, 2016 at 10:14 AM, Gerd Hoffmann <kraxel@redhat.com> wrote:
>> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
>> ---
>>  include/ui/spice-display.h |  1 +
>>  ui/spice-display.c         | 30 ++++++++++++++++++++++++++++++
>>  2 files changed, 31 insertions(+)
>>
>
> Could eventually be squashed with "add opengl/virgl/dmabuf support" patch
>
> Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Sigh, too bad this wasn't actually picked or squashed with the series.
This is required for the spice client to know the area of the GL
surface to draw. (currently it also receives monitor config from
2d/QXL, which it associates to GL scanout when enabled, which results
in some clipping visible in virt-manager). Imho it would be worth to
include in 2.6.

>
>> diff --git a/include/ui/spice-display.h b/include/ui/spice-display.h
>> index dd9cf6f..f9388c2 100644
>> --- a/include/ui/spice-display.h
>> +++ b/include/ui/spice-display.h
>> @@ -71,6 +71,7 @@ typedef struct QXLCookie {
>>              QXLRect area;
>>              int redraw;
>>          } render;
>> +        void *data;
>>      } u;
>>  } QXLCookie;
>>
>> diff --git a/ui/spice-display.c b/ui/spice-display.c
>> index 96beb02..34e6d51 100644
>> --- a/ui/spice-display.c
>> +++ b/ui/spice-display.c
>> @@ -660,6 +660,11 @@ static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
>>          qemu_bh_schedule(ssd->gl_unblock_bh);
>>          break;
>>      }
>> +    case QXL_COOKIE_TYPE_IO:
>> +        if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
>> +            g_free(cookie->u.data);
>> +        }
>> +        break;
>>  #endif
>>      default:
>>          /* should never be called, used in qxl native mode only */
>> @@ -795,6 +800,29 @@ static const DisplayChangeListenerOps display_listener_ops = {
>>
>>  #ifdef HAVE_SPICE_GL
>>
>> +static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
>> +                                         int x, int y, int w, int h)
>> +{
>> +    QXLMonitorsConfig *config;
>> +    QXLCookie *cookie;
>> +
>> +    config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
>> +    config->count = 1;
>> +    config->max_allowed = 1;
>> +    config->heads[0].x = x;
>> +    config->heads[0].y = y;
>> +    config->heads[0].width = w;
>> +    config->heads[0].height = h;
>> +    cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
>> +                            QXL_IO_MONITORS_CONFIG_ASYNC);
>> +    cookie->u.data = config;
>> +
>> +    spice_qxl_monitors_config_async(&ssd->qxl,
>> +                                    (uintptr_t)config,
>> +                                    MEMSLOT_GROUP_HOST,
>> +                                    (uintptr_t)cookie);
>> +}
>> +
>>  static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
>>  {
>>      uint64_t timeout;
>> @@ -934,6 +962,8 @@ static void qemu_spice_gl_scanout(DisplayChangeListener *dcl,
>>                           surface_width(ssd->ds),
>>                           surface_height(ssd->ds),
>>                           stride, fourcc, y_0_top);
>> +
>> +    qemu_spice_gl_monitor_config(ssd, x, y, w, h);
>>  }
>>
>>  static void qemu_spice_gl_update(DisplayChangeListener *dcl,
>> --
>> 1.8.3.1
>>
>
>
>
> --
> Marc-André Lureau



-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Gerd Hoffmann]

  Hi,

Resuming to work on this after 2.6 freeze break ...

> I have done some more testing and sent a series for spice-gtk fixing
> display with gl scanout-only case. And a minor patch to spice server
> to solve a cursor initialization when there is no canvas. Your series
> works ok with that, only when doing a reboot, virtio_gpu_virgl_reset()
> calls spice_qxl_gl_scanout( fd = -1), and later spice_gl_refresh()
> calls spice_qxl_gl_draw_async() and reaches the following error:
> 
> (process:21117): Spice-CRITICAL **:
> red-qxl.c:900:spice_qxl_gl_draw_async: condition
> `qxl_state->scanout.drm_dma_buf_fd != -1' failed

Hmm, that is sort-of intentional.  It's valid for scanouts to not be
backed by a resource, and in that case qemu_spice_gl_scanout() calls
spice_qxl_gl_scanout() with fd=-1.

So, what do you think we should do here?  Fix spice to handle that case?
Should qemu do something else instead?  Such as not calling
spice_qxl_gl_scanout() to keep the previous dma-buf alive?

cheers,
  Gerd

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Marc-André Lureau]

Hi

On Mon, May 23, 2016 at 3:52 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
>   Hi,
>
> Resuming to work on this after 2.6 freeze break ...
>
>> I have done some more testing and sent a series for spice-gtk fixing
>> display with gl scanout-only case. And a minor patch to spice server
>> to solve a cursor initialization when there is no canvas. Your series
>> works ok with that, only when doing a reboot, virtio_gpu_virgl_reset()
>> calls spice_qxl_gl_scanout( fd = -1), and later spice_gl_refresh()
>> calls spice_qxl_gl_draw_async() and reaches the following error:
>>
>> (process:21117): Spice-CRITICAL **:
>> red-qxl.c:900:spice_qxl_gl_draw_async: condition
>> `qxl_state->scanout.drm_dma_buf_fd != -1' failed
>
> Hmm, that is sort-of intentional.  It's valid for scanouts to not be
> backed by a resource, and in that case qemu_spice_gl_scanout() calls
> spice_qxl_gl_scanout() with fd=-1.

Ok, then I suppose the display should be marked as non-ready, and the
client should reflect that (blank display or "not ready" message)

>
> So, what do you think we should do here?  Fix spice to handle that case?
> Should qemu do something else instead?  Such as not calling
> spice_qxl_gl_scanout() to keep the previous dma-buf alive?

I can't really make sense of a call to spice_qxl_gl_draw_async() if
there is no scanout backing. So I can imagine the fix is on qemu side.

Do you have an up to date branch for testing?

thanks



-- 
Marc-André Lureau

Re: [Qemu-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Gerd Hoffmann]

On Mo, 2016-05-23 at 16:03 +0200, Marc-André Lureau wrote:
> Hi
> 
> On Mon, May 23, 2016 at 3:52 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> >   Hi,
> >
> > Resuming to work on this after 2.6 freeze break ...
> >
> >> I have done some more testing and sent a series for spice-gtk fixing
> >> display with gl scanout-only case. And a minor patch to spice server
> >> to solve a cursor initialization when there is no canvas.

What is the upstream status of this?  Built a bunch of fresh packages
today, including new spice-server and spice-gtk from master branch.  And
a bunch spice-gtk dependencies, due to soname change.  Still not working
without the dummy primary surface.

> >> (process:21117): Spice-CRITICAL **:
> >> red-qxl.c:900:spice_qxl_gl_draw_async: condition
> >> `qxl_state->scanout.drm_dma_buf_fd != -1' failed

> I can't really make sense of a call to spice_qxl_gl_draw_async() if
> there is no scanout backing. So I can imagine the fix is on qemu side.

Indeed.  That one should be fixed now.

> Do you have an up to date branch for testing?

Pushed fresh branch to the usual work/virgl location.

cheers,
  Gerd

Re: [Qemu-devel] [Spice-devel] [PATCH v2 10/12] spice/gl: create dummy primary surface (RfC)

[Marc-André Lureau]

Hi

----- Original Message -----
> On Mo, 2016-05-23 at 16:03 +0200, Marc-André Lureau wrote:
> > Hi
> > 
> > On Mon, May 23, 2016 at 3:52 PM, Gerd Hoffmann <kraxel@redhat.com> wrote:
> > >   Hi,
> > >
> > > Resuming to work on this after 2.6 freeze break ...
> > >
> > >> I have done some more testing and sent a series for spice-gtk fixing
> > >> display with gl scanout-only case. And a minor patch to spice server
> > >> to solve a cursor initialization when there is no canvas.
> 
> What is the upstream status of this?  Built a bunch of fresh packages
> today, including new spice-server and spice-gtk from master branch.  And
> a bunch spice-gtk dependencies, due to soname change.  Still not working
> without the dummy primary surface.

spicy from master works for me. However I found an issue with virt-viewer, due to delayed widget realize in this gl-only case, see: https://lists.freedesktop.org/archives/spice-devel/2016-May/029446.html

> 
> > >> (process:21117): Spice-CRITICAL **:
> > >> red-qxl.c:900:spice_qxl_gl_draw_async: condition
> > >> `qxl_state->scanout.drm_dma_buf_fd != -1' failed
> 
> > I can't really make sense of a call to spice_qxl_gl_draw_async() if
> > there is no scanout backing. So I can imagine the fix is on qemu side.
> 
> Indeed.  That one should be fixed now.

Thanks

> 
> > Do you have an up to date branch for testing?
> 
> Pushed fresh branch to the usual work/virgl location.

I found a cursor issue, due to spice worker being idle, and this solves it: What do you think?

commit bae34dde7b229cc87347639ac34d835b80725e1f
Author: Marc-André Lureau <marcandre.lureau@redhat.com>
Date:   Tue May 24 20:34:05 2016 +0200

    spice: wakeup worker to pick up mouse changes
    
    Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

diff --git a/ui/spice-display.c b/ui/spice-display.c
index 5ed7630..a04432c 100644
--- a/ui/spice-display.c
+++ b/ui/spice-display.c
@@ -766,6 +766,7 @@ static void display_mouse_set(DisplayChangeListener *dcl,
     g_free(ssd->ptr_move);
     ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL, on);
     qemu_mutex_unlock(&ssd->lock);
+    qemu_spice_wakeup(ssd);
 }
 
 static void display_mouse_define(DisplayChangeListener *dcl,
@@ -784,6 +785,7 @@ static void display_mouse_define(DisplayChangeListener *dcl,
     g_free(ssd->ptr_define);
     ssd->ptr_define = qemu_spice_create_cursor_update(ssd, c, 0);
     qemu_mutex_unlock(&ssd->lock);
+    qemu_spice_wakeup(ssd);
 }
 
 static const DisplayChangeListenerOps display_listener_ops = {