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 }