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 #include "trace.h"
  26
  27 #include "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         ssd->worker->add_memslot(ssd->worker, 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     ssd->worker->del_memslot(ssd->worker, 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         ssd->worker->create_primary_surface(ssd->worker, 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         ssd->worker->destroy_primary_surface(ssd->worker, id);
 120     }
 121 }
 122
 123 void qemu_spice_wakeup(SimpleSpiceDisplay *ssd)
 124 {
 125     trace_qemu_spice_wakeup(ssd->qxl.id);
 126     ssd->worker->wakeup(ssd->worker);
 127 }
 128
 129 void qemu_spice_start(SimpleSpiceDisplay *ssd)
 130 {
 131     trace_qemu_spice_start(ssd->qxl.id);
 132     ssd->worker->start(ssd->worker);
 133 }
 134
 135 void qemu_spice_stop(SimpleSpiceDisplay *ssd)
 136 {
 137     trace_qemu_spice_stop(ssd->qxl.id);
 138     ssd->worker->stop(ssd->worker);
 139 }
 140
 141 static SimpleSpiceUpdate *qemu_spice_create_update(SimpleSpiceDisplay *ssd)
 142 {
 143     SimpleSpiceUpdate *update;
 144     QXLDrawable *drawable;
 145     QXLImage *image;
 146     QXLCommand *cmd;
 147     uint8_t *src, *dst;
 148     int by, bw, bh;
 149     struct timespec time_space;
 150
 151     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
 152         return NULL;
 153     };
 154
 155     trace_qemu_spice_create_update(
 156            ssd->dirty.left, ssd->dirty.right,
 157            ssd->dirty.top, ssd->dirty.bottom);
 158
 159     update   = g_malloc0(sizeof(*update));
 160     drawable = &update->drawable;
 161     image    = &update->image;
 162     cmd      = &update->ext.cmd;
 163
 164     bw       = ssd->dirty.right - ssd->dirty.left;
 165     bh       = ssd->dirty.bottom - ssd->dirty.top;
 166     update->bitmap = g_malloc(bw * bh * 4);
 167
 168     drawable->bbox            = ssd->dirty;
 169     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
 170     drawable->effect          = QXL_EFFECT_OPAQUE;
 171     drawable->release_info.id = (uintptr_t)update;
 172     drawable->type            = QXL_DRAW_COPY;
 173     drawable->surfaces_dest[0] = -1;
 174     drawable->surfaces_dest[1] = -1;
 175     drawable->surfaces_dest[2] = -1;
 176     clock_gettime(CLOCK_MONOTONIC, &time_space);
 177     /* time in milliseconds from epoch. */
 178     drawable->mm_time = time_space.tv_sec * 1000
 179                       + time_space.tv_nsec / 1000 / 1000;
 180
 181     drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
 182     drawable->u.copy.src_bitmap      = (uintptr_t)image;
 183     drawable->u.copy.src_area.right  = bw;
 184     drawable->u.copy.src_area.bottom = bh;
 185
 186     QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
 187     image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
 188     image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
 189     image->bitmap.stride     = bw * 4;
 190     image->descriptor.width  = image->bitmap.x = bw;
 191     image->descriptor.height = image->bitmap.y = bh;
 192     image->bitmap.data = (uintptr_t)(update->bitmap);
 193     image->bitmap.palette = 0;
 194     image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
 195
 196     if (ssd->conv == NULL) {
 197         PixelFormat dst = qemu_default_pixelformat(32);
 198         ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
 199         assert(ssd->conv);
 200     }
 201
 202     src = ds_get_data(ssd->ds) +
 203         ssd->dirty.top * ds_get_linesize(ssd->ds) +
 204         ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
 205     dst = update->bitmap;
 206     for (by = 0; by < bh; by++) {
 207         qemu_pf_conv_run(ssd->conv, dst, src, bw);
 208         src += ds_get_linesize(ssd->ds);
 209         dst += image->bitmap.stride;
 210     }
 211
 212     cmd->type = QXL_CMD_DRAW;
 213     cmd->data = (uintptr_t)drawable;
 214
 215     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
 216     return update;
 217 }
 218
 219 /*
 220  * Called from spice server thread context (via interface_release_ressource)
 221  * We do *not* hold the global qemu mutex here, so extra care is needed
 222  * when calling qemu functions.  QEMU interfaces used:
 223  *    - g_free (underlying glibc free is re-entrant).
 224  */
 225 void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
 226 {
 227     g_free(update->bitmap);
 228     g_free(update);
 229 }
 230
 231 void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
 232 {
 233     QXLDevMemSlot memslot;
 234
 235     dprint(1, "%s:\n", __FUNCTION__);
 236
 237     memset(&memslot, 0, sizeof(memslot));
 238     memslot.slot_group_id = MEMSLOT_GROUP_HOST;
 239     memslot.virt_end = ~0;
 240     qemu_spice_add_memslot(ssd, &memslot, QXL_SYNC);
 241 }
 242
 243 void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
 244 {
 245     QXLDevSurfaceCreate surface;
 246
 247     memset(&surface, 0, sizeof(surface));
 248
 249     dprint(1, "%s: %dx%d\n", __FUNCTION__,
 250            ds_get_width(ssd->ds), ds_get_height(ssd->ds));
 251
 252     surface.format     = SPICE_SURFACE_FMT_32_xRGB;
 253     surface.width      = ds_get_width(ssd->ds);
 254     surface.height     = ds_get_height(ssd->ds);
 255     surface.stride     = -surface.width * 4;
 256     surface.mouse_mode = true;
 257     surface.flags      = 0;
 258     surface.type       = 0;
 259     surface.mem        = (uintptr_t)ssd->buf;
 260     surface.group_id   = MEMSLOT_GROUP_HOST;
 261
 262     qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
 263 }
 264
 265 void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
 266 {
 267     dprint(1, "%s:\n", __FUNCTION__);
 268
 269     qemu_spice_destroy_primary_surface(ssd, 0, QXL_SYNC);
 270 }
 271
 272 void qemu_spice_vm_change_state_handler(void *opaque, int running,
 273                                         RunState state)
 274 {
 275     SimpleSpiceDisplay *ssd = opaque;
 276
 277     if (running) {
 278         ssd->running = true;
 279         qemu_spice_start(ssd);
 280     } else {
 281         qemu_spice_stop(ssd);
 282         ssd->running = false;
 283     }
 284 }
 285
 286 void qemu_spice_display_init_common(SimpleSpiceDisplay *ssd, DisplayState *ds)
 287 {
 288     ssd->ds = ds;
 289     qemu_mutex_init(&ssd->lock);
 290     ssd->mouse_x = -1;
 291     ssd->mouse_y = -1;
 292     ssd->bufsize = (16 * 1024 * 1024);
 293     ssd->buf = g_malloc(ssd->bufsize);
 294 }
 295
 296 /* display listener callbacks */
 297
 298 void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
 299                                int x, int y, int w, int h)
 300 {
 301     QXLRect update_area;
 302
 303     dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
 304     update_area.left = x,
 305     update_area.right = x + w;
 306     update_area.top = y;
 307     update_area.bottom = y + h;
 308
 309     if (qemu_spice_rect_is_empty(&ssd->dirty)) {
 310         ssd->notify++;
 311     }
 312     qemu_spice_rect_union(&ssd->dirty, &update_area);
 313 }
 314
 315 void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
 316 {
 317     dprint(1, "%s:\n", __FUNCTION__);
 318
 319     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
 320     qemu_pf_conv_put(ssd->conv);
 321     ssd->conv = NULL;
 322
 323     qemu_mutex_lock(&ssd->lock);
 324     if (ssd->update != NULL) {
 325         qemu_spice_destroy_update(ssd, ssd->update);
 326         ssd->update = NULL;
 327     }
 328     qemu_mutex_unlock(&ssd->lock);
 329     qemu_spice_destroy_host_primary(ssd);
 330     qemu_spice_create_host_primary(ssd);
 331
 332     memset(&ssd->dirty, 0, sizeof(ssd->dirty));
 333     ssd->notify++;
 334 }
 335
 336 void qemu_spice_cursor_refresh_unlocked(SimpleSpiceDisplay *ssd)
 337 {
 338     if (ssd->cursor) {
 339         ssd->ds->cursor_define(ssd->cursor);
 340         cursor_put(ssd->cursor);
 341         ssd->cursor = NULL;
 342     }
 343     if (ssd->mouse_x != -1 && ssd->mouse_y != -1) {
 344         ssd->ds->mouse_set(ssd->mouse_x, ssd->mouse_y, 1);
 345         ssd->mouse_x = -1;
 346         ssd->mouse_y = -1;
 347     }
 348 }
 349
 350 void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
 351 {
 352     dprint(3, "%s:\n", __func__);
 353     vga_hw_update();
 354
 355     qemu_mutex_lock(&ssd->lock);
 356     if (ssd->update == NULL) {
 357         ssd->update = qemu_spice_create_update(ssd);
 358         ssd->notify++;
 359     }
 360     qemu_spice_cursor_refresh_unlocked(ssd);
 361     qemu_mutex_unlock(&ssd->lock);
 362
 363     if (ssd->notify) {
 364         ssd->notify = 0;
 365         qemu_spice_wakeup(ssd);
 366         dprint(2, "%s: notify\n", __FUNCTION__);
 367     }
 368 }
 369
 370 /* spice display interface callbacks */
 371
 372 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
 373 {
 374     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
 375
 376     dprint(1, "%s:\n", __FUNCTION__);
 377     ssd->worker = qxl_worker;
 378 }
 379
 380 static void interface_set_compression_level(QXLInstance *sin, int level)
 381 {
 382     dprint(1, "%s:\n", __FUNCTION__);
 383     /* nothing to do */
 384 }
 385
 386 static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
 387 {
 388     dprint(3, "%s:\n", __FUNCTION__);
 389     /* nothing to do */
 390 }
 391
 392 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
 393 {
 394     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
 395
 396     info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
 397     info->memslot_id_bits  = MEMSLOT_SLOT_BITS;
 398     info->num_memslots = NUM_MEMSLOTS;
 399     info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
 400     info->internal_groupslot_id = 0;
 401     info->qxl_ram_size = ssd->bufsize;
 402     info->n_surfaces = NUM_SURFACES;
 403 }
 404
 405 static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
 406 {
 407     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
 408     SimpleSpiceUpdate *update;
 409     int ret = false;
 410
 411     dprint(3, "%s:\n", __FUNCTION__);
 412
 413     qemu_mutex_lock(&ssd->lock);
 414     if (ssd->update != NULL) {
 415         update = ssd->update;
 416         ssd->update = NULL;
 417         *ext = update->ext;
 418         ret = true;
 419     }
 420     qemu_mutex_unlock(&ssd->lock);
 421
 422     return ret;
 423 }
 424
 425 static int interface_req_cmd_notification(QXLInstance *sin)
 426 {
 427     dprint(1, "%s:\n", __FUNCTION__);
 428     return 1;
 429 }
 430
 431 static void interface_release_resource(QXLInstance *sin,
 432                                        struct QXLReleaseInfoExt ext)
 433 {
 434     SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
 435     uintptr_t id;
 436
 437     dprint(2, "%s:\n", __FUNCTION__);
 438     id = ext.info->id;
 439     qemu_spice_destroy_update(ssd, (void*)id);
 440 }
 441
 442 static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
 443 {
 444     dprint(3, "%s:\n", __FUNCTION__);
 445     return false;
 446 }
 447
 448 static int interface_req_cursor_notification(QXLInstance *sin)
 449 {
 450     dprint(1, "%s:\n", __FUNCTION__);
 451     return 1;
 452 }
 453
 454 static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
 455 {
 456     fprintf(stderr, "%s: abort()\n", __FUNCTION__);
 457     abort();
 458 }
 459
 460 static int interface_flush_resources(QXLInstance *sin)
 461 {
 462     fprintf(stderr, "%s: abort()\n", __FUNCTION__);
 463     abort();
 464     return 0;
 465 }
 466
 467 static const QXLInterface dpy_interface = {
 468     .base.type               = SPICE_INTERFACE_QXL,
 469     .base.description        = "qemu simple display",
 470     .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
 471     .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,
 472
 473     .attache_worker          = interface_attach_worker,
 474     .set_compression_level   = interface_set_compression_level,
 475     .set_mm_time             = interface_set_mm_time,
 476     .get_init_info           = interface_get_init_info,
 477
 478     /* the callbacks below are called from spice server thread context */
 479     .get_command             = interface_get_command,
 480     .req_cmd_notification    = interface_req_cmd_notification,
 481     .release_resource        = interface_release_resource,
 482     .get_cursor_command      = interface_get_cursor_command,
 483     .req_cursor_notification = interface_req_cursor_notification,
 484     .notify_update           = interface_notify_update,
 485     .flush_resources         = interface_flush_resources,
 486 };
 487
 488 static SimpleSpiceDisplay sdpy;
 489
 490 static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
 491 {
 492     qemu_spice_display_update(&sdpy, x, y, w, h);
 493 }
 494
 495 static void display_resize(struct DisplayState *ds)
 496 {
 497     qemu_spice_display_resize(&sdpy);
 498 }
 499
 500 static void display_refresh(struct DisplayState *ds)
 501 {
 502     qemu_spice_display_refresh(&sdpy);
 503 }
 504
 505 static DisplayChangeListener display_listener = {
 506     .dpy_update  = display_update,
 507     .dpy_resize  = display_resize,
 508     .dpy_refresh = display_refresh,
 509 };
 510
 511 void qemu_spice_display_init(DisplayState *ds)
 512 {
 513     assert(sdpy.ds == NULL);
 514     qemu_spice_display_init_common(&sdpy, ds);
 515     register_displaychangelistener(ds, &display_listener);
 516
 517     sdpy.qxl.base.sif = &dpy_interface.base;
 518     qemu_spice_add_interface(&sdpy.qxl.base);
 519     assert(sdpy.worker);
 520
 521     qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
 522     qemu_spice_create_host_memslot(&sdpy);
 523     qemu_spice_create_host_primary(&sdpy);
 524 }