xref: /openbmc/qemu/ui/spice-display.c (revision ffe98631)
1 /*
2  * Copyright (C) 2010 Red Hat, Inc.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 or
7  * (at your option) version 3 of the License.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include "qemu/osdep.h"
19 #include "ui/qemu-spice.h"
20 #include "qemu/timer.h"
21 #include "qemu/lockable.h"
22 #include "qemu/main-loop.h"
23 #include "qemu/option.h"
24 #include "qemu/queue.h"
25 #include "ui/console.h"
26 #include "trace.h"
27 
28 #include "ui/spice-display.h"
29 
30 bool spice_opengl;
31 
32 int qemu_spice_rect_is_empty(const QXLRect* r)
33 {
34     return r->top == r->bottom || r->left == r->right;
35 }
36 
37 void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
38 {
39     if (qemu_spice_rect_is_empty(r)) {
40         return;
41     }
42 
43     if (qemu_spice_rect_is_empty(dest)) {
44         *dest = *r;
45         return;
46     }
47 
48     dest->top = MIN(dest->top, r->top);
49     dest->left = MIN(dest->left, r->left);
50     dest->bottom = MAX(dest->bottom, r->bottom);
51     dest->right = MAX(dest->right, r->right);
52 }
53 
54 QXLCookie *qxl_cookie_new(int type, uint64_t io)
55 {
56     QXLCookie *cookie;
57 
58     cookie = g_malloc0(sizeof(*cookie));
59     cookie->type = type;
60     cookie->io = io;
61     return cookie;
62 }
63 
64 void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
65                             qxl_async_io async)
66 {
67     trace_qemu_spice_add_memslot(ssd->qxl.id, memslot->slot_id,
68                                 memslot->virt_start, memslot->virt_end,
69                                 async);
70 
71     if (async != QXL_SYNC) {
72         spice_qxl_add_memslot_async(&ssd->qxl, memslot,
73                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
74                                           QXL_IO_MEMSLOT_ADD_ASYNC));
75     } else {
76         spice_qxl_add_memslot(&ssd->qxl, memslot);
77     }
78 }
79 
80 void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
81 {
82     trace_qemu_spice_del_memslot(ssd->qxl.id, gid, sid);
83     spice_qxl_del_memslot(&ssd->qxl, gid, sid);
84 }
85 
86 void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
87                                        QXLDevSurfaceCreate *surface,
88                                        qxl_async_io async)
89 {
90     trace_qemu_spice_create_primary_surface(ssd->qxl.id, id, surface, async);
91     if (async != QXL_SYNC) {
92         spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface,
93                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
94                                           QXL_IO_CREATE_PRIMARY_ASYNC));
95     } else {
96         spice_qxl_create_primary_surface(&ssd->qxl, id, surface);
97     }
98 }
99 
100 void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
101                                         uint32_t id, qxl_async_io async)
102 {
103     trace_qemu_spice_destroy_primary_surface(ssd->qxl.id, id, async);
104     if (async != QXL_SYNC) {
105         spice_qxl_destroy_primary_surface_async(&ssd->qxl, id,
106                 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
107                                           QXL_IO_DESTROY_PRIMARY_ASYNC));
108     } else {
109         spice_qxl_destroy_primary_surface(&ssd->qxl, id);
110     }
111 }
112 
113 void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
114 {
115     trace_qemu_spice_wakeup(ssd->qxl.id);
116     spice_qxl_wakeup(&ssd->qxl);
117 }
118 
119 static void qemu_spice_create_one_update(SimpleSpiceDisplay *ssd,
120                                          QXLRect *rect)
121 {
122     SimpleSpiceUpdate *update;
123     QXLDrawable *drawable;
124     QXLImage *image;
125     QXLCommand *cmd;
126     int bw, bh;
127     struct timespec time_space;
128     pixman_image_t *dest;
129 
130     trace_qemu_spice_create_update(
131            rect->left, rect->right,
132            rect->top, rect->bottom);
133 
134     update   = g_malloc0(sizeof(*update));
135     drawable = &update->drawable;
136     image    = &update->image;
137     cmd      = &update->ext.cmd;
138 
139     bw       = rect->right - rect->left;
140     bh       = rect->bottom - rect->top;
141     update->bitmap = g_malloc(bw * bh * 4);
142 
143     drawable->bbox            = *rect;
144     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
145     drawable->effect          = QXL_EFFECT_OPAQUE;
146     drawable->release_info.id = (uintptr_t)(&update->ext);
147     drawable->type            = QXL_DRAW_COPY;
148     drawable->surfaces_dest[0] = -1;
149     drawable->surfaces_dest[1] = -1;
150     drawable->surfaces_dest[2] = -1;
151     clock_gettime(CLOCK_MONOTONIC, &time_space);
152     /* time in milliseconds from epoch. */
153     drawable->mm_time = time_space.tv_sec * 1000
154                       + time_space.tv_nsec / 1000 / 1000;
155 
156     drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
157     drawable->u.copy.src_bitmap      = (uintptr_t)image;
158     drawable->u.copy.src_area.right  = bw;
159     drawable->u.copy.src_area.bottom = bh;
160 
161     QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
162     image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
163     image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
164     image->bitmap.stride     = bw * 4;
165     image->descriptor.width  = image->bitmap.x = bw;
166     image->descriptor.height = image->bitmap.y = bh;
167     image->bitmap.data = (uintptr_t)(update->bitmap);
168     image->bitmap.palette = 0;
169     image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
170 
171     dest = pixman_image_create_bits(PIXMAN_LE_x8r8g8b8, bw, bh,
172                                     (void *)update->bitmap, bw * 4);
173     pixman_image_composite(PIXMAN_OP_SRC, ssd->surface, NULL, ssd->mirror,
174                            rect->left, rect->top, 0, 0,
175                            rect->left, rect->top, bw, bh);
176     pixman_image_composite(PIXMAN_OP_SRC, ssd->mirror, NULL, dest,
177                            rect->left, rect->top, 0, 0,
178                            0, 0, bw, bh);
179     pixman_image_unref(dest);
180 
181     cmd->type = QXL_CMD_DRAW;
182     cmd->data = (uintptr_t)drawable;
183 
184     QTAILQ_INSERT_TAIL(&ssd->updates, update, next);
185 }
186 
187 static void qemu_spice_create_update(SimpleSpiceDisplay *ssd)
188 {
189     static const int blksize = 32;
190     int blocks = DIV_ROUND_UP(surface_width(ssd->ds), blksize);
191     int dirty_top[blocks];
192     int y, yoff1, yoff2, x, xoff, blk, bw;
193     int bpp = surface_bytes_per_pixel(ssd->ds);
194     uint8_t *guest, *mirror;
195 
196     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
197         return;
198     };
199 
200     for (blk = 0; blk < blocks; blk++) {
201         dirty_top[blk] = -1;
202     }
203 
204     guest = surface_data(ssd->ds);
205     mirror = (void *)pixman_image_get_data(ssd->mirror);
206     for (y = ssd->dirty.top; y < ssd->dirty.bottom; y++) {
207         yoff1 = y * surface_stride(ssd->ds);
208         yoff2 = y * pixman_image_get_stride(ssd->mirror);
209         for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
210             xoff = x * bpp;
211             blk = x / blksize;
212             bw = MIN(blksize, ssd->dirty.right - x);
213             if (memcmp(guest + yoff1 + xoff,
214                        mirror + yoff2 + xoff,
215                        bw * bpp) == 0) {
216                 if (dirty_top[blk] != -1) {
217                     QXLRect update = {
218                         .top    = dirty_top[blk],
219                         .bottom = y,
220                         .left   = x,
221                         .right  = x + bw,
222                     };
223                     qemu_spice_create_one_update(ssd, &update);
224                     dirty_top[blk] = -1;
225                 }
226             } else {
227                 if (dirty_top[blk] == -1) {
228                     dirty_top[blk] = y;
229                 }
230             }
231         }
232     }
233 
234     for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
235         blk = x / blksize;
236         bw = MIN(blksize, ssd->dirty.right - x);
237         if (dirty_top[blk] != -1) {
238             QXLRect update = {
239                 .top    = dirty_top[blk],
240                 .bottom = ssd->dirty.bottom,
241                 .left   = x,
242                 .right  = x + bw,
243             };
244             qemu_spice_create_one_update(ssd, &update);
245             dirty_top[blk] = -1;
246         }
247     }
248 
249     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
250 }
251 
252 static SimpleSpiceCursor*
253 qemu_spice_create_cursor_update(SimpleSpiceDisplay *ssd,
254                                 QEMUCursor *c,
255                                 int on)
256 {
257     size_t size = c ? c->width * c->height * 4 : 0;
258     SimpleSpiceCursor *update;
259     QXLCursorCmd *ccmd;
260     QXLCursor *cursor;
261     QXLCommand *cmd;
262 
263     update   = g_malloc0(sizeof(*update) + size);
264     ccmd     = &update->cmd;
265     cursor   = &update->cursor;
266     cmd      = &update->ext.cmd;
267 
268     if (c) {
269         ccmd->type = QXL_CURSOR_SET;
270         ccmd->u.set.position.x = ssd->ptr_x + ssd->hot_x;
271         ccmd->u.set.position.y = ssd->ptr_y + ssd->hot_y;
272         ccmd->u.set.visible    = true;
273         ccmd->u.set.shape      = (uintptr_t)cursor;
274         cursor->header.unique     = ssd->unique++;
275         cursor->header.type       = SPICE_CURSOR_TYPE_ALPHA;
276         cursor->header.width      = c->width;
277         cursor->header.height     = c->height;
278         cursor->header.hot_spot_x = c->hot_x;
279         cursor->header.hot_spot_y = c->hot_y;
280         cursor->data_size         = size;
281         cursor->chunk.data_size   = size;
282         memcpy(cursor->chunk.data, c->data, size);
283     } else if (!on) {
284         ccmd->type = QXL_CURSOR_HIDE;
285     } else {
286         ccmd->type = QXL_CURSOR_MOVE;
287         ccmd->u.position.x = ssd->ptr_x + ssd->hot_x;
288         ccmd->u.position.y = ssd->ptr_y + ssd->hot_y;
289     }
290     ccmd->release_info.id = (uintptr_t)(&update->ext);
291 
292     cmd->type = QXL_CMD_CURSOR;
293     cmd->data = (uintptr_t)ccmd;
294 
295     return update;
296 }
297 
298 /*
299  * Called from spice server thread context (via interface_release_resource)
300  * We do *not* hold the global qemu mutex here, so extra care is needed
301  * when calling qemu functions.  QEMU interfaces used:
302  *    - g_free (underlying glibc free is re-entrant).
303  */
304 void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
305 {
306     g_free(update->bitmap);
307     g_free(update);
308 }
309 
310 void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
311 {
312     QXLDevMemSlot memslot;
313 
314     memset(&memslot, 0, sizeof(memslot));
315     memslot.slot_group_id = MEMSLOT_GROUP_HOST;
316     memslot.virt_end = ~0;
317     qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
318 }
319 
320 void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
321 {
322     QXLDevSurfaceCreate surface;
323     uint64_t surface_size;
324 
325     memset(&surface, 0, sizeof(surface));
326 
327     surface_size = (uint64_t) surface_width(ssd->ds) *
328         surface_height(ssd->ds) * 4;
329     assert(surface_size > 0);
330     assert(surface_size < INT_MAX);
331     if (ssd->bufsize < surface_size) {
332         ssd->bufsize = surface_size;
333         g_free(ssd->buf);
334         ssd->buf = g_malloc(ssd->bufsize);
335     }
336 
337     surface.format     = SPICE_SURFACE_FMT_32_xRGB;
338     surface.width      = surface_width(ssd->ds);
339     surface.height     = surface_height(ssd->ds);
340     surface.stride     = -surface.width * 4;
341     surface.mouse_mode = true;
342     surface.flags      = 0;
343     surface.type       = 0;
344     surface.mem        = (uintptr_t)ssd->buf;
345     surface.group_id   = MEMSLOT_GROUP_HOST;
346 
347     qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
348 }
349 
350 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
351 {
352     qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
353 }
354 
355 void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd)
356 {
357     qemu_mutex_init(&ssd->lock);
358     QTAILQ_INIT(&ssd->updates);
359     ssd->mouse_x = -1;
360     ssd->mouse_y = -1;
361     if (ssd->num_surfaces == 0) {
362         ssd->num_surfaces = 1024;
363     }
364 }
365 
366 /* display listener callbacks */
367 
368 void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
369                                int x, int y, int w, int h)
370 {
371     QXLRect update_area;
372 
373     trace_qemu_spice_display_update(ssd->qxl.id, x, y, w, h);
374     update_area.left = x,
375     update_area.right = x + w;
376     update_area.top = y;
377     update_area.bottom = y + h;
378 
379     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
380         ssd->notify++;
381     }
382     qemu_spice_rect_union(&ssd->dirty, &update_area);
383 }
384 
385 void qemu_spice_display_switch(SimpleSpiceDisplay *ssd,
386                                DisplaySurface *surface)
387 {
388     SimpleSpiceUpdate *update;
389     bool need_destroy;
390 
391     if (ssd->surface &&
392         surface_width(surface) == pixman_image_get_width(ssd->surface) &&
393         surface_height(surface) == pixman_image_get_height(ssd->surface) &&
394         surface_format(surface) == pixman_image_get_format(ssd->surface)) {
395         /* no-resize fast path: just swap backing store */
396         trace_qemu_spice_display_surface(ssd->qxl.id,
397                                          surface_width(surface),
398                                          surface_height(surface),
399                                          true);
400         qemu_mutex_lock(&ssd->lock);
401         ssd->ds = surface;
402         pixman_image_unref(ssd->surface);
403         ssd->surface = pixman_image_ref(ssd->ds->image);
404         qemu_mutex_unlock(&ssd->lock);
405         qemu_spice_display_update(ssd, 0, 0,
406                                   surface_width(surface),
407                                   surface_height(surface));
408         return;
409     }
410 
411     /* full mode switch */
412     trace_qemu_spice_display_surface(ssd->qxl.id,
413                                      surface_width(surface),
414                                      surface_height(surface),
415                                      false);
416 
417     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
418     if (ssd->surface) {
419         pixman_image_unref(ssd->surface);
420         ssd->surface = NULL;
421         pixman_image_unref(ssd->mirror);
422         ssd->mirror = NULL;
423     }
424 
425     qemu_mutex_lock(&ssd->lock);
426     need_destroy = (ssd->ds != NULL);
427     ssd->ds = surface;
428     while ((update = QTAILQ_FIRST(&ssd->updates)) != NULL) {
429         QTAILQ_REMOVE(&ssd->updates, update, next);
430         qemu_spice_destroy_update(ssd, update);
431     }
432     qemu_mutex_unlock(&ssd->lock);
433     if (need_destroy) {
434         qemu_spice_destroy_host_primary(ssd);
435     }
436     if (ssd->ds) {
437         ssd->surface = pixman_image_ref(ssd->ds->image);
438         ssd->mirror  = qemu_pixman_mirror_create(ssd->ds->format,
439                                                  ssd->ds->image);
440         qemu_spice_create_host_primary(ssd);
441     }
442 
443     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
444     ssd->notify++;
445 
446     qemu_mutex_lock(&ssd->lock);
447     if (ssd->cursor) {
448         g_free(ssd->ptr_define);
449         ssd->ptr_define = qemu_spice_create_cursor_update(ssd, ssd->cursor, 0);
450     }
451     qemu_mutex_unlock(&ssd->lock);
452 }
453 
454 void qemu_spice_cursor_refresh_bh(void *opaque)
455 {
456     SimpleSpiceDisplay *ssd = opaque;
457 
458     qemu_mutex_lock(&ssd->lock);
459     if (ssd->cursor) {
460         QEMUCursor *c = ssd->cursor;
461         assert(ssd->dcl.con);
462         cursor_get(c);
463         qemu_mutex_unlock(&ssd->lock);
464         dpy_cursor_define(ssd->dcl.con, c);
465         qemu_mutex_lock(&ssd->lock);
466         cursor_put(c);
467     }
468 
469     if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
470         int x, y;
471         assert(ssd->dcl.con);
472         x = ssd->mouse_x;
473         y = ssd->mouse_y;
474         ssd->mouse_x = -1;
475         ssd->mouse_y = -1;
476         qemu_mutex_unlock(&ssd->lock);
477         dpy_mouse_set(ssd->dcl.con, x, y, 1);
478     } else {
479         qemu_mutex_unlock(&ssd->lock);
480     }
481 }
482 
483 void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
484 {
485     graphic_hw_update(ssd->dcl.con);
486 
487     WITH_QEMU_LOCK_GUARD(&ssd->lock) {
488         if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {
489             qemu_spice_create_update(ssd);
490             ssd->notify++;
491         }
492     }
493 
494     trace_qemu_spice_display_refresh(ssd->qxl.id, ssd->notify);
495     if (ssd->notify) {
496         ssd->notify = 0;
497         qemu_spice_wakeup(ssd);
498     }
499 }
500 
501 /* spice display interface callbacks */
502 
503 #if SPICE_HAS_ATTACHED_WORKER
504 static void interface_attached_worker(QXLInstance *sin)
505 {
506     /* nothing to do */
507 }
508 #else
509 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
510 {
511     /* nothing to do */
512 }
513 #endif
514 
515 static void interface_set_compression_level(QXLInstance *sin, int level)
516 {
517     /* nothing to do */
518 }
519 
520 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
521 {
522     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
523 
524     info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
525     info->memslot_id_bits  = MEMSLOT_SLOT_BITS;
526     info->num_memslots = NUM_MEMSLOTS;
527     info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
528     info->internal_groupslot_id = 0;
529     info->qxl_ram_size = 16 * 1024 * 1024;
530     info->n_surfaces = ssd->num_surfaces;
531 }
532 
533 static int interface_get_command(QXLInstance *sin, QXLCommandExt *ext)
534 {
535     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
536     SimpleSpiceUpdate *update;
537     int ret = false;
538 
539     qemu_mutex_lock(&ssd->lock);
540     update = QTAILQ_FIRST(&ssd->updates);
541     if (update != NULL) {
542         QTAILQ_REMOVE(&ssd->updates, update, next);
543         *ext = update->ext;
544         ret = true;
545     }
546     qemu_mutex_unlock(&ssd->lock);
547 
548     return ret;
549 }
550 
551 static int interface_req_cmd_notification(QXLInstance *sin)
552 {
553     return 1;
554 }
555 
556 static void interface_release_resource(QXLInstance *sin,
557                                        QXLReleaseInfoExt rext)
558 {
559     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
560     SimpleSpiceUpdate *update;
561     SimpleSpiceCursor *cursor;
562     QXLCommandExt *ext;
563 
564     if (!rext.info) {
565         return;
566     }
567 
568     ext = (void *)(intptr_t)(rext.info->id);
569     switch (ext->cmd.type) {
570     case QXL_CMD_DRAW:
571         update = container_of(ext, SimpleSpiceUpdate, ext);
572         qemu_spice_destroy_update(ssd, update);
573         break;
574     case QXL_CMD_CURSOR:
575         cursor = container_of(ext, SimpleSpiceCursor, ext);
576         g_free(cursor);
577         break;
578     default:
579         g_assert_not_reached();
580     }
581 }
582 
583 static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)
584 {
585     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
586     int ret;
587 
588     QEMU_LOCK_GUARD(&ssd->lock);
589     if (ssd->ptr_define) {
590         *ext = ssd->ptr_define->ext;
591         ssd->ptr_define = NULL;
592         ret = true;
593     } else if (ssd->ptr_move) {
594         *ext = ssd->ptr_move->ext;
595         ssd->ptr_move = NULL;
596         ret = true;
597     } else {
598         ret = false;
599     }
600     return ret;
601 }
602 
603 static int interface_req_cursor_notification(QXLInstance *sin)
604 {
605     return 1;
606 }
607 
608 static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
609 {
610     fprintf(stderr, "%s: abort()\n", __func__);
611     abort();
612 }
613 
614 static int interface_flush_resources(QXLInstance *sin)
615 {
616     fprintf(stderr, "%s: abort()\n", __func__);
617     abort();
618     return 0;
619 }
620 
621 static void interface_update_area_complete(QXLInstance *sin,
622         uint32_t surface_id,
623         QXLRect *dirty, uint32_t num_updated_rects)
624 {
625     /* should never be called, used in qxl native mode only */
626     fprintf(stderr, "%s: abort()\n", __func__);
627     abort();
628 }
629 
630 /* called from spice server thread context only */
631 static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
632 {
633     QXLCookie *cookie = (QXLCookie *)(uintptr_t)cookie_token;
634 
635     switch (cookie->type) {
636 #ifdef HAVE_SPICE_GL
637     case QXL_COOKIE_TYPE_GL_DRAW_DONE:
638     {
639         SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
640         qemu_bh_schedule(ssd->gl_unblock_bh);
641         break;
642     }
643     case QXL_COOKIE_TYPE_IO:
644         if (cookie->io == QXL_IO_MONITORS_CONFIG_ASYNC) {
645             g_free(cookie->u.data);
646         }
647         break;
648 #endif
649     default:
650         /* should never be called, used in qxl native mode only */
651         fprintf(stderr, "%s: abort()\n", __func__);
652         abort();
653     }
654     g_free(cookie);
655 }
656 
657 static void interface_set_client_capabilities(QXLInstance *sin,
658                                               uint8_t client_present,
659                                               uint8_t caps[58])
660 {
661     /* nothing to do */
662 }
663 
664 static int interface_client_monitors_config(QXLInstance *sin,
665                                             VDAgentMonitorsConfig *mc)
666 {
667     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
668     QemuUIInfo info;
669     int head;
670 
671     if (!dpy_ui_info_supported(ssd->dcl.con)) {
672         return 0; /* == not supported by guest */
673     }
674 
675     if (!mc) {
676         return 1;
677     }
678 
679     info = *dpy_get_ui_info(ssd->dcl.con);
680 
681     head = qemu_console_get_index(ssd->dcl.con);
682     if (mc->num_of_monitors > head) {
683         info.width  = mc->monitors[head].width;
684         info.height = mc->monitors[head].height;
685 #if SPICE_SERVER_VERSION >= 0x000e04 /* release 0.14.4 */
686         if (mc->flags & VD_AGENT_CONFIG_MONITORS_FLAG_PHYSICAL_SIZE) {
687             VDAgentMonitorMM *mm = (void *)&mc->monitors[mc->num_of_monitors];
688             info.width_mm = mm[head].width;
689             info.height_mm = mm[head].height;
690         }
691 #endif
692     }
693 
694     trace_qemu_spice_ui_info(ssd->qxl.id, info.width, info.height);
695     dpy_set_ui_info(ssd->dcl.con, &info, false);
696     return 1;
697 }
698 
699 static const QXLInterface dpy_interface = {
700     .base.type               = SPICE_INTERFACE_QXL,
701     .base.description        = "qemu simple display",
702     .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
703     .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,
704 
705 #if SPICE_HAS_ATTACHED_WORKER
706     .attached_worker         = interface_attached_worker,
707 #else
708     .attache_worker          = interface_attach_worker,
709 #endif
710     .set_compression_level   = interface_set_compression_level,
711     .get_init_info           = interface_get_init_info,
712 
713     /* the callbacks below are called from spice server thread context */
714     .get_command             = interface_get_command,
715     .req_cmd_notification    = interface_req_cmd_notification,
716     .release_resource        = interface_release_resource,
717     .get_cursor_command      = interface_get_cursor_command,
718     .req_cursor_notification = interface_req_cursor_notification,
719     .notify_update           = interface_notify_update,
720     .flush_resources         = interface_flush_resources,
721     .async_complete          = interface_async_complete,
722     .update_area_complete    = interface_update_area_complete,
723     .set_client_capabilities = interface_set_client_capabilities,
724     .client_monitors_config  = interface_client_monitors_config,
725 };
726 
727 static void display_update(DisplayChangeListener *dcl,
728                            int x, int y, int w, int h)
729 {
730     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
731     qemu_spice_display_update(ssd, x, y, w, h);
732 }
733 
734 static void display_switch(DisplayChangeListener *dcl,
735                            DisplaySurface *surface)
736 {
737     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
738     qemu_spice_display_switch(ssd, surface);
739 }
740 
741 static void display_refresh(DisplayChangeListener *dcl)
742 {
743     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
744     qemu_spice_display_refresh(ssd);
745 }
746 
747 static void display_mouse_set(DisplayChangeListener *dcl,
748                               int x, int y, int on)
749 {
750     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
751 
752     qemu_mutex_lock(&ssd->lock);
753     ssd->ptr_x = x;
754     ssd->ptr_y = y;
755     g_free(ssd->ptr_move);
756     ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL, on);
757     qemu_mutex_unlock(&ssd->lock);
758     qemu_spice_wakeup(ssd);
759 }
760 
761 static void display_mouse_define(DisplayChangeListener *dcl,
762                                  QEMUCursor *c)
763 {
764     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
765 
766     qemu_mutex_lock(&ssd->lock);
767     cursor_get(c);
768     cursor_put(ssd->cursor);
769     ssd->cursor = c;
770     ssd->hot_x = c->hot_x;
771     ssd->hot_y = c->hot_y;
772     g_free(ssd->ptr_move);
773     ssd->ptr_move = NULL;
774     g_free(ssd->ptr_define);
775     ssd->ptr_define = qemu_spice_create_cursor_update(ssd, c, 0);
776     qemu_mutex_unlock(&ssd->lock);
777     qemu_spice_wakeup(ssd);
778 }
779 
780 static const DisplayChangeListenerOps display_listener_ops = {
781     .dpy_name             = "spice",
782     .dpy_gfx_update       = display_update,
783     .dpy_gfx_switch       = display_switch,
784     .dpy_gfx_check_format = qemu_pixman_check_format,
785     .dpy_refresh          = display_refresh,
786     .dpy_mouse_set        = display_mouse_set,
787     .dpy_cursor_define    = display_mouse_define,
788 };
789 
790 #ifdef HAVE_SPICE_GL
791 
792 static void qemu_spice_gl_monitor_config(SimpleSpiceDisplay *ssd,
793                                          int x, int y, int w, int h)
794 {
795     QXLMonitorsConfig *config;
796     QXLCookie *cookie;
797 
798     config = g_malloc0(sizeof(QXLMonitorsConfig) + sizeof(QXLHead));
799     config->count = 1;
800     config->max_allowed = 1;
801     config->heads[0].x = x;
802     config->heads[0].y = y;
803     config->heads[0].width = w;
804     config->heads[0].height = h;
805     cookie = qxl_cookie_new(QXL_COOKIE_TYPE_IO,
806                             QXL_IO_MONITORS_CONFIG_ASYNC);
807     cookie->u.data = config;
808 
809     spice_qxl_monitors_config_async(&ssd->qxl,
810                                     (uintptr_t)config,
811                                     MEMSLOT_GROUP_HOST,
812                                     (uintptr_t)cookie);
813 }
814 
815 static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
816 {
817     uint64_t timeout;
818 
819     if (block) {
820         timeout = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
821         timeout += 1000; /* one sec */
822         timer_mod(ssd->gl_unblock_timer, timeout);
823     } else {
824         timer_del(ssd->gl_unblock_timer);
825     }
826     graphic_hw_gl_block(ssd->dcl.con, block);
827 }
828 
829 static void qemu_spice_gl_unblock_bh(void *opaque)
830 {
831     SimpleSpiceDisplay *ssd = opaque;
832 
833     qemu_spice_gl_block(ssd, false);
834 }
835 
836 static void qemu_spice_gl_block_timer(void *opaque)
837 {
838     warn_report("spice: no gl-draw-done within one second");
839 }
840 
841 static void spice_gl_refresh(DisplayChangeListener *dcl)
842 {
843     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
844     uint64_t cookie;
845 
846     if (!ssd->ds || qemu_console_is_gl_blocked(ssd->dcl.con)) {
847         return;
848     }
849 
850     graphic_hw_update(dcl->con);
851     if (ssd->gl_updates && ssd->have_surface) {
852         qemu_spice_gl_block(ssd, true);
853         glFlush();
854         cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
855         spice_qxl_gl_draw_async(&ssd->qxl, 0, 0,
856                                 surface_width(ssd->ds),
857                                 surface_height(ssd->ds),
858                                 cookie);
859         ssd->gl_updates = 0;
860     }
861 }
862 
863 static void spice_gl_update(DisplayChangeListener *dcl,
864                             int x, int y, int w, int h)
865 {
866     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
867 
868     surface_gl_update_texture(ssd->gls, ssd->ds, x, y, w, h);
869     ssd->gl_updates++;
870 }
871 
872 static void spice_gl_switch(DisplayChangeListener *dcl,
873                             struct DisplaySurface *new_surface)
874 {
875     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
876     EGLint stride, fourcc;
877     int fd;
878 
879     if (ssd->ds) {
880         surface_gl_destroy_texture(ssd->gls, ssd->ds);
881     }
882     ssd->ds = new_surface;
883     if (ssd->ds) {
884         surface_gl_create_texture(ssd->gls, ssd->ds);
885         fd = egl_get_fd_for_texture(ssd->ds->texture,
886                                     &stride, &fourcc,
887                                     NULL);
888         if (fd < 0) {
889             surface_gl_destroy_texture(ssd->gls, ssd->ds);
890             return;
891         }
892 
893         trace_qemu_spice_gl_surface(ssd->qxl.id,
894                                     surface_width(ssd->ds),
895                                     surface_height(ssd->ds),
896                                     fourcc);
897 
898         /* note: spice server will close the fd */
899         spice_qxl_gl_scanout(&ssd->qxl, fd,
900                              surface_width(ssd->ds),
901                              surface_height(ssd->ds),
902                              stride, fourcc, false);
903         ssd->have_surface = true;
904         ssd->have_scanout = false;
905 
906         qemu_spice_gl_monitor_config(ssd, 0, 0,
907                                      surface_width(ssd->ds),
908                                      surface_height(ssd->ds));
909     }
910 }
911 
912 static QEMUGLContext qemu_spice_gl_create_context(DisplayGLCtx *dgc,
913                                                   QEMUGLParams *params)
914 {
915     eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
916                    qemu_egl_rn_ctx);
917     return qemu_egl_create_context(dgc, params);
918 }
919 
920 static void qemu_spice_gl_scanout_disable(DisplayChangeListener *dcl)
921 {
922     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
923 
924     trace_qemu_spice_gl_scanout_disable(ssd->qxl.id);
925     spice_qxl_gl_scanout(&ssd->qxl, -1, 0, 0, 0, 0, false);
926     qemu_spice_gl_monitor_config(ssd, 0, 0, 0, 0);
927     ssd->have_surface = false;
928     ssd->have_scanout = false;
929 }
930 
931 static void qemu_spice_gl_scanout_texture(DisplayChangeListener *dcl,
932                                           uint32_t tex_id,
933                                           bool y_0_top,
934                                           uint32_t backing_width,
935                                           uint32_t backing_height,
936                                           uint32_t x, uint32_t y,
937                                           uint32_t w, uint32_t h)
938 {
939     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
940     EGLint stride = 0, fourcc = 0;
941     int fd = -1;
942 
943     assert(tex_id);
944     fd = egl_get_fd_for_texture(tex_id, &stride, &fourcc, NULL);
945     if (fd < 0) {
946         fprintf(stderr, "%s: failed to get fd for texture\n", __func__);
947         return;
948     }
949     trace_qemu_spice_gl_scanout_texture(ssd->qxl.id, w, h, fourcc);
950 
951     /* note: spice server will close the fd */
952     spice_qxl_gl_scanout(&ssd->qxl, fd, backing_width, backing_height,
953                          stride, fourcc, y_0_top);
954     qemu_spice_gl_monitor_config(ssd, x, y, w, h);
955     ssd->have_surface = false;
956     ssd->have_scanout = true;
957 }
958 
959 static void qemu_spice_gl_scanout_dmabuf(DisplayChangeListener *dcl,
960                                          QemuDmaBuf *dmabuf)
961 {
962     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
963 
964     ssd->guest_dmabuf = dmabuf;
965     ssd->guest_dmabuf_refresh = true;
966 
967     ssd->have_surface = false;
968     ssd->have_scanout = true;
969 }
970 
971 static void qemu_spice_gl_cursor_dmabuf(DisplayChangeListener *dcl,
972                                         QemuDmaBuf *dmabuf, bool have_hot,
973                                         uint32_t hot_x, uint32_t hot_y)
974 {
975     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
976 
977     ssd->have_hot = have_hot;
978     ssd->hot_x = hot_x;
979     ssd->hot_y = hot_y;
980 
981     trace_qemu_spice_gl_cursor(ssd->qxl.id, dmabuf != NULL, have_hot);
982     if (dmabuf) {
983         egl_dmabuf_import_texture(dmabuf);
984         if (!dmabuf->texture) {
985             return;
986         }
987         egl_fb_setup_for_tex(&ssd->cursor_fb, dmabuf->width, dmabuf->height,
988                              dmabuf->texture, false);
989     } else {
990         egl_fb_destroy(&ssd->cursor_fb);
991     }
992 }
993 
994 static void qemu_spice_gl_cursor_position(DisplayChangeListener *dcl,
995                                           uint32_t pos_x, uint32_t pos_y)
996 {
997     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
998 
999     qemu_mutex_lock(&ssd->lock);
1000     ssd->ptr_x = pos_x;
1001     ssd->ptr_y = pos_y;
1002     qemu_mutex_unlock(&ssd->lock);
1003 }
1004 
1005 static void qemu_spice_gl_release_dmabuf(DisplayChangeListener *dcl,
1006                                          QemuDmaBuf *dmabuf)
1007 {
1008     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
1009 
1010     if (ssd->guest_dmabuf == dmabuf) {
1011         ssd->guest_dmabuf = NULL;
1012         ssd->guest_dmabuf_refresh = false;
1013     }
1014     egl_dmabuf_release_texture(dmabuf);
1015 }
1016 
1017 static void qemu_spice_gl_update(DisplayChangeListener *dcl,
1018                                  uint32_t x, uint32_t y, uint32_t w, uint32_t h)
1019 {
1020     SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
1021     EGLint stride = 0, fourcc = 0;
1022     bool render_cursor = false;
1023     bool y_0_top = false; /* FIXME */
1024     uint64_t cookie;
1025     int fd;
1026 
1027     if (!ssd->have_scanout) {
1028         return;
1029     }
1030 
1031     if (ssd->cursor_fb.texture) {
1032         render_cursor = true;
1033     }
1034     if (ssd->render_cursor != render_cursor) {
1035         ssd->render_cursor = render_cursor;
1036         ssd->guest_dmabuf_refresh = true;
1037         egl_fb_destroy(&ssd->blit_fb);
1038     }
1039 
1040     if (ssd->guest_dmabuf_refresh) {
1041         QemuDmaBuf *dmabuf = ssd->guest_dmabuf;
1042         if (render_cursor) {
1043             egl_dmabuf_import_texture(dmabuf);
1044             if (!dmabuf->texture) {
1045                 return;
1046             }
1047 
1048             /* source framebuffer */
1049             egl_fb_setup_for_tex(&ssd->guest_fb,
1050                                  dmabuf->width, dmabuf->height,
1051                                  dmabuf->texture, false);
1052 
1053             /* dest framebuffer */
1054             if (ssd->blit_fb.width  != dmabuf->width ||
1055                 ssd->blit_fb.height != dmabuf->height) {
1056                 trace_qemu_spice_gl_render_dmabuf(ssd->qxl.id, dmabuf->width,
1057                                                   dmabuf->height);
1058                 egl_fb_destroy(&ssd->blit_fb);
1059                 egl_fb_setup_new_tex(&ssd->blit_fb,
1060                                      dmabuf->width, dmabuf->height);
1061                 fd = egl_get_fd_for_texture(ssd->blit_fb.texture,
1062                                             &stride, &fourcc, NULL);
1063                 spice_qxl_gl_scanout(&ssd->qxl, fd,
1064                                      dmabuf->width, dmabuf->height,
1065                                      stride, fourcc, false);
1066             }
1067         } else {
1068             trace_qemu_spice_gl_forward_dmabuf(ssd->qxl.id,
1069                                                dmabuf->width, dmabuf->height);
1070             /* note: spice server will close the fd, so hand over a dup */
1071             spice_qxl_gl_scanout(&ssd->qxl, dup(dmabuf->fd),
1072                                  dmabuf->width, dmabuf->height,
1073                                  dmabuf->stride, dmabuf->fourcc,
1074                                  dmabuf->y0_top);
1075         }
1076         qemu_spice_gl_monitor_config(ssd, 0, 0, dmabuf->width, dmabuf->height);
1077         ssd->guest_dmabuf_refresh = false;
1078     }
1079 
1080     if (render_cursor) {
1081         int x, y;
1082         qemu_mutex_lock(&ssd->lock);
1083         x = ssd->ptr_x;
1084         y = ssd->ptr_y;
1085         qemu_mutex_unlock(&ssd->lock);
1086         egl_texture_blit(ssd->gls, &ssd->blit_fb, &ssd->guest_fb,
1087                          !y_0_top);
1088         egl_texture_blend(ssd->gls, &ssd->blit_fb, &ssd->cursor_fb,
1089                           !y_0_top, x, y, 1.0, 1.0);
1090         glFlush();
1091     }
1092 
1093     trace_qemu_spice_gl_update(ssd->qxl.id, w, h, x, y);
1094     qemu_spice_gl_block(ssd, true);
1095     glFlush();
1096     cookie = (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_GL_DRAW_DONE, 0);
1097     spice_qxl_gl_draw_async(&ssd->qxl, x, y, w, h, cookie);
1098 }
1099 
1100 static const DisplayChangeListenerOps display_listener_gl_ops = {
1101     .dpy_name                = "spice-egl",
1102     .dpy_gfx_update          = spice_gl_update,
1103     .dpy_gfx_switch          = spice_gl_switch,
1104     .dpy_gfx_check_format    = console_gl_check_format,
1105     .dpy_refresh             = spice_gl_refresh,
1106     .dpy_mouse_set           = display_mouse_set,
1107     .dpy_cursor_define       = display_mouse_define,
1108 
1109     .dpy_gl_scanout_disable  = qemu_spice_gl_scanout_disable,
1110     .dpy_gl_scanout_texture  = qemu_spice_gl_scanout_texture,
1111     .dpy_gl_scanout_dmabuf   = qemu_spice_gl_scanout_dmabuf,
1112     .dpy_gl_cursor_dmabuf    = qemu_spice_gl_cursor_dmabuf,
1113     .dpy_gl_cursor_position  = qemu_spice_gl_cursor_position,
1114     .dpy_gl_release_dmabuf   = qemu_spice_gl_release_dmabuf,
1115     .dpy_gl_update           = qemu_spice_gl_update,
1116 };
1117 
1118 static bool
1119 qemu_spice_is_compatible_dcl(DisplayGLCtx *dgc,
1120                              DisplayChangeListener *dcl)
1121 {
1122     return dcl->ops == &display_listener_gl_ops;
1123 }
1124 
1125 static const DisplayGLCtxOps gl_ctx_ops = {
1126     .dpy_gl_ctx_is_compatible_dcl = qemu_spice_is_compatible_dcl,
1127     .dpy_gl_ctx_create       = qemu_spice_gl_create_context,
1128     .dpy_gl_ctx_destroy      = qemu_egl_destroy_context,
1129     .dpy_gl_ctx_make_current = qemu_egl_make_context_current,
1130 };
1131 
1132 #endif /* HAVE_SPICE_GL */
1133 
1134 static void qemu_spice_display_init_one(QemuConsole *con)
1135 {
1136     SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
1137 
1138     qemu_spice_display_init_common(ssd);
1139 
1140     ssd->dcl.ops = &display_listener_ops;
1141 #ifdef HAVE_SPICE_GL
1142     if (spice_opengl) {
1143         ssd->dcl.ops = &display_listener_gl_ops;
1144         ssd->dgc.ops = &gl_ctx_ops;
1145         ssd->gl_unblock_bh = qemu_bh_new(qemu_spice_gl_unblock_bh, ssd);
1146         ssd->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
1147                                              qemu_spice_gl_block_timer, ssd);
1148         ssd->gls = qemu_gl_init_shader();
1149         ssd->have_surface = false;
1150         ssd->have_scanout = false;
1151     }
1152 #endif
1153     ssd->dcl.con = con;
1154 
1155     ssd->qxl.base.sif = &dpy_interface.base;
1156     qemu_spice_add_display_interface(&ssd->qxl, con);
1157 
1158 #if SPICE_SERVER_VERSION >= 0x000e02 /* release 0.14.2 */
1159     Error *err = NULL;
1160     char device_address[256] = "";
1161     if (qemu_console_fill_device_address(con, device_address, 256, &err)) {
1162         spice_qxl_set_device_info(&ssd->qxl,
1163                                   device_address,
1164                                   qemu_console_get_head(con),
1165                                   1);
1166     } else {
1167         error_report_err(err);
1168     }
1169 #endif
1170 
1171     qemu_spice_create_host_memslot(ssd);
1172 
1173     if (spice_opengl) {
1174         qemu_console_set_display_gl_ctx(con, &ssd->dgc);
1175     }
1176     register_displaychangelistener(&ssd->dcl);
1177 }
1178 
1179 void qemu_spice_display_init(void)
1180 {
1181     QemuOptsList *olist = qemu_find_opts("spice");
1182     QemuOpts *opts = QTAILQ_FIRST(&olist->head);
1183     QemuConsole *spice_con, *con;
1184     const char *str;
1185     int i;
1186 
1187     str = qemu_opt_get(opts, "display");
1188     if (str) {
1189         int head = qemu_opt_get_number(opts, "head", 0);
1190         Error *err = NULL;
1191 
1192         spice_con = qemu_console_lookup_by_device_name(str, head, &err);
1193         if (err) {
1194             error_report("Failed to lookup display/head");
1195             exit(1);
1196         }
1197     } else {
1198         spice_con = NULL;
1199     }
1200 
1201     for (i = 0;; i++) {
1202         con = qemu_console_lookup_by_index(i);
1203         if (!con || !qemu_console_is_graphic(con)) {
1204             break;
1205         }
1206         if (qemu_spice_have_display_interface(con)) {
1207             continue;
1208         }
1209         if (spice_con != NULL && spice_con != con) {
1210             continue;
1211         }
1212         qemu_spice_display_init_one(con);
1213     }
1214 
1215     qemu_spice_display_init_done();
1216 }
1217