xref: /openbmc/qemu/ui/dbus-listener.c (revision 05caa062)
1 /*
2  * QEMU DBus display console
3  *
4  * Copyright (c) 2021 Marc-André Lureau <marcandre.lureau@redhat.com>
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "qemu/osdep.h"
25 #include "qemu/error-report.h"
26 #include "qapi/error.h"
27 #include "sysemu/sysemu.h"
28 #include "dbus.h"
29 #ifdef G_OS_UNIX
30 #include <gio/gunixfdlist.h>
31 #endif
32 #ifdef WIN32
33 #include <d3d11.h>
34 #include <dxgi1_2.h>
35 #endif
36 
37 #ifdef CONFIG_OPENGL
38 #include "ui/shader.h"
39 #include "ui/egl-helpers.h"
40 #include "ui/egl-context.h"
41 #include "ui/qemu-pixman.h"
42 #endif
43 #include "trace.h"
44 
45 static void dbus_gfx_switch(DisplayChangeListener *dcl,
46                             struct DisplaySurface *new_surface);
47 
48 enum share_kind {
49     SHARE_KIND_NONE,
50     SHARE_KIND_MAPPED,
51     SHARE_KIND_D3DTEX,
52 };
53 
54 struct _DBusDisplayListener {
55     GObject parent;
56 
57     char *bus_name;
58     DBusDisplayConsole *console;
59     GDBusConnection *conn;
60 
61     QemuDBusDisplay1Listener *proxy;
62 
63 #ifdef CONFIG_PIXMAN
64     /* Keep track of the damage region */
65     pixman_region32_t gl_damage;
66 #else
67     int gl_damage;
68 #endif
69 
70     DisplayChangeListener dcl;
71     DisplaySurface *ds;
72     enum share_kind ds_share;
73 
74     bool ds_mapped;
75     bool can_share_map;
76 
77 #ifdef WIN32
78     QemuDBusDisplay1ListenerWin32Map *map_proxy;
79     QemuDBusDisplay1ListenerWin32D3d11 *d3d11_proxy;
80     HANDLE peer_process;
81     ID3D11Texture2D *d3d_texture;
82 #ifdef CONFIG_OPENGL
83     egl_fb fb;
84 #endif
85 #endif
86 
87     guint dbus_filter;
88     guint32 out_serial_to_discard;
89 };
90 
91 G_DEFINE_TYPE(DBusDisplayListener, dbus_display_listener, G_TYPE_OBJECT)
92 
93 static void dbus_gfx_update(DisplayChangeListener *dcl,
94                             int x, int y, int w, int h);
95 
96 static void ddl_discard_pending_messages(DBusDisplayListener *ddl)
97 {
98     ddl->out_serial_to_discard = g_dbus_connection_get_last_serial(
99         g_dbus_proxy_get_connection(G_DBUS_PROXY(ddl->proxy)));
100 }
101 
102 #ifdef CONFIG_OPENGL
103 static void dbus_scanout_disable(DisplayChangeListener *dcl)
104 {
105     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
106 
107     qemu_dbus_display1_listener_call_disable(
108         ddl->proxy, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
109 }
110 
111 #ifdef WIN32
112 static bool d3d_texture2d_share(ID3D11Texture2D *d3d_texture,
113                                 HANDLE *handle, Error **errp)
114 {
115     IDXGIResource1 *dxgiResource = NULL;
116     HRESULT hr;
117 
118     hr = d3d_texture->lpVtbl->QueryInterface(d3d_texture,
119                                              &IID_IDXGIResource1,
120                                              (void **)&dxgiResource);
121     if (FAILED(hr)) {
122         goto fail;
123     }
124 
125     hr = dxgiResource->lpVtbl->CreateSharedHandle(
126         dxgiResource,
127         NULL,
128         DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
129         NULL,
130         handle
131         );
132 
133     dxgiResource->lpVtbl->Release(dxgiResource);
134 
135     if (SUCCEEDED(hr)) {
136         return true;
137     }
138 
139 fail:
140     error_setg_win32(errp, GetLastError(), "failed to create shared handle");
141     return false;
142 }
143 
144 static bool d3d_texture2d_acquire0(ID3D11Texture2D *d3d_texture, Error **errp)
145 {
146     IDXGIKeyedMutex *dxgiMutex = NULL;
147     HRESULT hr;
148 
149     hr = d3d_texture->lpVtbl->QueryInterface(d3d_texture,
150                                              &IID_IDXGIKeyedMutex,
151                                              (void **)&dxgiMutex);
152     if (FAILED(hr)) {
153         goto fail;
154     }
155 
156     hr = dxgiMutex->lpVtbl->AcquireSync(dxgiMutex, 0, INFINITE);
157 
158     dxgiMutex->lpVtbl->Release(dxgiMutex);
159 
160     if (SUCCEEDED(hr)) {
161         return true;
162     }
163 
164 fail:
165     error_setg_win32(errp, GetLastError(), "failed to acquire texture mutex");
166     return false;
167 }
168 
169 static bool d3d_texture2d_release0(ID3D11Texture2D *d3d_texture, Error **errp)
170 {
171     IDXGIKeyedMutex *dxgiMutex = NULL;
172     HRESULT hr;
173 
174     hr = d3d_texture->lpVtbl->QueryInterface(d3d_texture,
175                                              &IID_IDXGIKeyedMutex,
176                                              (void **)&dxgiMutex);
177     if (FAILED(hr)) {
178         goto fail;
179     }
180 
181     hr = dxgiMutex->lpVtbl->ReleaseSync(dxgiMutex, 0);
182 
183     dxgiMutex->lpVtbl->Release(dxgiMutex);
184 
185     if (SUCCEEDED(hr)) {
186         return true;
187     }
188 
189 fail:
190     error_setg_win32(errp, GetLastError(), "failed to release texture mutex");
191     return false;
192 }
193 #endif /* WIN32 */
194 
195 #if defined(CONFIG_GBM) || defined(WIN32)
196 static void dbus_update_gl_cb(GObject *source_object,
197                               GAsyncResult *res,
198                               gpointer user_data)
199 {
200     g_autoptr(GError) err = NULL;
201     DBusDisplayListener *ddl = user_data;
202     bool success;
203 
204 #ifdef CONFIG_GBM
205     success = qemu_dbus_display1_listener_call_update_dmabuf_finish(
206         ddl->proxy, res, &err);
207 #endif
208 
209 #ifdef WIN32
210     success = qemu_dbus_display1_listener_win32_d3d11_call_update_texture2d_finish(
211         ddl->d3d11_proxy, res, &err);
212     d3d_texture2d_acquire0(ddl->d3d_texture, &error_warn);
213 #endif
214 
215     if (!success) {
216         error_report("Failed to call update: %s", err->message);
217     }
218 
219     graphic_hw_gl_block(ddl->dcl.con, false);
220     g_object_unref(ddl);
221 }
222 #endif
223 
224 static void dbus_call_update_gl(DisplayChangeListener *dcl,
225                                 int x, int y, int w, int h)
226 {
227 #if defined(CONFIG_GBM) || defined(WIN32)
228     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
229 #endif
230 
231     trace_dbus_update_gl(x, y, w, h);
232 
233     glFlush();
234 #ifdef CONFIG_GBM
235     graphic_hw_gl_block(ddl->dcl.con, true);
236     qemu_dbus_display1_listener_call_update_dmabuf(ddl->proxy,
237         x, y, w, h,
238         G_DBUS_CALL_FLAGS_NONE,
239         DBUS_DEFAULT_TIMEOUT, NULL,
240         dbus_update_gl_cb,
241         g_object_ref(ddl));
242 #endif
243 
244 #ifdef WIN32
245     switch (ddl->ds_share) {
246     case SHARE_KIND_MAPPED:
247         egl_fb_read_rect(ddl->ds, &ddl->fb, x, y, w, h);
248         dbus_gfx_update(dcl, x, y, w, h);
249         break;
250     case SHARE_KIND_D3DTEX: {
251         Error *err = NULL;
252         assert(ddl->d3d_texture);
253 
254         graphic_hw_gl_block(ddl->dcl.con, true);
255         if (!d3d_texture2d_release0(ddl->d3d_texture, &err)) {
256             error_report_err(err);
257             return;
258         }
259         qemu_dbus_display1_listener_win32_d3d11_call_update_texture2d(
260             ddl->d3d11_proxy,
261             x, y, w, h,
262             G_DBUS_CALL_FLAGS_NONE,
263             DBUS_DEFAULT_TIMEOUT, NULL,
264             dbus_update_gl_cb,
265             g_object_ref(ddl));
266         break;
267     }
268     default:
269         g_warn_if_reached();
270     }
271 #endif
272 }
273 
274 #ifdef CONFIG_GBM
275 static void dbus_scanout_dmabuf(DisplayChangeListener *dcl,
276                                 QemuDmaBuf *dmabuf)
277 {
278     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
279     g_autoptr(GError) err = NULL;
280     g_autoptr(GUnixFDList) fd_list = NULL;
281     int fd;
282     uint32_t width, height, stride, fourcc;
283     uint64_t modifier;
284     bool y0_top;
285 
286     fd = qemu_dmabuf_get_fd(dmabuf);
287     fd_list = g_unix_fd_list_new();
288     if (g_unix_fd_list_append(fd_list, fd, &err) != 0) {
289         error_report("Failed to setup dmabuf fdlist: %s", err->message);
290         return;
291     }
292 
293     ddl_discard_pending_messages(ddl);
294 
295     width = qemu_dmabuf_get_width(dmabuf);
296     height = qemu_dmabuf_get_height(dmabuf);
297     stride = qemu_dmabuf_get_stride(dmabuf);
298     fourcc = qemu_dmabuf_get_fourcc(dmabuf);
299     modifier = qemu_dmabuf_get_modifier(dmabuf);
300     y0_top = qemu_dmabuf_get_y0_top(dmabuf);
301 
302     /* FIXME: add missing x/y/w/h support */
303     qemu_dbus_display1_listener_call_scanout_dmabuf(
304         ddl->proxy, g_variant_new_handle(0),
305         width, height, stride, fourcc, modifier,
306         y0_top, G_DBUS_CALL_FLAGS_NONE,
307         -1, fd_list, NULL, NULL, NULL);
308 }
309 #endif /* GBM */
310 #endif /* OPENGL */
311 
312 #ifdef WIN32
313 static bool dbus_scanout_map(DBusDisplayListener *ddl)
314 {
315     g_autoptr(GError) err = NULL;
316     BOOL success;
317     HANDLE target_handle;
318 
319     if (ddl->ds_share == SHARE_KIND_MAPPED) {
320         return true;
321     }
322 
323     if (!ddl->can_share_map || !ddl->ds->handle) {
324         return false;
325     }
326 
327     success = DuplicateHandle(
328         GetCurrentProcess(),
329         ddl->ds->handle,
330         ddl->peer_process,
331         &target_handle,
332         FILE_MAP_READ | SECTION_QUERY,
333         FALSE, 0);
334     if (!success) {
335         g_autofree char *msg = g_win32_error_message(GetLastError());
336         g_debug("Failed to DuplicateHandle: %s", msg);
337         ddl->can_share_map = false;
338         return false;
339     }
340 
341     ddl_discard_pending_messages(ddl);
342 
343     if (!qemu_dbus_display1_listener_win32_map_call_scanout_map_sync(
344             ddl->map_proxy,
345             GPOINTER_TO_UINT(target_handle),
346             ddl->ds->handle_offset,
347             surface_width(ddl->ds),
348             surface_height(ddl->ds),
349             surface_stride(ddl->ds),
350             surface_format(ddl->ds),
351             G_DBUS_CALL_FLAGS_NONE,
352             DBUS_DEFAULT_TIMEOUT,
353             NULL,
354             &err)) {
355         g_debug("Failed to call ScanoutMap: %s", err->message);
356         ddl->can_share_map = false;
357         return false;
358     }
359 
360     ddl->ds_share = SHARE_KIND_MAPPED;
361 
362     return true;
363 }
364 
365 #ifdef CONFIG_OPENGL
366 static bool
367 dbus_scanout_share_d3d_texture(
368     DBusDisplayListener *ddl,
369     ID3D11Texture2D *tex,
370     bool backing_y_0_top,
371     uint32_t backing_width,
372     uint32_t backing_height,
373     uint32_t x, uint32_t y,
374     uint32_t w, uint32_t h)
375 {
376     Error *err = NULL;
377     BOOL success;
378     HANDLE share_handle, target_handle;
379 
380     if (!d3d_texture2d_release0(tex, &err)) {
381         error_report_err(err);
382         return false;
383     }
384 
385     if (!d3d_texture2d_share(tex, &share_handle, &err)) {
386         error_report_err(err);
387         return false;
388     }
389 
390     success = DuplicateHandle(
391         GetCurrentProcess(),
392         share_handle,
393         ddl->peer_process,
394         &target_handle,
395         0,
396         FALSE, DUPLICATE_SAME_ACCESS);
397     if (!success) {
398         g_autofree char *msg = g_win32_error_message(GetLastError());
399         g_debug("Failed to DuplicateHandle: %s", msg);
400         CloseHandle(share_handle);
401         return false;
402     }
403 
404     ddl_discard_pending_messages(ddl);
405 
406     qemu_dbus_display1_listener_win32_d3d11_call_scanout_texture2d(
407         ddl->d3d11_proxy,
408         GPOINTER_TO_INT(target_handle),
409         backing_width,
410         backing_height,
411         backing_y_0_top,
412         x, y, w, h,
413         G_DBUS_CALL_FLAGS_NONE,
414         -1,
415         NULL, NULL, NULL);
416 
417     CloseHandle(share_handle);
418 
419     if (!d3d_texture2d_acquire0(tex, &err)) {
420         error_report_err(err);
421         return false;
422     }
423 
424     ddl->d3d_texture = tex;
425     ddl->ds_share = SHARE_KIND_D3DTEX;
426 
427     return true;
428 }
429 #endif /* CONFIG_OPENGL */
430 #endif /* WIN32 */
431 
432 #ifdef CONFIG_OPENGL
433 static void dbus_scanout_texture(DisplayChangeListener *dcl,
434                                  uint32_t tex_id,
435                                  bool backing_y_0_top,
436                                  uint32_t backing_width,
437                                  uint32_t backing_height,
438                                  uint32_t x, uint32_t y,
439                                  uint32_t w, uint32_t h,
440                                  void *d3d_tex2d)
441 {
442     trace_dbus_scanout_texture(tex_id, backing_y_0_top,
443                                backing_width, backing_height, x, y, w, h);
444 #ifdef CONFIG_GBM
445     g_autoptr(QemuDmaBuf) dmabuf = NULL;
446     int fd;
447     uint32_t stride, fourcc;
448     uint64_t modifier;
449 
450     assert(tex_id);
451     fd = egl_get_fd_for_texture(tex_id, (EGLint *)&stride, (EGLint *)&fourcc,
452                                 &modifier);
453     if (fd < 0) {
454         error_report("%s: failed to get fd for texture", __func__);
455         return;
456     }
457     dmabuf = qemu_dmabuf_new(w, h, stride, x, y, backing_width,
458                              backing_height, fourcc, modifier, fd,
459                              false, backing_y_0_top);
460 
461     dbus_scanout_dmabuf(dcl, dmabuf);
462     qemu_dmabuf_close(dmabuf);
463 #endif
464 
465 #ifdef WIN32
466     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
467 
468     /* there must be a matching gfx_switch before */
469     assert(surface_width(ddl->ds) == w);
470     assert(surface_height(ddl->ds) == h);
471 
472     if (d3d_tex2d) {
473         dbus_scanout_share_d3d_texture(ddl, d3d_tex2d, backing_y_0_top,
474                                        backing_width, backing_height, x, y, w, h);
475     } else {
476         dbus_scanout_map(ddl);
477         egl_fb_setup_for_tex(&ddl->fb, backing_width, backing_height, tex_id, false);
478     }
479 #endif
480 }
481 
482 #ifdef CONFIG_GBM
483 static void dbus_cursor_dmabuf(DisplayChangeListener *dcl,
484                                QemuDmaBuf *dmabuf, bool have_hot,
485                                uint32_t hot_x, uint32_t hot_y)
486 {
487     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
488     DisplaySurface *ds;
489     GVariant *v_data = NULL;
490     egl_fb cursor_fb = EGL_FB_INIT;
491     uint32_t width, height, texture;
492 
493     if (!dmabuf) {
494         qemu_dbus_display1_listener_call_mouse_set(
495             ddl->proxy, 0, 0, false,
496             G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
497         return;
498     }
499 
500     egl_dmabuf_import_texture(dmabuf);
501     texture = qemu_dmabuf_get_texture(dmabuf);
502     if (!texture) {
503         return;
504     }
505 
506     width = qemu_dmabuf_get_width(dmabuf);
507     height = qemu_dmabuf_get_height(dmabuf);
508 
509     egl_fb_setup_for_tex(&cursor_fb, width, height, texture, false);
510     ds = qemu_create_displaysurface(width, height);
511     egl_fb_read(ds, &cursor_fb);
512 
513     v_data = g_variant_new_from_data(
514         G_VARIANT_TYPE("ay"),
515         surface_data(ds),
516         surface_width(ds) * surface_height(ds) * 4,
517         TRUE,
518         (GDestroyNotify)qemu_free_displaysurface,
519         ds);
520     qemu_dbus_display1_listener_call_cursor_define(
521         ddl->proxy,
522         surface_width(ds),
523         surface_height(ds),
524         hot_x,
525         hot_y,
526         v_data,
527         G_DBUS_CALL_FLAGS_NONE,
528         -1,
529         NULL,
530         NULL,
531         NULL);
532 }
533 
534 static void dbus_release_dmabuf(DisplayChangeListener *dcl,
535                                 QemuDmaBuf *dmabuf)
536 {
537     dbus_scanout_disable(dcl);
538 }
539 #endif /* GBM */
540 
541 static void dbus_gl_cursor_position(DisplayChangeListener *dcl,
542                                  uint32_t pos_x, uint32_t pos_y)
543 {
544     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
545 
546     qemu_dbus_display1_listener_call_mouse_set(
547         ddl->proxy, pos_x, pos_y, true,
548         G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
549 }
550 
551 static void dbus_scanout_update(DisplayChangeListener *dcl,
552                                 uint32_t x, uint32_t y,
553                                 uint32_t w, uint32_t h)
554 {
555     dbus_call_update_gl(dcl, x, y, w, h);
556 }
557 
558 static void dbus_gl_refresh(DisplayChangeListener *dcl)
559 {
560     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
561 
562     graphic_hw_update(dcl->con);
563 
564     if (!ddl->ds || qemu_console_is_gl_blocked(ddl->dcl.con)) {
565         return;
566     }
567 
568 #ifdef CONFIG_PIXMAN
569     int n_rects = pixman_region32_n_rects(&ddl->gl_damage);
570 
571     for (int i = 0; i < n_rects; i++) {
572         pixman_box32_t *box;
573         box = pixman_region32_rectangles(&ddl->gl_damage, NULL) + i;
574         /* TODO: Add a UpdateList call to send multiple updates at once */
575         dbus_call_update_gl(dcl, box->x1, box->y1,
576                             box->x2 - box->x1, box->y2 - box->y1);
577     }
578     pixman_region32_clear(&ddl->gl_damage);
579 #else
580     if (ddl->gl_damage) {
581         dbus_call_update_gl(dcl, 0, 0,
582                             surface_width(ddl->ds), surface_height(ddl->ds));
583         ddl->gl_damage = 0;
584     }
585 #endif
586 }
587 #endif /* OPENGL */
588 
589 static void dbus_refresh(DisplayChangeListener *dcl)
590 {
591     graphic_hw_update(dcl->con);
592 }
593 
594 #ifdef CONFIG_OPENGL
595 static void dbus_gl_gfx_update(DisplayChangeListener *dcl,
596                                int x, int y, int w, int h)
597 {
598     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
599 
600 #ifdef CONFIG_PIXMAN
601     pixman_region32_t rect_region;
602     pixman_region32_init_rect(&rect_region, x, y, w, h);
603     pixman_region32_union(&ddl->gl_damage, &ddl->gl_damage, &rect_region);
604     pixman_region32_fini(&rect_region);
605 #else
606     ddl->gl_damage++;
607 #endif
608 }
609 #endif
610 
611 static void dbus_gfx_update_sub(DBusDisplayListener *ddl,
612                                 int x, int y, int w, int h)
613 {
614     pixman_image_t *img;
615     size_t stride;
616     GVariant *v_data;
617 
618     /* make a copy, since gvariant only handles linear data */
619     stride = w * DIV_ROUND_UP(PIXMAN_FORMAT_BPP(surface_format(ddl->ds)), 8);
620     img = pixman_image_create_bits(surface_format(ddl->ds),
621                                    w, h, NULL, stride);
622 #ifdef CONFIG_PIXMAN
623     pixman_image_composite(PIXMAN_OP_SRC, ddl->ds->image, NULL, img,
624                            x, y, 0, 0, 0, 0, w, h);
625 #else
626     {
627         uint8_t *src = (uint8_t *)pixman_image_get_data(ddl->ds->image);
628         uint8_t *dst = (uint8_t *)pixman_image_get_data(img);
629         int bp = PIXMAN_FORMAT_BPP(surface_format(ddl->ds)) / 8;
630         int hh;
631 
632         for (hh = 0; hh < h; hh++) {
633             memcpy(&dst[stride * hh],
634                    &src[surface_stride(ddl->ds) * (hh + y) + x * bp],
635                    stride);
636         }
637     }
638 #endif
639     v_data = g_variant_new_from_data(
640         G_VARIANT_TYPE("ay"),
641         pixman_image_get_data(img),
642         pixman_image_get_stride(img) * h,
643         TRUE,
644         (GDestroyNotify)pixman_image_unref,
645         img);
646     qemu_dbus_display1_listener_call_update(ddl->proxy,
647         x, y, w, h, pixman_image_get_stride(img), pixman_image_get_format(img),
648         v_data,
649         G_DBUS_CALL_FLAGS_NONE,
650         DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
651 }
652 
653 static void ddl_scanout(DBusDisplayListener *ddl)
654 {
655     GVariant *v_data;
656 
657     v_data = g_variant_new_from_data(
658         G_VARIANT_TYPE("ay"), surface_data(ddl->ds),
659         surface_stride(ddl->ds) * surface_height(ddl->ds), TRUE,
660         (GDestroyNotify)pixman_image_unref, pixman_image_ref(ddl->ds->image));
661 
662     ddl_discard_pending_messages(ddl);
663 
664     qemu_dbus_display1_listener_call_scanout(
665         ddl->proxy, surface_width(ddl->ds), surface_height(ddl->ds),
666         surface_stride(ddl->ds), surface_format(ddl->ds), v_data,
667         G_DBUS_CALL_FLAGS_NONE, DBUS_DEFAULT_TIMEOUT, NULL, NULL,
668         g_object_ref(ddl));
669 }
670 
671 static void dbus_gfx_update(DisplayChangeListener *dcl,
672                             int x, int y, int w, int h)
673 {
674     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
675 
676     assert(ddl->ds);
677 
678     trace_dbus_update(x, y, w, h);
679 
680 #ifdef WIN32
681     if (dbus_scanout_map(ddl)) {
682         qemu_dbus_display1_listener_win32_map_call_update_map(
683             ddl->map_proxy,
684             x, y, w, h,
685             G_DBUS_CALL_FLAGS_NONE,
686             DBUS_DEFAULT_TIMEOUT, NULL, NULL, NULL);
687         return;
688     }
689 #endif
690 
691     if (x == 0 && y == 0 && w == surface_width(ddl->ds) && h == surface_height(ddl->ds)) {
692         return ddl_scanout(ddl);
693     }
694 
695     dbus_gfx_update_sub(ddl, x, y, w, h);
696 }
697 
698 #ifdef CONFIG_OPENGL
699 static void dbus_gl_gfx_switch(DisplayChangeListener *dcl,
700                                struct DisplaySurface *new_surface)
701 {
702     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
703 
704     trace_dbus_gl_gfx_switch(new_surface);
705 
706     ddl->ds = new_surface;
707     ddl->ds_share = SHARE_KIND_NONE;
708     if (ddl->ds) {
709         int width = surface_width(ddl->ds);
710         int height = surface_height(ddl->ds);
711 
712         /* TODO: lazy send dmabuf (there are unnecessary sent otherwise) */
713         dbus_scanout_texture(&ddl->dcl, ddl->ds->texture, false,
714                              width, height, 0, 0, width, height, NULL);
715     }
716 }
717 #endif
718 
719 static void dbus_gfx_switch(DisplayChangeListener *dcl,
720                             struct DisplaySurface *new_surface)
721 {
722     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
723 
724     ddl->ds = new_surface;
725     ddl->ds_share = SHARE_KIND_NONE;
726 }
727 
728 static void dbus_mouse_set(DisplayChangeListener *dcl,
729                            int x, int y, bool on)
730 {
731     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
732 
733     qemu_dbus_display1_listener_call_mouse_set(
734         ddl->proxy, x, y, on, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
735 }
736 
737 static void dbus_cursor_define(DisplayChangeListener *dcl,
738                                QEMUCursor *c)
739 {
740     DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
741     GVariant *v_data = NULL;
742 
743     v_data = g_variant_new_from_data(
744         G_VARIANT_TYPE("ay"),
745         c->data,
746         c->width * c->height * 4,
747         TRUE,
748         (GDestroyNotify)cursor_unref,
749         cursor_ref(c));
750 
751     qemu_dbus_display1_listener_call_cursor_define(
752         ddl->proxy,
753         c->width,
754         c->height,
755         c->hot_x,
756         c->hot_y,
757         v_data,
758         G_DBUS_CALL_FLAGS_NONE,
759         -1,
760         NULL,
761         NULL,
762         NULL);
763 }
764 
765 #ifdef CONFIG_OPENGL
766 const DisplayChangeListenerOps dbus_gl_dcl_ops = {
767     .dpy_name                = "dbus-gl",
768     .dpy_gfx_update          = dbus_gl_gfx_update,
769     .dpy_gfx_switch          = dbus_gl_gfx_switch,
770     .dpy_gfx_check_format    = console_gl_check_format,
771     .dpy_refresh             = dbus_gl_refresh,
772     .dpy_mouse_set           = dbus_mouse_set,
773     .dpy_cursor_define       = dbus_cursor_define,
774 
775     .dpy_gl_scanout_disable  = dbus_scanout_disable,
776     .dpy_gl_scanout_texture  = dbus_scanout_texture,
777 #ifdef CONFIG_GBM
778     .dpy_gl_scanout_dmabuf   = dbus_scanout_dmabuf,
779     .dpy_gl_cursor_dmabuf    = dbus_cursor_dmabuf,
780     .dpy_gl_release_dmabuf   = dbus_release_dmabuf,
781 #endif
782     .dpy_gl_cursor_position  = dbus_gl_cursor_position,
783     .dpy_gl_update           = dbus_scanout_update,
784 };
785 #endif
786 
787 const DisplayChangeListenerOps dbus_dcl_ops = {
788     .dpy_name                = "dbus",
789     .dpy_gfx_update          = dbus_gfx_update,
790     .dpy_gfx_switch          = dbus_gfx_switch,
791     .dpy_refresh             = dbus_refresh,
792     .dpy_mouse_set           = dbus_mouse_set,
793     .dpy_cursor_define       = dbus_cursor_define,
794 };
795 
796 static void
797 dbus_display_listener_dispose(GObject *object)
798 {
799     DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);
800 
801     unregister_displaychangelistener(&ddl->dcl);
802     g_clear_object(&ddl->conn);
803     g_clear_pointer(&ddl->bus_name, g_free);
804     g_clear_object(&ddl->proxy);
805 #ifdef WIN32
806     g_clear_object(&ddl->map_proxy);
807     g_clear_object(&ddl->d3d11_proxy);
808     g_clear_pointer(&ddl->peer_process, CloseHandle);
809 #ifdef CONFIG_PIXMAN
810     pixman_region32_fini(&ddl->gl_damage);
811 #endif
812 #ifdef CONFIG_OPENGL
813     egl_fb_destroy(&ddl->fb);
814 #endif
815 #endif
816 
817     G_OBJECT_CLASS(dbus_display_listener_parent_class)->dispose(object);
818 }
819 
820 static void
821 dbus_display_listener_constructed(GObject *object)
822 {
823     DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(object);
824 
825     ddl->dcl.ops = &dbus_dcl_ops;
826 #ifdef CONFIG_OPENGL
827     if (display_opengl) {
828         ddl->dcl.ops = &dbus_gl_dcl_ops;
829     }
830 #endif
831 
832     G_OBJECT_CLASS(dbus_display_listener_parent_class)->constructed(object);
833 }
834 
835 static void
836 dbus_display_listener_class_init(DBusDisplayListenerClass *klass)
837 {
838     GObjectClass *object_class = G_OBJECT_CLASS(klass);
839 
840     object_class->dispose = dbus_display_listener_dispose;
841     object_class->constructed = dbus_display_listener_constructed;
842 }
843 
844 static void
845 dbus_display_listener_init(DBusDisplayListener *ddl)
846 {
847 #ifdef CONFIG_PIXMAN
848     pixman_region32_init(&ddl->gl_damage);
849 #endif
850 }
851 
852 const char *
853 dbus_display_listener_get_bus_name(DBusDisplayListener *ddl)
854 {
855     return ddl->bus_name ?: "p2p";
856 }
857 
858 DBusDisplayConsole *
859 dbus_display_listener_get_console(DBusDisplayListener *ddl)
860 {
861     return ddl->console;
862 }
863 
864 #ifdef WIN32
865 static bool
866 dbus_display_listener_implements(DBusDisplayListener *ddl, const char *iface)
867 {
868     QemuDBusDisplay1Listener *l = QEMU_DBUS_DISPLAY1_LISTENER(ddl->proxy);
869     bool implements;
870 
871     implements = g_strv_contains(qemu_dbus_display1_listener_get_interfaces(l), iface);
872     if (!implements) {
873         g_debug("Display listener does not implement: `%s`", iface);
874     }
875 
876     return implements;
877 }
878 
879 static bool
880 dbus_display_listener_setup_peer_process(DBusDisplayListener *ddl)
881 {
882     g_autoptr(GError) err = NULL;
883     GDBusConnection *conn;
884     GIOStream *stream;
885     GSocket *sock;
886     g_autoptr(GCredentials) creds = NULL;
887     DWORD *pid;
888 
889     if (ddl->peer_process) {
890         return true;
891     }
892 
893     conn = g_dbus_proxy_get_connection(G_DBUS_PROXY(ddl->proxy));
894     stream = g_dbus_connection_get_stream(conn);
895 
896     if (!G_IS_UNIX_CONNECTION(stream)) {
897         return false;
898     }
899 
900     sock = g_socket_connection_get_socket(G_SOCKET_CONNECTION(stream));
901     creds = g_socket_get_credentials(sock, &err);
902 
903     if (!creds) {
904         g_debug("Failed to get peer credentials: %s", err->message);
905         return false;
906     }
907 
908     pid = g_credentials_get_native(creds, G_CREDENTIALS_TYPE_WIN32_PID);
909 
910     if (pid == NULL) {
911         g_debug("Failed to get peer PID");
912         return false;
913     }
914 
915     ddl->peer_process = OpenProcess(
916         PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION,
917         false, *pid);
918 
919     if (!ddl->peer_process) {
920         g_autofree char *msg = g_win32_error_message(GetLastError());
921         g_debug("Failed to OpenProcess: %s", msg);
922         return false;
923     }
924 
925     return true;
926 }
927 #endif
928 
929 static void
930 dbus_display_listener_setup_d3d11(DBusDisplayListener *ddl)
931 {
932 #ifdef WIN32
933     g_autoptr(GError) err = NULL;
934 
935     if (!dbus_display_listener_implements(ddl,
936             "org.qemu.Display1.Listener.Win32.D3d11")) {
937         return;
938     }
939 
940     if (!dbus_display_listener_setup_peer_process(ddl)) {
941         return;
942     }
943 
944     ddl->d3d11_proxy =
945         qemu_dbus_display1_listener_win32_d3d11_proxy_new_sync(ddl->conn,
946             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
947             NULL,
948             "/org/qemu/Display1/Listener",
949             NULL,
950             &err);
951     if (!ddl->d3d11_proxy) {
952         g_debug("Failed to setup win32 d3d11 proxy: %s", err->message);
953         return;
954     }
955 #endif
956 }
957 
958 static void
959 dbus_display_listener_setup_shared_map(DBusDisplayListener *ddl)
960 {
961 #ifdef WIN32
962     g_autoptr(GError) err = NULL;
963 
964     if (!dbus_display_listener_implements(ddl, "org.qemu.Display1.Listener.Win32.Map")) {
965         return;
966     }
967 
968     if (!dbus_display_listener_setup_peer_process(ddl)) {
969         return;
970     }
971 
972     ddl->map_proxy =
973         qemu_dbus_display1_listener_win32_map_proxy_new_sync(ddl->conn,
974             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
975             NULL,
976             "/org/qemu/Display1/Listener",
977             NULL,
978             &err);
979     if (!ddl->map_proxy) {
980         g_debug("Failed to setup win32 map proxy: %s", err->message);
981         return;
982     }
983 
984     ddl->can_share_map = true;
985 #endif
986 }
987 
988 static GDBusMessage *
989 dbus_filter(GDBusConnection *connection,
990             GDBusMessage    *message,
991             gboolean         incoming,
992             gpointer         user_data)
993 {
994     DBusDisplayListener *ddl = DBUS_DISPLAY_LISTENER(user_data);
995     guint32 serial;
996 
997     if (incoming) {
998         return message;
999     }
1000 
1001     serial = g_dbus_message_get_serial(message);
1002     if (serial <= ddl->out_serial_to_discard) {
1003         trace_dbus_filter(serial, ddl->out_serial_to_discard);
1004         return NULL;
1005     }
1006 
1007     return message;
1008 }
1009 
1010 DBusDisplayListener *
1011 dbus_display_listener_new(const char *bus_name,
1012                           GDBusConnection *conn,
1013                           DBusDisplayConsole *console)
1014 {
1015     DBusDisplayListener *ddl;
1016     QemuConsole *con;
1017     g_autoptr(GError) err = NULL;
1018 
1019     ddl = g_object_new(DBUS_DISPLAY_TYPE_LISTENER, NULL);
1020     ddl->proxy =
1021         qemu_dbus_display1_listener_proxy_new_sync(conn,
1022             G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
1023             NULL,
1024             "/org/qemu/Display1/Listener",
1025             NULL,
1026             &err);
1027     if (!ddl->proxy) {
1028         error_report("Failed to setup proxy: %s", err->message);
1029         g_object_unref(conn);
1030         g_object_unref(ddl);
1031         return NULL;
1032     }
1033 
1034     ddl->dbus_filter = g_dbus_connection_add_filter(conn, dbus_filter, g_object_ref(ddl), g_object_unref);
1035     ddl->bus_name = g_strdup(bus_name);
1036     ddl->conn = conn;
1037     ddl->console = console;
1038 
1039     dbus_display_listener_setup_shared_map(ddl);
1040     dbus_display_listener_setup_d3d11(ddl);
1041 
1042     con = qemu_console_lookup_by_index(dbus_display_console_get_index(console));
1043     assert(con);
1044     ddl->dcl.con = con;
1045     register_displaychangelistener(&ddl->dcl);
1046 
1047     return ddl;
1048 }
1049