blob: 66e25788ce9171c6462394dc02438c4776656404 [file] [log] [blame]
Gerd Hoffmanna3e22262010-08-25 15:32:06 +02001/*
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
Gerd Hoffmanna3e22262010-08-25 15:32:06 +020018#include "qemu-common.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010019#include "ui/qemu-spice.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010020#include "qemu/timer.h"
21#include "qemu/queue.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010022#include "monitor/monitor.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010023#include "ui/console.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010024#include "sysemu/sysemu.h"
Alon Levyc480bb72012-03-18 13:46:14 +010025#include "trace.h"
Gerd Hoffmanna3e22262010-08-25 15:32:06 +020026
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010027#include "ui/spice-display.h"
Gerd Hoffmanna3e22262010-08-25 15:32:06 +020028
29static int debug = 0;
30
Stefan Weil2c80e422010-10-13 20:54:27 +020031static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +020032{
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
42int qemu_spice_rect_is_empty(const QXLRect* r)
43{
44 return r->top == r->bottom || r->left == r->right;
45}
46
47void 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
Alon Levy2e1a98c2012-02-24 23:19:30 +020064QXLCookie *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
Alon Levy5ff4e362011-07-20 12:20:58 +030074void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
75 qxl_async_io async)
Gerd Hoffmann5c59d112011-07-20 12:20:50 +030076{
Alon Levyc480bb72012-03-18 13:46:14 +010077 trace_qemu_spice_add_memslot(ssd->qxl.id, memslot->slot_id,
78 memslot->virt_start, memslot->virt_end,
79 async);
80
Alon Levy5ff4e362011-07-20 12:20:58 +030081 if (async != QXL_SYNC) {
Alon Levy2e1a98c2012-02-24 23:19:30 +020082 spice_qxl_add_memslot_async(&ssd->qxl, memslot,
Peter Maydell34d14c62012-03-07 13:36:48 +000083 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
84 QXL_IO_MEMSLOT_ADD_ASYNC));
Alon Levy5ff4e362011-07-20 12:20:58 +030085 } else {
Marc-André Lureau26defe82013-10-04 13:10:46 +020086 spice_qxl_add_memslot(&ssd->qxl, memslot);
Alon Levy5ff4e362011-07-20 12:20:58 +030087 }
Gerd Hoffmann5c59d112011-07-20 12:20:50 +030088}
89
90void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
91{
Alon Levyc480bb72012-03-18 13:46:14 +010092 trace_qemu_spice_del_memslot(ssd->qxl.id, gid, sid);
Marc-André Lureau26defe82013-10-04 13:10:46 +020093 spice_qxl_del_memslot(&ssd->qxl, gid, sid);
Gerd Hoffmann5c59d112011-07-20 12:20:50 +030094}
95
96void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
Alon Levy5ff4e362011-07-20 12:20:58 +030097 QXLDevSurfaceCreate *surface,
98 qxl_async_io async)
Gerd Hoffmann5c59d112011-07-20 12:20:50 +030099{
Alon Levyc480bb72012-03-18 13:46:14 +0100100 trace_qemu_spice_create_primary_surface(ssd->qxl.id, id, surface, async);
Alon Levy5ff4e362011-07-20 12:20:58 +0300101 if (async != QXL_SYNC) {
Alon Levy2e1a98c2012-02-24 23:19:30 +0200102 spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface,
Peter Maydell34d14c62012-03-07 13:36:48 +0000103 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
104 QXL_IO_CREATE_PRIMARY_ASYNC));
Alon Levy5ff4e362011-07-20 12:20:58 +0300105 } else {
Marc-André Lureau26defe82013-10-04 13:10:46 +0200106 spice_qxl_create_primary_surface(&ssd->qxl, id, surface);
Alon Levy5ff4e362011-07-20 12:20:58 +0300107 }
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300108}
109
Alon Levy5ff4e362011-07-20 12:20:58 +0300110void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
111 uint32_t id, qxl_async_io async)
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300112{
Alon Levyc480bb72012-03-18 13:46:14 +0100113 trace_qemu_spice_destroy_primary_surface(ssd->qxl.id, id, async);
Alon Levy5ff4e362011-07-20 12:20:58 +0300114 if (async != QXL_SYNC) {
Alon Levy2e1a98c2012-02-24 23:19:30 +0200115 spice_qxl_destroy_primary_surface_async(&ssd->qxl, id,
Peter Maydell34d14c62012-03-07 13:36:48 +0000116 (uintptr_t)qxl_cookie_new(QXL_COOKIE_TYPE_IO,
117 QXL_IO_DESTROY_PRIMARY_ASYNC));
Alon Levy5ff4e362011-07-20 12:20:58 +0300118 } else {
Marc-André Lureau26defe82013-10-04 13:10:46 +0200119 spice_qxl_destroy_primary_surface(&ssd->qxl, id);
Alon Levy5ff4e362011-07-20 12:20:58 +0300120 }
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300121}
122
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300123void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
124{
Alon Levyc480bb72012-03-18 13:46:14 +0100125 trace_qemu_spice_wakeup(ssd->qxl.id);
Marc-André Lureau26defe82013-10-04 13:10:46 +0200126 spice_qxl_wakeup(&ssd->qxl);
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300127}
128
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200129static void qemu_spice_create_one_update(SimpleSpiceDisplay *ssd,
130 QXLRect *rect)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200131{
132 SimpleSpiceUpdate *update;
133 QXLDrawable *drawable;
134 QXLImage *image;
135 QXLCommand *cmd;
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100136 int bw, bh;
Alon Levy22795172011-06-15 20:44:38 +0200137 struct timespec time_space;
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100138 pixman_image_t *dest;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200139
Alon Levyc480bb72012-03-18 13:46:14 +0100140 trace_qemu_spice_create_update(
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200141 rect->left, rect->right,
142 rect->top, rect->bottom);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200143
Anthony Liguori7267c092011-08-20 22:09:37 -0500144 update = g_malloc0(sizeof(*update));
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200145 drawable = &update->drawable;
146 image = &update->image;
147 cmd = &update->ext.cmd;
148
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200149 bw = rect->right - rect->left;
150 bh = rect->bottom - rect->top;
Anthony Liguori7267c092011-08-20 22:09:37 -0500151 update->bitmap = g_malloc(bw * bh * 4);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200152
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200153 drawable->bbox = *rect;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200154 drawable->clip.type = SPICE_CLIP_TYPE_NONE;
155 drawable->effect = QXL_EFFECT_OPAQUE;
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200156 drawable->release_info.id = (uintptr_t)(&update->ext);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200157 drawable->type = QXL_DRAW_COPY;
158 drawable->surfaces_dest[0] = -1;
159 drawable->surfaces_dest[1] = -1;
160 drawable->surfaces_dest[2] = -1;
Alon Levy22795172011-06-15 20:44:38 +0200161 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;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200165
166 drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
Alon Levya13ccc92012-03-21 18:17:18 +0200167 drawable->u.copy.src_bitmap = (uintptr_t)image;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200168 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;
Alon Levya13ccc92012-03-21 18:17:18 +0200177 image->bitmap.data = (uintptr_t)(update->bitmap);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200178 image->bitmap.palette = 0;
179 image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
180
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100181 dest = pixman_image_create_bits(PIXMAN_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);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200190
191 cmd->type = QXL_CMD_DRAW;
Alon Levya13ccc92012-03-21 18:17:18 +0200192 cmd->data = (uintptr_t)drawable;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200193
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200194 QTAILQ_INSERT_TAIL(&ssd->updates, update, next);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200195}
196
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200197static void qemu_spice_create_update(SimpleSpiceDisplay *ssd)
198{
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200199 static const int blksize = 32;
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100200 int blocks = (surface_width(ssd->ds) + blksize - 1) / blksize;
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200201 int dirty_top[blocks];
202 int y, yoff, x, xoff, blk, bw;
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100203 int bpp = surface_bytes_per_pixel(ssd->ds);
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200204 uint8_t *guest, *mirror;
205
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200206 if (qemu_spice_rect_is_empty(&ssd->dirty)) {
207 return;
208 };
Gerd Hoffmanna7310dd2012-09-05 09:35:57 +0200209
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100210 if (ssd->surface == NULL) {
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100211 ssd->surface = pixman_image_ref(ssd->ds->image);
212 ssd->mirror = qemu_pixman_mirror_create(ssd->ds->format,
213 ssd->ds->image);
Gerd Hoffmanna7310dd2012-09-05 09:35:57 +0200214 }
215
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200216 for (blk = 0; blk < blocks; blk++) {
217 dirty_top[blk] = -1;
218 }
219
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100220 guest = surface_data(ssd->ds);
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100221 mirror = (void *)pixman_image_get_data(ssd->mirror);
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200222 for (y = ssd->dirty.top; y < ssd->dirty.bottom; y++) {
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100223 yoff = y * surface_stride(ssd->ds);
Gerd Hoffmannb021bd22012-09-05 10:41:42 +0200224 for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
225 xoff = x * bpp;
226 blk = x / blksize;
227 bw = MIN(blksize, ssd->dirty.right - x);
228 if (memcmp(guest + yoff + xoff,
229 mirror + yoff + xoff,
230 bw * bpp) == 0) {
231 if (dirty_top[blk] != -1) {
232 QXLRect update = {
233 .top = dirty_top[blk],
234 .bottom = y,
235 .left = x,
236 .right = x + bw,
237 };
238 qemu_spice_create_one_update(ssd, &update);
239 dirty_top[blk] = -1;
240 }
241 } else {
242 if (dirty_top[blk] == -1) {
243 dirty_top[blk] = y;
244 }
245 }
246 }
247 }
248
249 for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
250 blk = x / blksize;
251 bw = MIN(blksize, ssd->dirty.right - x);
252 if (dirty_top[blk] != -1) {
253 QXLRect update = {
254 .top = dirty_top[blk],
255 .bottom = ssd->dirty.bottom,
256 .left = x,
257 .right = x + bw,
258 };
259 qemu_spice_create_one_update(ssd, &update);
260 dirty_top[blk] = -1;
261 }
262 }
263
Gerd Hoffmannc60319a2012-09-05 08:52:23 +0200264 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
265}
266
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200267static SimpleSpiceCursor*
268qemu_spice_create_cursor_update(SimpleSpiceDisplay *ssd,
269 QEMUCursor *c)
270{
271 size_t size = c ? c->width * c->height * 4 : 0;
272 SimpleSpiceCursor *update;
273 QXLCursorCmd *ccmd;
274 QXLCursor *cursor;
275 QXLCommand *cmd;
276
277 update = g_malloc0(sizeof(*update) + size);
278 ccmd = &update->cmd;
279 cursor = &update->cursor;
280 cmd = &update->ext.cmd;
281
282 if (c) {
283 ccmd->type = QXL_CURSOR_SET;
284 ccmd->u.set.position.x = ssd->ptr_x;
285 ccmd->u.set.position.y = ssd->ptr_y;
286 ccmd->u.set.visible = true;
287 ccmd->u.set.shape = (uintptr_t)cursor;
288 cursor->header.unique = ssd->unique++;
289 cursor->header.type = SPICE_CURSOR_TYPE_ALPHA;
290 cursor->header.width = c->width;
291 cursor->header.height = c->height;
292 cursor->header.hot_spot_x = c->hot_x;
293 cursor->header.hot_spot_y = c->hot_y;
294 cursor->data_size = size;
295 cursor->chunk.data_size = size;
296 memcpy(cursor->chunk.data, c->data, size);
297 } else {
298 ccmd->type = QXL_CURSOR_MOVE;
299 ccmd->u.position.x = ssd->ptr_x;
300 ccmd->u.position.y = ssd->ptr_y;
301 }
302 ccmd->release_info.id = (uintptr_t)(&update->ext);
303
304 cmd->type = QXL_CMD_CURSOR;
305 cmd->data = (uintptr_t)ccmd;
306
307 return update;
308}
309
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200310/*
Stefan Weil4580c492012-08-17 15:20:00 +0200311 * Called from spice server thread context (via interface_release_resource)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200312 * We do *not* hold the global qemu mutex here, so extra care is needed
Stefan Weil5cbdb3a2012-04-07 09:23:39 +0200313 * when calling qemu functions. QEMU interfaces used:
Anthony Liguori7267c092011-08-20 22:09:37 -0500314 * - g_free (underlying glibc free is re-entrant).
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200315 */
316void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
317{
Anthony Liguori7267c092011-08-20 22:09:37 -0500318 g_free(update->bitmap);
319 g_free(update);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200320}
321
322void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
323{
324 QXLDevMemSlot memslot;
325
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200326 dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200327
328 memset(&memslot, 0, sizeof(memslot));
329 memslot.slot_group_id = MEMSLOT_GROUP_HOST;
330 memslot.virt_end = ~0;
Alon Levy5ff4e362011-07-20 12:20:58 +0300331 qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200332}
333
334void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
335{
336 QXLDevSurfaceCreate surface;
337
Alon Levy160c31f2012-05-24 12:38:11 +0300338 memset(&surface, 0, sizeof(surface));
339
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200340 dprint(1, "%s/%d: %dx%d\n", __func__, ssd->qxl.id,
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100341 surface_width(ssd->ds), surface_height(ssd->ds));
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200342
343 surface.format = SPICE_SURFACE_FMT_32_xRGB;
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100344 surface.width = surface_width(ssd->ds);
345 surface.height = surface_height(ssd->ds);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200346 surface.stride = -surface.width * 4;
Gerd Hoffmann869564a2010-04-13 09:05:03 +0200347 surface.mouse_mode = true;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200348 surface.flags = 0;
349 surface.type = 0;
Alon Levya13ccc92012-03-21 18:17:18 +0200350 surface.mem = (uintptr_t)ssd->buf;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200351 surface.group_id = MEMSLOT_GROUP_HOST;
Gerd Hoffmann7466bc42010-10-14 16:55:01 +0200352
Alon Levy5ff4e362011-07-20 12:20:58 +0300353 qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200354}
355
356void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
357{
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200358 dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200359
Alon Levy5ff4e362011-07-20 12:20:58 +0300360 qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200361}
362
Gerd Hoffmannc78f7132013-03-05 15:24:14 +0100363void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd)
Gerd Hoffmanna963f872011-07-20 12:20:51 +0300364{
Gerd Hoffmanna963f872011-07-20 12:20:51 +0300365 qemu_mutex_init(&ssd->lock);
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200366 QTAILQ_INIT(&ssd->updates);
Gerd Hoffmanna963f872011-07-20 12:20:51 +0300367 ssd->mouse_x = -1;
368 ssd->mouse_y = -1;
Gerd Hoffmannddd8fdc2012-09-04 11:39:41 +0200369 if (ssd->num_surfaces == 0) {
370 ssd->num_surfaces = 1024;
371 }
Gerd Hoffmanna963f872011-07-20 12:20:51 +0300372 ssd->bufsize = (16 * 1024 * 1024);
Anthony Liguori7267c092011-08-20 22:09:37 -0500373 ssd->buf = g_malloc(ssd->bufsize);
Gerd Hoffmanna963f872011-07-20 12:20:51 +0300374}
375
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200376/* display listener callbacks */
377
378void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
379 int x, int y, int w, int h)
380{
381 QXLRect update_area;
382
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200383 dprint(2, "%s/%d: x %d y %d w %d h %d\n", __func__,
384 ssd->qxl.id, x, y, w, h);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200385 update_area.left = x,
386 update_area.right = x + w;
387 update_area.top = y;
388 update_area.bottom = y + h;
389
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200390 if (qemu_spice_rect_is_empty(&ssd->dirty)) {
391 ssd->notify++;
392 }
393 qemu_spice_rect_union(&ssd->dirty, &update_area);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200394}
395
Gerd Hoffmannc12aeb82013-02-28 15:03:04 +0100396void qemu_spice_display_switch(SimpleSpiceDisplay *ssd,
397 DisplaySurface *surface)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200398{
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200399 SimpleSpiceUpdate *update;
Gerd Hoffmann4b87dc42014-01-24 10:48:58 +0100400 bool need_destroy;
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200401
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200402 dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200403
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200404 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
Gerd Hoffmannd9a86562012-11-02 09:12:49 +0100405 if (ssd->surface) {
406 pixman_image_unref(ssd->surface);
407 ssd->surface = NULL;
408 pixman_image_unref(ssd->mirror);
409 ssd->mirror = NULL;
410 }
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200411
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200412 qemu_mutex_lock(&ssd->lock);
Gerd Hoffmann4b87dc42014-01-24 10:48:58 +0100413 need_destroy = (ssd->ds != NULL);
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100414 ssd->ds = surface;
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200415 while ((update = QTAILQ_FIRST(&ssd->updates)) != NULL) {
416 QTAILQ_REMOVE(&ssd->updates, update, next);
417 qemu_spice_destroy_update(ssd, update);
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200418 }
419 qemu_mutex_unlock(&ssd->lock);
Gerd Hoffmann4b87dc42014-01-24 10:48:58 +0100420 if (need_destroy) {
421 qemu_spice_destroy_host_primary(ssd);
422 }
423 if (ssd->ds) {
424 qemu_spice_create_host_primary(ssd);
425 }
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200426
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200427 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
428 ssd->notify++;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200429}
430
Alon Levybb5a8cd2012-02-24 23:19:25 +0200431void qemu_spice_cursor_refresh_unlocked(SimpleSpiceDisplay *ssd)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200432{
Gerd Hoffmann07536092011-04-27 15:50:32 +0200433 if (ssd->cursor) {
Gerd Hoffmann284d1c62013-03-15 15:45:54 +0100434 assert(ssd->dcl.con);
435 dpy_cursor_define(ssd->dcl.con, ssd->cursor);
Gerd Hoffmann07536092011-04-27 15:50:32 +0200436 cursor_put(ssd->cursor);
437 ssd->cursor = NULL;
438 }
439 if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
Gerd Hoffmann284d1c62013-03-15 15:45:54 +0100440 assert(ssd->dcl.con);
441 dpy_mouse_set(ssd->dcl.con, ssd->mouse_x, ssd->mouse_y, 1);
Gerd Hoffmann07536092011-04-27 15:50:32 +0200442 ssd->mouse_x = -1;
443 ssd->mouse_y = -1;
444 }
Alon Levybb5a8cd2012-02-24 23:19:25 +0200445}
446
447void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
448{
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200449 dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmann284d1c62013-03-15 15:45:54 +0100450 graphic_hw_update(ssd->dcl.con);
Alon Levybb5a8cd2012-02-24 23:19:25 +0200451
452 qemu_mutex_lock(&ssd->lock);
Gerd Hoffmann71874c12013-02-28 16:42:28 +0100453 if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200454 qemu_spice_create_update(ssd);
Alon Levybb5a8cd2012-02-24 23:19:25 +0200455 ssd->notify++;
456 }
457 qemu_spice_cursor_refresh_unlocked(ssd);
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200458 qemu_mutex_unlock(&ssd->lock);
459
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200460 if (ssd->notify) {
461 ssd->notify = 0;
Gerd Hoffmann5c59d112011-07-20 12:20:50 +0300462 qemu_spice_wakeup(ssd);
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200463 dprint(2, "%s/%d: notify\n", __func__, ssd->qxl.id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200464 }
465}
466
467/* spice display interface callbacks */
468
469static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
470{
471 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
472
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200473 dprint(1, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200474 ssd->worker = qxl_worker;
475}
476
477static void interface_set_compression_level(QXLInstance *sin, int level)
478{
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200479 dprint(1, "%s/%d:\n", __func__, sin->id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200480 /* nothing to do */
481}
482
483static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
484{
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200485 dprint(3, "%s/%d:\n", __func__, sin->id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200486 /* nothing to do */
487}
488
489static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
490{
491 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
492
493 info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
494 info->memslot_id_bits = MEMSLOT_SLOT_BITS;
495 info->num_memslots = NUM_MEMSLOTS;
496 info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
497 info->internal_groupslot_id = 0;
498 info->qxl_ram_size = ssd->bufsize;
Gerd Hoffmannddd8fdc2012-09-04 11:39:41 +0200499 info->n_surfaces = ssd->num_surfaces;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200500}
501
502static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
503{
504 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
505 SimpleSpiceUpdate *update;
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200506 int ret = false;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200507
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200508 dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200509
510 qemu_mutex_lock(&ssd->lock);
Gerd Hoffmannb1af98b2012-09-05 08:25:08 +0200511 update = QTAILQ_FIRST(&ssd->updates);
512 if (update != NULL) {
513 QTAILQ_REMOVE(&ssd->updates, update, next);
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200514 *ext = update->ext;
515 ret = true;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200516 }
Gerd Hoffmanne0c64d02011-04-27 15:21:51 +0200517 qemu_mutex_unlock(&ssd->lock);
518
519 return ret;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200520}
521
522static int interface_req_cmd_notification(QXLInstance *sin)
523{
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200524 dprint(1, "%s/%d:\n", __func__, sin->id);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200525 return 1;
526}
527
528static void interface_release_resource(QXLInstance *sin,
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200529 struct QXLReleaseInfoExt rext)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200530{
531 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200532 SimpleSpiceUpdate *update;
533 SimpleSpiceCursor *cursor;
534 QXLCommandExt *ext;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200535
Gerd Hoffmann35b21222013-10-17 12:11:43 +0200536 dprint(2, "%s/%d:\n", __func__, ssd->qxl.id);
Gerd Hoffmanne8e23b72014-06-20 08:12:44 +0200537 ext = (void *)(intptr_t)(rext.info->id);
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200538 switch (ext->cmd.type) {
539 case QXL_CMD_DRAW:
540 update = container_of(ext, SimpleSpiceUpdate, ext);
541 qemu_spice_destroy_update(ssd, update);
542 break;
543 case QXL_CMD_CURSOR:
544 cursor = container_of(ext, SimpleSpiceCursor, ext);
545 g_free(cursor);
546 break;
547 default:
548 g_assert_not_reached();
549 }
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200550}
551
552static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
553{
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200554 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
555 int ret;
556
557 dprint(3, "%s/%d:\n", __func__, ssd->qxl.id);
558
559 qemu_mutex_lock(&ssd->lock);
560 if (ssd->ptr_define) {
561 *ext = ssd->ptr_define->ext;
562 ssd->ptr_define = NULL;
563 ret = true;
564 } else if (ssd->ptr_move) {
565 *ext = ssd->ptr_move->ext;
566 ssd->ptr_move = NULL;
567 ret = true;
568 } else {
569 ret = false;
570 }
571 qemu_mutex_unlock(&ssd->lock);
572 return ret;
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200573}
574
575static int interface_req_cursor_notification(QXLInstance *sin)
576{
577 dprint(1, "%s:\n", __FUNCTION__);
578 return 1;
579}
580
581static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
582{
583 fprintf(stderr, "%s: abort()\n", __FUNCTION__);
584 abort();
585}
586
587static int interface_flush_resources(QXLInstance *sin)
588{
589 fprintf(stderr, "%s: abort()\n", __FUNCTION__);
590 abort();
591 return 0;
592}
593
Gerd Hoffmann21a50d02012-11-21 14:41:48 +0100594static void interface_update_area_complete(QXLInstance *sin,
595 uint32_t surface_id,
596 QXLRect *dirty, uint32_t num_updated_rects)
597{
598 /* should never be called, used in qxl native mode only */
599 fprintf(stderr, "%s: abort()\n", __func__);
600 abort();
601}
602
603/* called from spice server thread context only */
604static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
605{
606 /* should never be called, used in qxl native mode only */
607 fprintf(stderr, "%s: abort()\n", __func__);
608 abort();
609}
610
611static void interface_set_client_capabilities(QXLInstance *sin,
612 uint8_t client_present,
613 uint8_t caps[58])
614{
615 dprint(3, "%s:\n", __func__);
616}
617
618static int interface_client_monitors_config(QXLInstance *sin,
Gerd Hoffmann9b74d0d2014-01-24 18:47:20 +0100619 VDAgentMonitorsConfig *mc)
Gerd Hoffmann21a50d02012-11-21 14:41:48 +0100620{
Gerd Hoffmann9b74d0d2014-01-24 18:47:20 +0100621 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
622 QemuUIInfo info;
623 int rc;
624
Gerd Hoffmanndc491cf2014-04-07 12:15:44 +0200625 if (!mc) {
626 return 1;
627 }
628
Gerd Hoffmann9b74d0d2014-01-24 18:47:20 +0100629 /*
630 * FIXME: multihead is tricky due to the way
631 * spice has multihead implemented.
632 */
633 memset(&info, 0, sizeof(info));
634 if (mc->num_of_monitors > 0) {
635 info.width = mc->monitors[0].width;
636 info.height = mc->monitors[0].height;
637 }
638 rc = dpy_set_ui_info(ssd->dcl.con, &info);
639 dprint(1, "%s/%d: size %dx%d, rc %d <--- ==========================\n",
640 __func__, ssd->qxl.id, info.width, info.height, rc);
641 if (rc != 0) {
642 return 0; /* == not supported by guest */
643 } else {
644 return 1;
645 }
Gerd Hoffmann21a50d02012-11-21 14:41:48 +0100646}
647
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200648static const QXLInterface dpy_interface = {
649 .base.type = SPICE_INTERFACE_QXL,
650 .base.description = "qemu simple display",
651 .base.major_version = SPICE_INTERFACE_QXL_MAJOR,
652 .base.minor_version = SPICE_INTERFACE_QXL_MINOR,
653
654 .attache_worker = interface_attach_worker,
655 .set_compression_level = interface_set_compression_level,
656 .set_mm_time = interface_set_mm_time,
657 .get_init_info = interface_get_init_info,
658
659 /* the callbacks below are called from spice server thread context */
660 .get_command = interface_get_command,
661 .req_cmd_notification = interface_req_cmd_notification,
662 .release_resource = interface_release_resource,
663 .get_cursor_command = interface_get_cursor_command,
664 .req_cursor_notification = interface_req_cursor_notification,
665 .notify_update = interface_notify_update,
666 .flush_resources = interface_flush_resources,
Gerd Hoffmann21a50d02012-11-21 14:41:48 +0100667 .async_complete = interface_async_complete,
668 .update_area_complete = interface_update_area_complete,
669 .set_client_capabilities = interface_set_client_capabilities,
670 .client_monitors_config = interface_client_monitors_config,
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200671};
672
Gerd Hoffmann7c20b4a2012-11-13 14:51:41 +0100673static void display_update(DisplayChangeListener *dcl,
Gerd Hoffmann7c20b4a2012-11-13 14:51:41 +0100674 int x, int y, int w, int h)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200675{
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100676 SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
677 qemu_spice_display_update(ssd, x, y, w, h);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200678}
679
Gerd Hoffmannc12aeb82013-02-28 15:03:04 +0100680static void display_switch(DisplayChangeListener *dcl,
Gerd Hoffmannc12aeb82013-02-28 15:03:04 +0100681 struct DisplaySurface *surface)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200682{
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100683 SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
Gerd Hoffmannc12aeb82013-02-28 15:03:04 +0100684 qemu_spice_display_switch(ssd, surface);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200685}
686
Gerd Hoffmannbc2ed972013-03-01 13:03:04 +0100687static void display_refresh(DisplayChangeListener *dcl)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200688{
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100689 SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
690 qemu_spice_display_refresh(ssd);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200691}
692
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200693static void display_mouse_set(DisplayChangeListener *dcl,
694 int x, int y, int on)
695{
696 SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
697
698 qemu_mutex_lock(&ssd->lock);
699 ssd->ptr_x = x;
700 ssd->ptr_y = x;
701 if (ssd->ptr_move) {
702 g_free(ssd->ptr_move);
703 }
704 ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL);
705 qemu_mutex_unlock(&ssd->lock);
706}
707
708static void display_mouse_define(DisplayChangeListener *dcl,
709 QEMUCursor *c)
710{
711 SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
712
713 qemu_mutex_lock(&ssd->lock);
714 if (ssd->ptr_move) {
715 g_free(ssd->ptr_move);
716 ssd->ptr_move = NULL;
717 }
718 if (ssd->ptr_define) {
719 g_free(ssd->ptr_define);
720 }
721 ssd->ptr_define = qemu_spice_create_cursor_update(ssd, c);
722 qemu_mutex_unlock(&ssd->lock);
723}
724
Gerd Hoffmann7c20b4a2012-11-13 14:51:41 +0100725static const DisplayChangeListenerOps display_listener_ops = {
Gerd Hoffmann5643fc02014-06-07 13:03:10 +0200726 .dpy_name = "spice",
727 .dpy_gfx_update = display_update,
728 .dpy_gfx_switch = display_switch,
729 .dpy_refresh = display_refresh,
730 .dpy_mouse_set = display_mouse_set,
731 .dpy_cursor_define = display_mouse_define,
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200732};
733
Gerd Hoffmann9fa03282013-10-11 22:39:59 +0200734static void qemu_spice_display_init_one(QemuConsole *con)
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200735{
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100736 SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200737
Gerd Hoffmannc78f7132013-03-05 15:24:14 +0100738 qemu_spice_display_init_common(ssd);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200739
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100740 ssd->qxl.base.sif = &dpy_interface.base;
Gerd Hoffmann9fa03282013-10-11 22:39:59 +0200741 qemu_spice_add_display_interface(&ssd->qxl, con);
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100742 assert(ssd->worker);
Gerd Hoffmann7c20b4a2012-11-13 14:51:41 +0100743
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100744 qemu_spice_create_host_memslot(ssd);
Gerd Hoffmann9c80a312013-02-28 14:47:07 +0100745
746 ssd->dcl.ops = &display_listener_ops;
Gerd Hoffmann9fa03282013-10-11 22:39:59 +0200747 ssd->dcl.con = con;
Gerd Hoffmann52090892013-04-23 15:44:31 +0200748 register_displaychangelistener(&ssd->dcl);
Gerd Hoffmanna3e22262010-08-25 15:32:06 +0200749}
Gerd Hoffmann9fa03282013-10-11 22:39:59 +0200750
751void qemu_spice_display_init(void)
752{
753 QemuConsole *con;
754 int i;
755
756 for (i = 0;; i++) {
757 con = qemu_console_lookup_by_index(i);
758 if (!con || !qemu_console_is_graphic(con)) {
759 break;
760 }
761 if (qemu_spice_have_display_interface(con)) {
762 continue;
763 }
764 qemu_spice_display_init_one(con);
765 }
766}