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