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 } 504