keep the PID file locked for the lifetime of the process
[qemu.git] / ui / spice-display.c
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-common.h"
19 #include "qemu-spice.h"
20 #include "qemu-timer.h"
21 #include "qemu-queue.h"
22 #include "monitor.h"
23 #include "console.h"
24 #include "sysemu.h"
25
26 #include "spice-display.h"
27
28 static int debug = 0;
29
30 static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
31 {
32 va_list args;
33
34 if (level <= debug) {
35 va_start(args, fmt);
36 vfprintf(stderr, fmt, args);
37 va_end(args);
38 }
39 }
40
41 int qemu_spice_rect_is_empty(const QXLRect* r)
42 {
43 return r->top == r->bottom || r->left == r->right;
44 }
45
46 void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
47 {
48 if (qemu_spice_rect_is_empty(r)) {
49 return;
50 }
51
52 if (qemu_spice_rect_is_empty(dest)) {
53 *dest = *r;
54 return;
55 }
56
57 dest->top = MIN(dest->top, r->top);
58 dest->left = MIN(dest->left, r->left);
59 dest->bottom = MAX(dest->bottom, r->bottom);
60 dest->right = MAX(dest->right, r->right);
61 }
62
63 void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
64 qxl_async_io async)
65 {
66 if (async != QXL_SYNC) {
67 #if SPICE_INTERFACE_QXL_MINOR >= 1
68 spice_qxl_add_memslot_async(&ssd->qxl, memslot, 0);
69 #else
70 abort();
71 #endif
72 } else {
73 ssd->worker->add_memslot(ssd->worker, memslot);
74 }
75 }
76
77 void qemu_spice_del_memslot(SimpleSpiceDisplay *ssd, uint32_t gid, uint32_t sid)
78 {
79 ssd->worker->del_memslot(ssd->worker, gid, sid);
80 }
81
82 void qemu_spice_create_primary_surface(SimpleSpiceDisplay *ssd, uint32_t id,
83 QXLDevSurfaceCreate *surface,
84 qxl_async_io async)
85 {
86 if (async != QXL_SYNC) {
87 #if SPICE_INTERFACE_QXL_MINOR >= 1
88 spice_qxl_create_primary_surface_async(&ssd->qxl, id, surface, 0);
89 #else
90 abort();
91 #endif
92 } else {
93 ssd->worker->create_primary_surface(ssd->worker, id, surface);
94 }
95 }
96
97
98 void qemu_spice_destroy_primary_surface(SimpleSpiceDisplay *ssd,
99 uint32_t id, qxl_async_io async)
100 {
101 if (async != QXL_SYNC) {
102 #if SPICE_INTERFACE_QXL_MINOR >= 1
103 spice_qxl_destroy_primary_surface_async(&ssd->qxl, id, 0);
104 #else
105 abort();
106 #endif
107 } else {
108 ssd->worker->destroy_primary_surface(ssd->worker, id);
109 }
110 }
111
112 void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
113 {
114 ssd->worker->wakeup(ssd->worker);
115 }
116
117 void qemu_spice_start(SimpleSpiceDisplay *ssd)
118 {
119 ssd->worker->start(ssd->worker);
120 }
121
122 void qemu_spice_stop(SimpleSpiceDisplay *ssd)
123 {
124 ssd->worker->stop(ssd->worker);
125 }
126
127 static SimpleSpiceUpdate *qemu_spice_create_update(SimpleSpiceDisplay *ssd)
128 {
129 SimpleSpiceUpdate *update;
130 QXLDrawable *drawable;
131 QXLImage *image;
132 QXLCommand *cmd;
133 uint8_t *src, *dst;
134 int by, bw, bh;
135 struct timespec time_space;
136
137 if (qemu_spice_rect_is_empty(&ssd->dirty)) {
138 return NULL;
139 };
140
141 dprint(2, "%s: lr %d -> %d, tb -> %d -> %d\n", __FUNCTION__,
142 ssd->dirty.left, ssd->dirty.right,
143 ssd->dirty.top, ssd->dirty.bottom);
144
145 update = g_malloc0(sizeof(*update));
146 drawable = &update->drawable;
147 image = &update->image;
148 cmd = &update->ext.cmd;
149
150 bw = ssd->dirty.right - ssd->dirty.left;
151 bh = ssd->dirty.bottom - ssd->dirty.top;
152 update->bitmap = g_malloc(bw * bh * 4);
153
154 drawable->bbox = ssd->dirty;
155 drawable->clip.type = SPICE_CLIP_TYPE_NONE;
156 drawable->effect = QXL_EFFECT_OPAQUE;
157 drawable->release_info.id = (intptr_t)update;
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 /* time in milliseconds from epoch. */
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 = (intptr_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 = (intptr_t)(update->bitmap);
179 image->bitmap.palette = 0;
180 image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
181
182 if (ssd->conv == NULL) {
183 PixelFormat dst = qemu_default_pixelformat(32);
184 ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
185 assert(ssd->conv);
186 }
187
188 src = ds_get_data(ssd->ds) +
189 ssd->dirty.top * ds_get_linesize(ssd->ds) +
190 ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
191 dst = update->bitmap;
192 for (by = 0; by < bh; by++) {
193 qemu_pf_conv_run(ssd->conv, dst, src, bw);
194 src += ds_get_linesize(ssd->ds);
195 dst += image->bitmap.stride;
196 }
197
198 cmd->type = QXL_CMD_DRAW;
199 cmd->data = (intptr_t)drawable;
200
201 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
202 return update;
203 }
204
205 /*
206 * Called from spice server thread context (via interface_release_ressource)
207 * We do *not* hold the global qemu mutex here, so extra care is needed
208 * when calling qemu functions. Qemu interfaces used:
209 * - g_free (underlying glibc free is re-entrant).
210 */
211 void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
212 {
213 g_free(update->bitmap);
214 g_free(update);
215 }
216
217 void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
218 {
219 QXLDevMemSlot memslot;
220
221 dprint(1, "%s:\n", __FUNCTION__);
222
223 memset(&memslot, 0, sizeof(memslot));
224 memslot.slot_group_id = MEMSLOT_GROUP_HOST;
225 memslot.virt_end = ~0;
226 qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
227 }
228
229 void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
230 {
231 QXLDevSurfaceCreate surface;
232
233 dprint(1, "%s: %dx%d\n", __FUNCTION__,
234 ds_get_width(ssd->ds), ds_get_height(ssd->ds));
235
236 surface.format = SPICE_SURFACE_FMT_32_xRGB;
237 surface.width = ds_get_width(ssd->ds);
238 surface.height = ds_get_height(ssd->ds);
239 surface.stride = -surface.width * 4;
240 surface.mouse_mode = true;
241 surface.flags = 0;
242 surface.type = 0;
243 surface.mem = (intptr_t)ssd->buf;
244 surface.group_id = MEMSLOT_GROUP_HOST;
245
246 qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
247 }
248
249 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
250 {
251 dprint(1, "%s:\n", __FUNCTION__);
252
253 qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
254 }
255
256 void qemu_spice_vm_change_state_handler(void *opaque, int running,
257 RunState state)
258 {
259 SimpleSpiceDisplay *ssd = opaque;
260
261 if (running) {
262 ssd->running = true;
263 qemu_spice_start(ssd);
264 } else {
265 qemu_spice_stop(ssd);
266 ssd->running = false;
267 }
268 }
269
270 void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd, DisplayState *ds)
271 {
272 ssd->ds = ds;
273 qemu_mutex_init(&ssd->lock);
274 ssd->mouse_x = -1;
275 ssd->mouse_y = -1;
276 ssd->bufsize = (16 * 1024 * 1024);
277 ssd->buf = g_malloc(ssd->bufsize);
278 }
279
280 /* display listener callbacks */
281
282 void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
283 int x, int y, int w, int h)
284 {
285 QXLRect update_area;
286
287 dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
288 update_area.left = x,
289 update_area.right = x + w;
290 update_area.top = y;
291 update_area.bottom = y + h;
292
293 if (qemu_spice_rect_is_empty(&ssd->dirty)) {
294 ssd->notify++;
295 }
296 qemu_spice_rect_union(&ssd->dirty, &update_area);
297 }
298
299 void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
300 {
301 dprint(1, "%s:\n", __FUNCTION__);
302
303 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
304 qemu_pf_conv_put(ssd->conv);
305 ssd->conv = NULL;
306
307 qemu_mutex_lock(&ssd->lock);
308 if (ssd->update != NULL) {
309 qemu_spice_destroy_update(ssd, ssd->update);
310 ssd->update = NULL;
311 }
312 qemu_mutex_unlock(&ssd->lock);
313 qemu_spice_destroy_host_primary(ssd);
314 qemu_spice_create_host_primary(ssd);
315
316 memset(&ssd->dirty, 0, sizeof(ssd->dirty));
317 ssd->notify++;
318 }
319
320 void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
321 {
322 dprint(3, "%s:\n", __FUNCTION__);
323 vga_hw_update();
324
325 qemu_mutex_lock(&ssd->lock);
326 if (ssd->update == NULL) {
327 ssd->update = qemu_spice_create_update(ssd);
328 ssd->notify++;
329 }
330 if (ssd->cursor) {
331 ssd->ds->cursor_define(ssd->cursor);
332 cursor_put(ssd->cursor);
333 ssd->cursor = NULL;
334 }
335 if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
336 ssd->ds->mouse_set(ssd->mouse_x, ssd->mouse_y, 1);
337 ssd->mouse_x = -1;
338 ssd->mouse_y = -1;
339 }
340 qemu_mutex_unlock(&ssd->lock);
341
342 if (ssd->notify) {
343 ssd->notify = 0;
344 qemu_spice_wakeup(ssd);
345 dprint(2, "%s: notify\n", __FUNCTION__);
346 }
347 }
348
349 /* spice display interface callbacks */
350
351 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
352 {
353 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
354
355 dprint(1, "%s:\n", __FUNCTION__);
356 ssd->worker = qxl_worker;
357 }
358
359 static void interface_set_compression_level(QXLInstance *sin, int level)
360 {
361 dprint(1, "%s:\n", __FUNCTION__);
362 /* nothing to do */
363 }
364
365 static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
366 {
367 dprint(3, "%s:\n", __FUNCTION__);
368 /* nothing to do */
369 }
370
371 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
372 {
373 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
374
375 info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
376 info->memslot_id_bits = MEMSLOT_SLOT_BITS;
377 info->num_memslots = NUM_MEMSLOTS;
378 info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
379 info->internal_groupslot_id = 0;
380 info->qxl_ram_size = ssd->bufsize;
381 info->n_surfaces = NUM_SURFACES;
382 }
383
384 static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
385 {
386 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
387 SimpleSpiceUpdate *update;
388 int ret = false;
389
390 dprint(3, "%s:\n", __FUNCTION__);
391
392 qemu_mutex_lock(&ssd->lock);
393 if (ssd->update != NULL) {
394 update = ssd->update;
395 ssd->update = NULL;
396 *ext = update->ext;
397 ret = true;
398 }
399 qemu_mutex_unlock(&ssd->lock);
400
401 return ret;
402 }
403
404 static int interface_req_cmd_notification(QXLInstance *sin)
405 {
406 dprint(1, "%s:\n", __FUNCTION__);
407 return 1;
408 }
409
410 static void interface_release_resource(QXLInstance *sin,
411 struct QXLReleaseInfoExt ext)
412 {
413 SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
414 uintptr_t id;
415
416 dprint(2, "%s:\n", __FUNCTION__);
417 id = ext.info->id;
418 qemu_spice_destroy_update(ssd, (void*)id);
419 }
420
421 static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
422 {
423 dprint(3, "%s:\n", __FUNCTION__);
424 return false;
425 }
426
427 static int interface_req_cursor_notification(QXLInstance *sin)
428 {
429 dprint(1, "%s:\n", __FUNCTION__);
430 return 1;
431 }
432
433 static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
434 {
435 fprintf(stderr, "%s: abort()\n", __FUNCTION__);
436 abort();
437 }
438
439 static int interface_flush_resources(QXLInstance *sin)
440 {
441 fprintf(stderr, "%s: abort()\n", __FUNCTION__);
442 abort();
443 return 0;
444 }
445
446 static const QXLInterface dpy_interface = {
447 .base.type = SPICE_INTERFACE_QXL,
448 .base.description = "qemu simple display",
449 .base.major_version = SPICE_INTERFACE_QXL_MAJOR,
450 .base.minor_version = SPICE_INTERFACE_QXL_MINOR,
451
452 .attache_worker = interface_attach_worker,
453 .set_compression_level = interface_set_compression_level,
454 .set_mm_time = interface_set_mm_time,
455 .get_init_info = interface_get_init_info,
456
457 /* the callbacks below are called from spice server thread context */
458 .get_command = interface_get_command,
459 .req_cmd_notification = interface_req_cmd_notification,
460 .release_resource = interface_release_resource,
461 .get_cursor_command = interface_get_cursor_command,
462 .req_cursor_notification = interface_req_cursor_notification,
463 .notify_update = interface_notify_update,
464 .flush_resources = interface_flush_resources,
465 };
466
467 static SimpleSpiceDisplay sdpy;
468
469 static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
470 {
471 qemu_spice_display_update(&sdpy, x, y, w, h);
472 }
473
474 static void display_resize(struct DisplayState *ds)
475 {
476 qemu_spice_display_resize(&sdpy);
477 }
478
479 static void display_refresh(struct DisplayState *ds)
480 {
481 qemu_spice_display_refresh(&sdpy);
482 }
483
484 static DisplayChangeListener display_listener = {
485 .dpy_update = display_update,
486 .dpy_resize = display_resize,
487 .dpy_refresh = display_refresh,
488 };
489
490 void qemu_spice_display_init(DisplayState *ds)
491 {
492 assert(sdpy.ds == NULL);
493 qemu_spice_display_init_common(&sdpy, ds);
494 register_displaychangelistener(ds, &display_listener);
495
496 sdpy.qxl.base.sif = &dpy_interface.base;
497 qemu_spice_add_interface(&sdpy.qxl.base);
498 assert(sdpy.worker);
499
500 qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
501 qemu_spice_create_host_memslot(&sdpy);
502 qemu_spice_create_host_primary(&sdpy);
503 }