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