1 /* 2 * Virtio GPU Device 3 * 4 * Copyright Red Hat, Inc. 2013-2014 5 * 6 * Authors: 7 * Dave Airlie <airlied@redhat.com> 8 * Gerd Hoffmann <kraxel@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "qemu-common.h" 16 #include "qemu/iov.h" 17 #include "ui/console.h" 18 #include "trace.h" 19 #include "hw/virtio/virtio.h" 20 #include "hw/virtio/virtio-gpu.h" 21 #include "hw/virtio/virtio-bus.h" 22 #include "migration/blocker.h" 23 #include "qemu/log.h" 24 #include "qapi/error.h" 25 26 #define VIRTIO_GPU_VM_VERSION 1 27 28 static struct virtio_gpu_simple_resource* 29 virtio_gpu_find_resource(VirtIOGPU *g, uint32_t resource_id); 30 31 static void virtio_gpu_cleanup_mapping(struct virtio_gpu_simple_resource *res); 32 33 static void 34 virtio_gpu_ctrl_hdr_bswap(struct virtio_gpu_ctrl_hdr *hdr) 35 { 36 le32_to_cpus(&hdr->type); 37 le32_to_cpus(&hdr->flags); 38 le64_to_cpus(&hdr->fence_id); 39 le32_to_cpus(&hdr->ctx_id); 40 le32_to_cpus(&hdr->padding); 41 } 42 43 static void virtio_gpu_bswap_32(void *ptr, 44 size_t size) 45 { 46 #ifdef HOST_WORDS_BIGENDIAN 47 48 size_t i; 49 struct virtio_gpu_ctrl_hdr *hdr = (struct virtio_gpu_ctrl_hdr *) ptr; 50 51 virtio_gpu_ctrl_hdr_bswap(hdr); 52 53 i = sizeof(struct virtio_gpu_ctrl_hdr); 54 while (i < size) { 55 le32_to_cpus((uint32_t *)(ptr + i)); 56 i = i + sizeof(uint32_t); 57 } 58 59 #endif 60 } 61 62 static void 63 virtio_gpu_t2d_bswap(struct virtio_gpu_transfer_to_host_2d *t2d) 64 { 65 virtio_gpu_ctrl_hdr_bswap(&t2d->hdr); 66 le32_to_cpus(&t2d->r.x); 67 le32_to_cpus(&t2d->r.y); 68 le32_to_cpus(&t2d->r.width); 69 le32_to_cpus(&t2d->r.height); 70 le64_to_cpus(&t2d->offset); 71 le32_to_cpus(&t2d->resource_id); 72 le32_to_cpus(&t2d->padding); 73 } 74 75 #ifdef CONFIG_VIRGL 76 #include <virglrenderer.h> 77 #define VIRGL(_g, _virgl, _simple, ...) \ 78 do { \ 79 if (_g->use_virgl_renderer) { \ 80 _virgl(__VA_ARGS__); \ 81 } else { \ 82 _simple(__VA_ARGS__); \ 83 } \ 84 } while (0) 85 #else 86 #define VIRGL(_g, _virgl, _simple, ...) \ 87 do { \ 88 _simple(__VA_ARGS__); \ 89 } while (0) 90 #endif 91 92 static void update_cursor_data_simple(VirtIOGPU *g, 93 struct virtio_gpu_scanout *s, 94 uint32_t resource_id) 95 { 96 struct virtio_gpu_simple_resource *res; 97 uint32_t pixels; 98 99 res = virtio_gpu_find_resource(g, resource_id); 100 if (!res) { 101 return; 102 } 103 104 if (pixman_image_get_width(res->image) != s->current_cursor->width || 105 pixman_image_get_height(res->image) != s->current_cursor->height) { 106 return; 107 } 108 109 pixels = s->current_cursor->width * s->current_cursor->height; 110 memcpy(s->current_cursor->data, 111 pixman_image_get_data(res->image), 112 pixels * sizeof(uint32_t)); 113 } 114 115 #ifdef CONFIG_VIRGL 116 117 static void update_cursor_data_virgl(VirtIOGPU *g, 118 struct virtio_gpu_scanout *s, 119 uint32_t resource_id) 120 { 121 uint32_t width, height; 122 uint32_t pixels, *data; 123 124 data = virgl_renderer_get_cursor_data(resource_id, &width, &height); 125 if (!data) { 126 return; 127 } 128 129 if (width != s->current_cursor->width || 130 height != s->current_cursor->height) { 131 free(data); 132 return; 133 } 134 135 pixels = s->current_cursor->width * s->current_cursor->height; 136 memcpy(s->current_cursor->data, data, pixels * sizeof(uint32_t)); 137 free(data); 138 } 139 140 #endif 141 142 static void update_cursor(VirtIOGPU *g, struct virtio_gpu_update_cursor *cursor) 143 { 144 struct virtio_gpu_scanout *s; 145 bool move = cursor->hdr.type == VIRTIO_GPU_CMD_MOVE_CURSOR; 146 147 if (cursor->pos.scanout_id >= g->conf.max_outputs) { 148 return; 149 } 150 s = &g->scanout[cursor->pos.scanout_id]; 151 152 trace_virtio_gpu_update_cursor(cursor->pos.scanout_id, 153 cursor->pos.x, 154 cursor->pos.y, 155 move ? "move" : "update", 156 cursor->resource_id); 157 158 if (!move) { 159 if (!s->current_cursor) { 160 s->current_cursor = cursor_alloc(64, 64); 161 } 162 163 s->current_cursor->hot_x = cursor->hot_x; 164 s->current_cursor->hot_y = cursor->hot_y; 165 166 if (cursor->resource_id > 0) { 167 VIRGL(g, update_cursor_data_virgl, update_cursor_data_simple, 168 g, s, cursor->resource_id); 169 } 170 dpy_cursor_define(s->con, s->current_cursor); 171 172 s->cursor = *cursor; 173 } else { 174 s->cursor.pos.x = cursor->pos.x; 175 s->cursor.pos.y = cursor->pos.y; 176 } 177 dpy_mouse_set(s->con, cursor->pos.x, cursor->pos.y, 178 cursor->resource_id ? 1 : 0); 179 } 180 181 static void virtio_gpu_get_config(VirtIODevice *vdev, uint8_t *config) 182 { 183 VirtIOGPU *g = VIRTIO_GPU(vdev); 184 memcpy(config, &g->virtio_config, sizeof(g->virtio_config)); 185 } 186 187 static void virtio_gpu_set_config(VirtIODevice *vdev, const uint8_t *config) 188 { 189 VirtIOGPU *g = VIRTIO_GPU(vdev); 190 struct virtio_gpu_config vgconfig; 191 192 memcpy(&vgconfig, config, sizeof(g->virtio_config)); 193 194 if (vgconfig.events_clear) { 195 g->virtio_config.events_read &= ~vgconfig.events_clear; 196 } 197 } 198 199 static uint64_t virtio_gpu_get_features(VirtIODevice *vdev, uint64_t features, 200 Error **errp) 201 { 202 VirtIOGPU *g = VIRTIO_GPU(vdev); 203 204 if (virtio_gpu_virgl_enabled(g->conf)) { 205 features |= (1 << VIRTIO_GPU_F_VIRGL); 206 } 207 return features; 208 } 209 210 static void virtio_gpu_set_features(VirtIODevice *vdev, uint64_t features) 211 { 212 static const uint32_t virgl = (1 << VIRTIO_GPU_F_VIRGL); 213 VirtIOGPU *g = VIRTIO_GPU(vdev); 214 215 g->use_virgl_renderer = ((features & virgl) == virgl); 216 trace_virtio_gpu_features(g->use_virgl_renderer); 217 } 218 219 static void virtio_gpu_notify_event(VirtIOGPU *g, uint32_t event_type) 220 { 221 g->virtio_config.events_read |= event_type; 222 virtio_notify_config(&g->parent_obj); 223 } 224 225 static struct virtio_gpu_simple_resource * 226 virtio_gpu_find_resource(VirtIOGPU *g, uint32_t resource_id) 227 { 228 struct virtio_gpu_simple_resource *res; 229 230 QTAILQ_FOREACH(res, &g->reslist, next) { 231 if (res->resource_id == resource_id) { 232 return res; 233 } 234 } 235 return NULL; 236 } 237 238 void virtio_gpu_ctrl_response(VirtIOGPU *g, 239 struct virtio_gpu_ctrl_command *cmd, 240 struct virtio_gpu_ctrl_hdr *resp, 241 size_t resp_len) 242 { 243 size_t s; 244 245 if (cmd->cmd_hdr.flags & VIRTIO_GPU_FLAG_FENCE) { 246 resp->flags |= VIRTIO_GPU_FLAG_FENCE; 247 resp->fence_id = cmd->cmd_hdr.fence_id; 248 resp->ctx_id = cmd->cmd_hdr.ctx_id; 249 } 250 virtio_gpu_ctrl_hdr_bswap(resp); 251 s = iov_from_buf(cmd->elem.in_sg, cmd->elem.in_num, 0, resp, resp_len); 252 if (s != resp_len) { 253 qemu_log_mask(LOG_GUEST_ERROR, 254 "%s: response size incorrect %zu vs %zu\n", 255 __func__, s, resp_len); 256 } 257 virtqueue_push(cmd->vq, &cmd->elem, s); 258 virtio_notify(VIRTIO_DEVICE(g), cmd->vq); 259 cmd->finished = true; 260 } 261 262 void virtio_gpu_ctrl_response_nodata(VirtIOGPU *g, 263 struct virtio_gpu_ctrl_command *cmd, 264 enum virtio_gpu_ctrl_type type) 265 { 266 struct virtio_gpu_ctrl_hdr resp; 267 268 memset(&resp, 0, sizeof(resp)); 269 resp.type = type; 270 virtio_gpu_ctrl_response(g, cmd, &resp, sizeof(resp)); 271 } 272 273 static void 274 virtio_gpu_fill_display_info(VirtIOGPU *g, 275 struct virtio_gpu_resp_display_info *dpy_info) 276 { 277 int i; 278 279 for (i = 0; i < g->conf.max_outputs; i++) { 280 if (g->enabled_output_bitmask & (1 << i)) { 281 dpy_info->pmodes[i].enabled = 1; 282 dpy_info->pmodes[i].r.width = cpu_to_le32(g->req_state[i].width); 283 dpy_info->pmodes[i].r.height = cpu_to_le32(g->req_state[i].height); 284 } 285 } 286 } 287 288 void virtio_gpu_get_display_info(VirtIOGPU *g, 289 struct virtio_gpu_ctrl_command *cmd) 290 { 291 struct virtio_gpu_resp_display_info display_info; 292 293 trace_virtio_gpu_cmd_get_display_info(); 294 memset(&display_info, 0, sizeof(display_info)); 295 display_info.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO; 296 virtio_gpu_fill_display_info(g, &display_info); 297 virtio_gpu_ctrl_response(g, cmd, &display_info.hdr, 298 sizeof(display_info)); 299 } 300 301 static pixman_format_code_t get_pixman_format(uint32_t virtio_gpu_format) 302 { 303 switch (virtio_gpu_format) { 304 case VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM: 305 return PIXMAN_BE_b8g8r8x8; 306 case VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM: 307 return PIXMAN_BE_b8g8r8a8; 308 case VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM: 309 return PIXMAN_BE_x8r8g8b8; 310 case VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM: 311 return PIXMAN_BE_a8r8g8b8; 312 case VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM: 313 return PIXMAN_BE_r8g8b8x8; 314 case VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM: 315 return PIXMAN_BE_r8g8b8a8; 316 case VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM: 317 return PIXMAN_BE_x8b8g8r8; 318 case VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM: 319 return PIXMAN_BE_a8b8g8r8; 320 default: 321 return 0; 322 } 323 } 324 325 static void virtio_gpu_resource_create_2d(VirtIOGPU *g, 326 struct virtio_gpu_ctrl_command *cmd) 327 { 328 pixman_format_code_t pformat; 329 struct virtio_gpu_simple_resource *res; 330 struct virtio_gpu_resource_create_2d c2d; 331 332 VIRTIO_GPU_FILL_CMD(c2d); 333 virtio_gpu_bswap_32(&c2d, sizeof(c2d)); 334 trace_virtio_gpu_cmd_res_create_2d(c2d.resource_id, c2d.format, 335 c2d.width, c2d.height); 336 337 if (c2d.resource_id == 0) { 338 qemu_log_mask(LOG_GUEST_ERROR, "%s: resource id 0 is not allowed\n", 339 __func__); 340 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 341 return; 342 } 343 344 res = virtio_gpu_find_resource(g, c2d.resource_id); 345 if (res) { 346 qemu_log_mask(LOG_GUEST_ERROR, "%s: resource already exists %d\n", 347 __func__, c2d.resource_id); 348 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 349 return; 350 } 351 352 res = g_new0(struct virtio_gpu_simple_resource, 1); 353 354 res->width = c2d.width; 355 res->height = c2d.height; 356 res->format = c2d.format; 357 res->resource_id = c2d.resource_id; 358 359 pformat = get_pixman_format(c2d.format); 360 if (!pformat) { 361 qemu_log_mask(LOG_GUEST_ERROR, 362 "%s: host couldn't handle guest format %d\n", 363 __func__, c2d.format); 364 g_free(res); 365 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER; 366 return; 367 } 368 369 res->hostmem = PIXMAN_FORMAT_BPP(pformat) * c2d.width * c2d.height; 370 if (res->hostmem + g->hostmem < g->conf.max_hostmem) { 371 res->image = pixman_image_create_bits(pformat, 372 c2d.width, 373 c2d.height, 374 NULL, 0); 375 } 376 377 if (!res->image) { 378 qemu_log_mask(LOG_GUEST_ERROR, 379 "%s: resource creation failed %d %d %d\n", 380 __func__, c2d.resource_id, c2d.width, c2d.height); 381 g_free(res); 382 cmd->error = VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY; 383 return; 384 } 385 386 QTAILQ_INSERT_HEAD(&g->reslist, res, next); 387 g->hostmem += res->hostmem; 388 } 389 390 static void virtio_gpu_resource_destroy(VirtIOGPU *g, 391 struct virtio_gpu_simple_resource *res) 392 { 393 pixman_image_unref(res->image); 394 virtio_gpu_cleanup_mapping(res); 395 QTAILQ_REMOVE(&g->reslist, res, next); 396 g->hostmem -= res->hostmem; 397 g_free(res); 398 } 399 400 static void virtio_gpu_resource_unref(VirtIOGPU *g, 401 struct virtio_gpu_ctrl_command *cmd) 402 { 403 struct virtio_gpu_simple_resource *res; 404 struct virtio_gpu_resource_unref unref; 405 406 VIRTIO_GPU_FILL_CMD(unref); 407 virtio_gpu_bswap_32(&unref, sizeof(unref)); 408 trace_virtio_gpu_cmd_res_unref(unref.resource_id); 409 410 res = virtio_gpu_find_resource(g, unref.resource_id); 411 if (!res) { 412 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 413 __func__, unref.resource_id); 414 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 415 return; 416 } 417 virtio_gpu_resource_destroy(g, res); 418 } 419 420 static void virtio_gpu_transfer_to_host_2d(VirtIOGPU *g, 421 struct virtio_gpu_ctrl_command *cmd) 422 { 423 struct virtio_gpu_simple_resource *res; 424 int h; 425 uint32_t src_offset, dst_offset, stride; 426 int bpp; 427 pixman_format_code_t format; 428 struct virtio_gpu_transfer_to_host_2d t2d; 429 430 VIRTIO_GPU_FILL_CMD(t2d); 431 virtio_gpu_t2d_bswap(&t2d); 432 trace_virtio_gpu_cmd_res_xfer_toh_2d(t2d.resource_id); 433 434 res = virtio_gpu_find_resource(g, t2d.resource_id); 435 if (!res || !res->iov) { 436 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 437 __func__, t2d.resource_id); 438 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 439 return; 440 } 441 442 if (t2d.r.x > res->width || 443 t2d.r.y > res->height || 444 t2d.r.width > res->width || 445 t2d.r.height > res->height || 446 t2d.r.x + t2d.r.width > res->width || 447 t2d.r.y + t2d.r.height > res->height) { 448 qemu_log_mask(LOG_GUEST_ERROR, "%s: transfer bounds outside resource" 449 " bounds for resource %d: %d %d %d %d vs %d %d\n", 450 __func__, t2d.resource_id, t2d.r.x, t2d.r.y, 451 t2d.r.width, t2d.r.height, res->width, res->height); 452 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER; 453 return; 454 } 455 456 format = pixman_image_get_format(res->image); 457 bpp = DIV_ROUND_UP(PIXMAN_FORMAT_BPP(format), 8); 458 stride = pixman_image_get_stride(res->image); 459 460 if (t2d.offset || t2d.r.x || t2d.r.y || 461 t2d.r.width != pixman_image_get_width(res->image)) { 462 void *img_data = pixman_image_get_data(res->image); 463 for (h = 0; h < t2d.r.height; h++) { 464 src_offset = t2d.offset + stride * h; 465 dst_offset = (t2d.r.y + h) * stride + (t2d.r.x * bpp); 466 467 iov_to_buf(res->iov, res->iov_cnt, src_offset, 468 (uint8_t *)img_data 469 + dst_offset, t2d.r.width * bpp); 470 } 471 } else { 472 iov_to_buf(res->iov, res->iov_cnt, 0, 473 pixman_image_get_data(res->image), 474 pixman_image_get_stride(res->image) 475 * pixman_image_get_height(res->image)); 476 } 477 } 478 479 static void virtio_gpu_resource_flush(VirtIOGPU *g, 480 struct virtio_gpu_ctrl_command *cmd) 481 { 482 struct virtio_gpu_simple_resource *res; 483 struct virtio_gpu_resource_flush rf; 484 pixman_region16_t flush_region; 485 int i; 486 487 VIRTIO_GPU_FILL_CMD(rf); 488 virtio_gpu_bswap_32(&rf, sizeof(rf)); 489 trace_virtio_gpu_cmd_res_flush(rf.resource_id, 490 rf.r.width, rf.r.height, rf.r.x, rf.r.y); 491 492 res = virtio_gpu_find_resource(g, rf.resource_id); 493 if (!res) { 494 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 495 __func__, rf.resource_id); 496 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 497 return; 498 } 499 500 if (rf.r.x > res->width || 501 rf.r.y > res->height || 502 rf.r.width > res->width || 503 rf.r.height > res->height || 504 rf.r.x + rf.r.width > res->width || 505 rf.r.y + rf.r.height > res->height) { 506 qemu_log_mask(LOG_GUEST_ERROR, "%s: flush bounds outside resource" 507 " bounds for resource %d: %d %d %d %d vs %d %d\n", 508 __func__, rf.resource_id, rf.r.x, rf.r.y, 509 rf.r.width, rf.r.height, res->width, res->height); 510 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER; 511 return; 512 } 513 514 pixman_region_init_rect(&flush_region, 515 rf.r.x, rf.r.y, rf.r.width, rf.r.height); 516 for (i = 0; i < g->conf.max_outputs; i++) { 517 struct virtio_gpu_scanout *scanout; 518 pixman_region16_t region, finalregion; 519 pixman_box16_t *extents; 520 521 if (!(res->scanout_bitmask & (1 << i))) { 522 continue; 523 } 524 scanout = &g->scanout[i]; 525 526 pixman_region_init(&finalregion); 527 pixman_region_init_rect(®ion, scanout->x, scanout->y, 528 scanout->width, scanout->height); 529 530 pixman_region_intersect(&finalregion, &flush_region, ®ion); 531 pixman_region_translate(&finalregion, -scanout->x, -scanout->y); 532 extents = pixman_region_extents(&finalregion); 533 /* work out the area we need to update for each console */ 534 dpy_gfx_update(g->scanout[i].con, 535 extents->x1, extents->y1, 536 extents->x2 - extents->x1, 537 extents->y2 - extents->y1); 538 539 pixman_region_fini(®ion); 540 pixman_region_fini(&finalregion); 541 } 542 pixman_region_fini(&flush_region); 543 } 544 545 static void virtio_unref_resource(pixman_image_t *image, void *data) 546 { 547 pixman_image_unref(data); 548 } 549 550 static void virtio_gpu_set_scanout(VirtIOGPU *g, 551 struct virtio_gpu_ctrl_command *cmd) 552 { 553 struct virtio_gpu_simple_resource *res; 554 struct virtio_gpu_scanout *scanout; 555 pixman_format_code_t format; 556 uint32_t offset; 557 int bpp; 558 struct virtio_gpu_set_scanout ss; 559 560 VIRTIO_GPU_FILL_CMD(ss); 561 virtio_gpu_bswap_32(&ss, sizeof(ss)); 562 trace_virtio_gpu_cmd_set_scanout(ss.scanout_id, ss.resource_id, 563 ss.r.width, ss.r.height, ss.r.x, ss.r.y); 564 565 if (ss.scanout_id >= g->conf.max_outputs) { 566 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal scanout id specified %d", 567 __func__, ss.scanout_id); 568 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID; 569 return; 570 } 571 572 g->enable = 1; 573 if (ss.resource_id == 0) { 574 scanout = &g->scanout[ss.scanout_id]; 575 if (scanout->resource_id) { 576 res = virtio_gpu_find_resource(g, scanout->resource_id); 577 if (res) { 578 res->scanout_bitmask &= ~(1 << ss.scanout_id); 579 } 580 } 581 if (ss.scanout_id == 0) { 582 qemu_log_mask(LOG_GUEST_ERROR, 583 "%s: illegal scanout id specified %d", 584 __func__, ss.scanout_id); 585 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID; 586 return; 587 } 588 dpy_gfx_replace_surface(g->scanout[ss.scanout_id].con, NULL); 589 scanout->ds = NULL; 590 scanout->width = 0; 591 scanout->height = 0; 592 return; 593 } 594 595 /* create a surface for this scanout */ 596 res = virtio_gpu_find_resource(g, ss.resource_id); 597 if (!res) { 598 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 599 __func__, ss.resource_id); 600 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 601 return; 602 } 603 604 if (ss.r.x > res->width || 605 ss.r.y > res->height || 606 ss.r.width > res->width || 607 ss.r.height > res->height || 608 ss.r.x + ss.r.width > res->width || 609 ss.r.y + ss.r.height > res->height) { 610 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal scanout %d bounds for" 611 " resource %d, (%d,%d)+%d,%d vs %d %d\n", 612 __func__, ss.scanout_id, ss.resource_id, ss.r.x, ss.r.y, 613 ss.r.width, ss.r.height, res->width, res->height); 614 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER; 615 return; 616 } 617 618 scanout = &g->scanout[ss.scanout_id]; 619 620 format = pixman_image_get_format(res->image); 621 bpp = DIV_ROUND_UP(PIXMAN_FORMAT_BPP(format), 8); 622 offset = (ss.r.x * bpp) + ss.r.y * pixman_image_get_stride(res->image); 623 if (!scanout->ds || surface_data(scanout->ds) 624 != ((uint8_t *)pixman_image_get_data(res->image) + offset) || 625 scanout->width != ss.r.width || 626 scanout->height != ss.r.height) { 627 pixman_image_t *rect; 628 void *ptr = (uint8_t *)pixman_image_get_data(res->image) + offset; 629 rect = pixman_image_create_bits(format, ss.r.width, ss.r.height, ptr, 630 pixman_image_get_stride(res->image)); 631 pixman_image_ref(res->image); 632 pixman_image_set_destroy_function(rect, virtio_unref_resource, 633 res->image); 634 /* realloc the surface ptr */ 635 scanout->ds = qemu_create_displaysurface_pixman(rect); 636 if (!scanout->ds) { 637 cmd->error = VIRTIO_GPU_RESP_ERR_UNSPEC; 638 return; 639 } 640 pixman_image_unref(rect); 641 dpy_gfx_replace_surface(g->scanout[ss.scanout_id].con, scanout->ds); 642 } 643 644 res->scanout_bitmask |= (1 << ss.scanout_id); 645 scanout->resource_id = ss.resource_id; 646 scanout->x = ss.r.x; 647 scanout->y = ss.r.y; 648 scanout->width = ss.r.width; 649 scanout->height = ss.r.height; 650 } 651 652 int virtio_gpu_create_mapping_iov(struct virtio_gpu_resource_attach_backing *ab, 653 struct virtio_gpu_ctrl_command *cmd, 654 uint64_t **addr, struct iovec **iov) 655 { 656 struct virtio_gpu_mem_entry *ents; 657 size_t esize, s; 658 int i; 659 660 if (ab->nr_entries > 16384) { 661 qemu_log_mask(LOG_GUEST_ERROR, 662 "%s: nr_entries is too big (%d > 16384)\n", 663 __func__, ab->nr_entries); 664 return -1; 665 } 666 667 esize = sizeof(*ents) * ab->nr_entries; 668 ents = g_malloc(esize); 669 s = iov_to_buf(cmd->elem.out_sg, cmd->elem.out_num, 670 sizeof(*ab), ents, esize); 671 if (s != esize) { 672 qemu_log_mask(LOG_GUEST_ERROR, 673 "%s: command data size incorrect %zu vs %zu\n", 674 __func__, s, esize); 675 g_free(ents); 676 return -1; 677 } 678 679 *iov = g_malloc0(sizeof(struct iovec) * ab->nr_entries); 680 if (addr) { 681 *addr = g_malloc0(sizeof(uint64_t) * ab->nr_entries); 682 } 683 for (i = 0; i < ab->nr_entries; i++) { 684 uint64_t a = le64_to_cpu(ents[i].addr); 685 uint32_t l = le32_to_cpu(ents[i].length); 686 hwaddr len = l; 687 (*iov)[i].iov_len = l; 688 (*iov)[i].iov_base = cpu_physical_memory_map(a, &len, 1); 689 if (addr) { 690 (*addr)[i] = a; 691 } 692 if (!(*iov)[i].iov_base || len != l) { 693 qemu_log_mask(LOG_GUEST_ERROR, "%s: failed to map MMIO memory for" 694 " resource %d element %d\n", 695 __func__, ab->resource_id, i); 696 virtio_gpu_cleanup_mapping_iov(*iov, i); 697 g_free(ents); 698 *iov = NULL; 699 if (addr) { 700 g_free(*addr); 701 *addr = NULL; 702 } 703 return -1; 704 } 705 } 706 g_free(ents); 707 return 0; 708 } 709 710 void virtio_gpu_cleanup_mapping_iov(struct iovec *iov, uint32_t count) 711 { 712 int i; 713 714 for (i = 0; i < count; i++) { 715 cpu_physical_memory_unmap(iov[i].iov_base, iov[i].iov_len, 1, 716 iov[i].iov_len); 717 } 718 g_free(iov); 719 } 720 721 static void virtio_gpu_cleanup_mapping(struct virtio_gpu_simple_resource *res) 722 { 723 virtio_gpu_cleanup_mapping_iov(res->iov, res->iov_cnt); 724 res->iov = NULL; 725 res->iov_cnt = 0; 726 g_free(res->addrs); 727 res->addrs = NULL; 728 } 729 730 static void 731 virtio_gpu_resource_attach_backing(VirtIOGPU *g, 732 struct virtio_gpu_ctrl_command *cmd) 733 { 734 struct virtio_gpu_simple_resource *res; 735 struct virtio_gpu_resource_attach_backing ab; 736 int ret; 737 738 VIRTIO_GPU_FILL_CMD(ab); 739 virtio_gpu_bswap_32(&ab, sizeof(ab)); 740 trace_virtio_gpu_cmd_res_back_attach(ab.resource_id); 741 742 res = virtio_gpu_find_resource(g, ab.resource_id); 743 if (!res) { 744 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 745 __func__, ab.resource_id); 746 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 747 return; 748 } 749 750 if (res->iov) { 751 cmd->error = VIRTIO_GPU_RESP_ERR_UNSPEC; 752 return; 753 } 754 755 ret = virtio_gpu_create_mapping_iov(&ab, cmd, &res->addrs, &res->iov); 756 if (ret != 0) { 757 cmd->error = VIRTIO_GPU_RESP_ERR_UNSPEC; 758 return; 759 } 760 761 res->iov_cnt = ab.nr_entries; 762 } 763 764 static void 765 virtio_gpu_resource_detach_backing(VirtIOGPU *g, 766 struct virtio_gpu_ctrl_command *cmd) 767 { 768 struct virtio_gpu_simple_resource *res; 769 struct virtio_gpu_resource_detach_backing detach; 770 771 VIRTIO_GPU_FILL_CMD(detach); 772 virtio_gpu_bswap_32(&detach, sizeof(detach)); 773 trace_virtio_gpu_cmd_res_back_detach(detach.resource_id); 774 775 res = virtio_gpu_find_resource(g, detach.resource_id); 776 if (!res || !res->iov) { 777 qemu_log_mask(LOG_GUEST_ERROR, "%s: illegal resource specified %d\n", 778 __func__, detach.resource_id); 779 cmd->error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID; 780 return; 781 } 782 virtio_gpu_cleanup_mapping(res); 783 } 784 785 static void virtio_gpu_simple_process_cmd(VirtIOGPU *g, 786 struct virtio_gpu_ctrl_command *cmd) 787 { 788 VIRTIO_GPU_FILL_CMD(cmd->cmd_hdr); 789 virtio_gpu_ctrl_hdr_bswap(&cmd->cmd_hdr); 790 791 switch (cmd->cmd_hdr.type) { 792 case VIRTIO_GPU_CMD_GET_DISPLAY_INFO: 793 virtio_gpu_get_display_info(g, cmd); 794 break; 795 case VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: 796 virtio_gpu_resource_create_2d(g, cmd); 797 break; 798 case VIRTIO_GPU_CMD_RESOURCE_UNREF: 799 virtio_gpu_resource_unref(g, cmd); 800 break; 801 case VIRTIO_GPU_CMD_RESOURCE_FLUSH: 802 virtio_gpu_resource_flush(g, cmd); 803 break; 804 case VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: 805 virtio_gpu_transfer_to_host_2d(g, cmd); 806 break; 807 case VIRTIO_GPU_CMD_SET_SCANOUT: 808 virtio_gpu_set_scanout(g, cmd); 809 break; 810 case VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING: 811 virtio_gpu_resource_attach_backing(g, cmd); 812 break; 813 case VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING: 814 virtio_gpu_resource_detach_backing(g, cmd); 815 break; 816 default: 817 cmd->error = VIRTIO_GPU_RESP_ERR_UNSPEC; 818 break; 819 } 820 if (!cmd->finished) { 821 virtio_gpu_ctrl_response_nodata(g, cmd, cmd->error ? cmd->error : 822 VIRTIO_GPU_RESP_OK_NODATA); 823 } 824 } 825 826 static void virtio_gpu_handle_ctrl_cb(VirtIODevice *vdev, VirtQueue *vq) 827 { 828 VirtIOGPU *g = VIRTIO_GPU(vdev); 829 qemu_bh_schedule(g->ctrl_bh); 830 } 831 832 static void virtio_gpu_handle_cursor_cb(VirtIODevice *vdev, VirtQueue *vq) 833 { 834 VirtIOGPU *g = VIRTIO_GPU(vdev); 835 qemu_bh_schedule(g->cursor_bh); 836 } 837 838 void virtio_gpu_process_cmdq(VirtIOGPU *g) 839 { 840 struct virtio_gpu_ctrl_command *cmd; 841 842 while (!QTAILQ_EMPTY(&g->cmdq)) { 843 cmd = QTAILQ_FIRST(&g->cmdq); 844 845 /* process command */ 846 VIRGL(g, virtio_gpu_virgl_process_cmd, virtio_gpu_simple_process_cmd, 847 g, cmd); 848 if (cmd->waiting) { 849 break; 850 } 851 QTAILQ_REMOVE(&g->cmdq, cmd, next); 852 if (virtio_gpu_stats_enabled(g->conf)) { 853 g->stats.requests++; 854 } 855 856 if (!cmd->finished) { 857 QTAILQ_INSERT_TAIL(&g->fenceq, cmd, next); 858 g->inflight++; 859 if (virtio_gpu_stats_enabled(g->conf)) { 860 if (g->stats.max_inflight < g->inflight) { 861 g->stats.max_inflight = g->inflight; 862 } 863 fprintf(stderr, "inflight: %3d (+)\r", g->inflight); 864 } 865 } else { 866 g_free(cmd); 867 } 868 } 869 } 870 871 static void virtio_gpu_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq) 872 { 873 VirtIOGPU *g = VIRTIO_GPU(vdev); 874 struct virtio_gpu_ctrl_command *cmd; 875 876 if (!virtio_queue_ready(vq)) { 877 return; 878 } 879 880 #ifdef CONFIG_VIRGL 881 if (!g->renderer_inited && g->use_virgl_renderer) { 882 virtio_gpu_virgl_init(g); 883 g->renderer_inited = true; 884 } 885 #endif 886 887 cmd = virtqueue_pop(vq, sizeof(struct virtio_gpu_ctrl_command)); 888 while (cmd) { 889 cmd->vq = vq; 890 cmd->error = 0; 891 cmd->finished = false; 892 cmd->waiting = false; 893 QTAILQ_INSERT_TAIL(&g->cmdq, cmd, next); 894 cmd = virtqueue_pop(vq, sizeof(struct virtio_gpu_ctrl_command)); 895 } 896 897 virtio_gpu_process_cmdq(g); 898 899 #ifdef CONFIG_VIRGL 900 if (g->use_virgl_renderer) { 901 virtio_gpu_virgl_fence_poll(g); 902 } 903 #endif 904 } 905 906 static void virtio_gpu_ctrl_bh(void *opaque) 907 { 908 VirtIOGPU *g = opaque; 909 virtio_gpu_handle_ctrl(&g->parent_obj, g->ctrl_vq); 910 } 911 912 static void virtio_gpu_handle_cursor(VirtIODevice *vdev, VirtQueue *vq) 913 { 914 VirtIOGPU *g = VIRTIO_GPU(vdev); 915 VirtQueueElement *elem; 916 size_t s; 917 struct virtio_gpu_update_cursor cursor_info; 918 919 if (!virtio_queue_ready(vq)) { 920 return; 921 } 922 for (;;) { 923 elem = virtqueue_pop(vq, sizeof(VirtQueueElement)); 924 if (!elem) { 925 break; 926 } 927 928 s = iov_to_buf(elem->out_sg, elem->out_num, 0, 929 &cursor_info, sizeof(cursor_info)); 930 if (s != sizeof(cursor_info)) { 931 qemu_log_mask(LOG_GUEST_ERROR, 932 "%s: cursor size incorrect %zu vs %zu\n", 933 __func__, s, sizeof(cursor_info)); 934 } else { 935 virtio_gpu_bswap_32(&cursor_info, sizeof(cursor_info)); 936 update_cursor(g, &cursor_info); 937 } 938 virtqueue_push(vq, elem, 0); 939 virtio_notify(vdev, vq); 940 g_free(elem); 941 } 942 } 943 944 static void virtio_gpu_cursor_bh(void *opaque) 945 { 946 VirtIOGPU *g = opaque; 947 virtio_gpu_handle_cursor(&g->parent_obj, g->cursor_vq); 948 } 949 950 static void virtio_gpu_invalidate_display(void *opaque) 951 { 952 } 953 954 static void virtio_gpu_update_display(void *opaque) 955 { 956 } 957 958 static void virtio_gpu_text_update(void *opaque, console_ch_t *chardata) 959 { 960 } 961 962 static int virtio_gpu_ui_info(void *opaque, uint32_t idx, QemuUIInfo *info) 963 { 964 VirtIOGPU *g = opaque; 965 966 if (idx >= g->conf.max_outputs) { 967 return -1; 968 } 969 970 g->req_state[idx].x = info->xoff; 971 g->req_state[idx].y = info->yoff; 972 g->req_state[idx].width = info->width; 973 g->req_state[idx].height = info->height; 974 975 if (info->width && info->height) { 976 g->enabled_output_bitmask |= (1 << idx); 977 } else { 978 g->enabled_output_bitmask &= ~(1 << idx); 979 } 980 981 /* send event to guest */ 982 virtio_gpu_notify_event(g, VIRTIO_GPU_EVENT_DISPLAY); 983 return 0; 984 } 985 986 const GraphicHwOps virtio_gpu_ops = { 987 .invalidate = virtio_gpu_invalidate_display, 988 .gfx_update = virtio_gpu_update_display, 989 .text_update = virtio_gpu_text_update, 990 .ui_info = virtio_gpu_ui_info, 991 #ifdef CONFIG_VIRGL 992 .gl_block = virtio_gpu_gl_block, 993 #endif 994 }; 995 996 static const VMStateDescription vmstate_virtio_gpu_scanout = { 997 .name = "virtio-gpu-one-scanout", 998 .version_id = 1, 999 .fields = (VMStateField[]) { 1000 VMSTATE_UINT32(resource_id, struct virtio_gpu_scanout), 1001 VMSTATE_UINT32(width, struct virtio_gpu_scanout), 1002 VMSTATE_UINT32(height, struct virtio_gpu_scanout), 1003 VMSTATE_INT32(x, struct virtio_gpu_scanout), 1004 VMSTATE_INT32(y, struct virtio_gpu_scanout), 1005 VMSTATE_UINT32(cursor.resource_id, struct virtio_gpu_scanout), 1006 VMSTATE_UINT32(cursor.hot_x, struct virtio_gpu_scanout), 1007 VMSTATE_UINT32(cursor.hot_y, struct virtio_gpu_scanout), 1008 VMSTATE_UINT32(cursor.pos.x, struct virtio_gpu_scanout), 1009 VMSTATE_UINT32(cursor.pos.y, struct virtio_gpu_scanout), 1010 VMSTATE_END_OF_LIST() 1011 }, 1012 }; 1013 1014 static const VMStateDescription vmstate_virtio_gpu_scanouts = { 1015 .name = "virtio-gpu-scanouts", 1016 .version_id = 1, 1017 .fields = (VMStateField[]) { 1018 VMSTATE_INT32(enable, struct VirtIOGPU), 1019 VMSTATE_UINT32_EQUAL(conf.max_outputs, struct VirtIOGPU, NULL), 1020 VMSTATE_STRUCT_VARRAY_UINT32(scanout, struct VirtIOGPU, 1021 conf.max_outputs, 1, 1022 vmstate_virtio_gpu_scanout, 1023 struct virtio_gpu_scanout), 1024 VMSTATE_END_OF_LIST() 1025 }, 1026 }; 1027 1028 static int virtio_gpu_save(QEMUFile *f, void *opaque, size_t size, 1029 VMStateField *field, QJSON *vmdesc) 1030 { 1031 VirtIOGPU *g = opaque; 1032 struct virtio_gpu_simple_resource *res; 1033 int i; 1034 1035 /* in 2d mode we should never find unprocessed commands here */ 1036 assert(QTAILQ_EMPTY(&g->cmdq)); 1037 1038 QTAILQ_FOREACH(res, &g->reslist, next) { 1039 qemu_put_be32(f, res->resource_id); 1040 qemu_put_be32(f, res->width); 1041 qemu_put_be32(f, res->height); 1042 qemu_put_be32(f, res->format); 1043 qemu_put_be32(f, res->iov_cnt); 1044 for (i = 0; i < res->iov_cnt; i++) { 1045 qemu_put_be64(f, res->addrs[i]); 1046 qemu_put_be32(f, res->iov[i].iov_len); 1047 } 1048 qemu_put_buffer(f, (void *)pixman_image_get_data(res->image), 1049 pixman_image_get_stride(res->image) * res->height); 1050 } 1051 qemu_put_be32(f, 0); /* end of list */ 1052 1053 vmstate_save_state(f, &vmstate_virtio_gpu_scanouts, g, NULL); 1054 1055 return 0; 1056 } 1057 1058 static int virtio_gpu_load(QEMUFile *f, void *opaque, size_t size, 1059 VMStateField *field) 1060 { 1061 VirtIOGPU *g = opaque; 1062 struct virtio_gpu_simple_resource *res; 1063 struct virtio_gpu_scanout *scanout; 1064 uint32_t resource_id, pformat; 1065 int i; 1066 1067 g->hostmem = 0; 1068 1069 resource_id = qemu_get_be32(f); 1070 while (resource_id != 0) { 1071 res = g_new0(struct virtio_gpu_simple_resource, 1); 1072 res->resource_id = resource_id; 1073 res->width = qemu_get_be32(f); 1074 res->height = qemu_get_be32(f); 1075 res->format = qemu_get_be32(f); 1076 res->iov_cnt = qemu_get_be32(f); 1077 1078 /* allocate */ 1079 pformat = get_pixman_format(res->format); 1080 if (!pformat) { 1081 g_free(res); 1082 return -EINVAL; 1083 } 1084 res->image = pixman_image_create_bits(pformat, 1085 res->width, res->height, 1086 NULL, 0); 1087 if (!res->image) { 1088 g_free(res); 1089 return -EINVAL; 1090 } 1091 1092 res->hostmem = PIXMAN_FORMAT_BPP(pformat) * res->width * res->height; 1093 1094 res->addrs = g_new(uint64_t, res->iov_cnt); 1095 res->iov = g_new(struct iovec, res->iov_cnt); 1096 1097 /* read data */ 1098 for (i = 0; i < res->iov_cnt; i++) { 1099 res->addrs[i] = qemu_get_be64(f); 1100 res->iov[i].iov_len = qemu_get_be32(f); 1101 } 1102 qemu_get_buffer(f, (void *)pixman_image_get_data(res->image), 1103 pixman_image_get_stride(res->image) * res->height); 1104 1105 /* restore mapping */ 1106 for (i = 0; i < res->iov_cnt; i++) { 1107 hwaddr len = res->iov[i].iov_len; 1108 res->iov[i].iov_base = 1109 cpu_physical_memory_map(res->addrs[i], &len, 1); 1110 if (!res->iov[i].iov_base || len != res->iov[i].iov_len) { 1111 /* Clean up the half-a-mapping we just created... */ 1112 if (res->iov[i].iov_base) { 1113 cpu_physical_memory_unmap(res->iov[i].iov_base, 1114 len, 0, 0); 1115 } 1116 /* ...and the mappings for previous loop iterations */ 1117 res->iov_cnt = i; 1118 virtio_gpu_cleanup_mapping(res); 1119 pixman_image_unref(res->image); 1120 g_free(res); 1121 return -EINVAL; 1122 } 1123 } 1124 1125 QTAILQ_INSERT_HEAD(&g->reslist, res, next); 1126 g->hostmem += res->hostmem; 1127 1128 resource_id = qemu_get_be32(f); 1129 } 1130 1131 /* load & apply scanout state */ 1132 vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1); 1133 for (i = 0; i < g->conf.max_outputs; i++) { 1134 scanout = &g->scanout[i]; 1135 if (!scanout->resource_id) { 1136 continue; 1137 } 1138 res = virtio_gpu_find_resource(g, scanout->resource_id); 1139 if (!res) { 1140 return -EINVAL; 1141 } 1142 scanout->ds = qemu_create_displaysurface_pixman(res->image); 1143 if (!scanout->ds) { 1144 return -EINVAL; 1145 } 1146 1147 dpy_gfx_replace_surface(scanout->con, scanout->ds); 1148 dpy_gfx_update(scanout->con, 0, 0, scanout->width, scanout->height); 1149 if (scanout->cursor.resource_id) { 1150 update_cursor(g, &scanout->cursor); 1151 } 1152 res->scanout_bitmask |= (1 << i); 1153 } 1154 1155 return 0; 1156 } 1157 1158 static void virtio_gpu_device_realize(DeviceState *qdev, Error **errp) 1159 { 1160 VirtIODevice *vdev = VIRTIO_DEVICE(qdev); 1161 VirtIOGPU *g = VIRTIO_GPU(qdev); 1162 bool have_virgl; 1163 Error *local_err = NULL; 1164 int i; 1165 1166 if (g->conf.max_outputs > VIRTIO_GPU_MAX_SCANOUTS) { 1167 error_setg(errp, "invalid max_outputs > %d", VIRTIO_GPU_MAX_SCANOUTS); 1168 return; 1169 } 1170 1171 g->use_virgl_renderer = false; 1172 #if !defined(CONFIG_VIRGL) || defined(HOST_WORDS_BIGENDIAN) 1173 have_virgl = false; 1174 #else 1175 have_virgl = display_opengl; 1176 #endif 1177 if (!have_virgl) { 1178 g->conf.flags &= ~(1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED); 1179 } 1180 1181 if (virtio_gpu_virgl_enabled(g->conf)) { 1182 error_setg(&g->migration_blocker, "virgl is not yet migratable"); 1183 migrate_add_blocker(g->migration_blocker, &local_err); 1184 if (local_err) { 1185 error_propagate(errp, local_err); 1186 error_free(g->migration_blocker); 1187 return; 1188 } 1189 } 1190 1191 g->config_size = sizeof(struct virtio_gpu_config); 1192 g->virtio_config.num_scanouts = cpu_to_le32(g->conf.max_outputs); 1193 virtio_init(VIRTIO_DEVICE(g), "virtio-gpu", VIRTIO_ID_GPU, 1194 g->config_size); 1195 1196 g->req_state[0].width = g->conf.xres; 1197 g->req_state[0].height = g->conf.yres; 1198 1199 if (virtio_gpu_virgl_enabled(g->conf)) { 1200 /* use larger control queue in 3d mode */ 1201 g->ctrl_vq = virtio_add_queue(vdev, 256, virtio_gpu_handle_ctrl_cb); 1202 g->cursor_vq = virtio_add_queue(vdev, 16, virtio_gpu_handle_cursor_cb); 1203 g->virtio_config.num_capsets = 1; 1204 } else { 1205 g->ctrl_vq = virtio_add_queue(vdev, 64, virtio_gpu_handle_ctrl_cb); 1206 g->cursor_vq = virtio_add_queue(vdev, 16, virtio_gpu_handle_cursor_cb); 1207 } 1208 1209 g->ctrl_bh = qemu_bh_new(virtio_gpu_ctrl_bh, g); 1210 g->cursor_bh = qemu_bh_new(virtio_gpu_cursor_bh, g); 1211 QTAILQ_INIT(&g->reslist); 1212 QTAILQ_INIT(&g->cmdq); 1213 QTAILQ_INIT(&g->fenceq); 1214 1215 g->enabled_output_bitmask = 1; 1216 g->qdev = qdev; 1217 1218 for (i = 0; i < g->conf.max_outputs; i++) { 1219 g->scanout[i].con = 1220 graphic_console_init(DEVICE(g), i, &virtio_gpu_ops, g); 1221 if (i > 0) { 1222 dpy_gfx_replace_surface(g->scanout[i].con, NULL); 1223 } 1224 } 1225 } 1226 1227 static void virtio_gpu_device_unrealize(DeviceState *qdev, Error **errp) 1228 { 1229 VirtIOGPU *g = VIRTIO_GPU(qdev); 1230 if (g->migration_blocker) { 1231 migrate_del_blocker(g->migration_blocker); 1232 error_free(g->migration_blocker); 1233 } 1234 } 1235 1236 static void virtio_gpu_instance_init(Object *obj) 1237 { 1238 } 1239 1240 static void virtio_gpu_reset(VirtIODevice *vdev) 1241 { 1242 VirtIOGPU *g = VIRTIO_GPU(vdev); 1243 struct virtio_gpu_simple_resource *res, *tmp; 1244 int i; 1245 1246 g->enable = 0; 1247 1248 QTAILQ_FOREACH_SAFE(res, &g->reslist, next, tmp) { 1249 virtio_gpu_resource_destroy(g, res); 1250 } 1251 for (i = 0; i < g->conf.max_outputs; i++) { 1252 g->scanout[i].resource_id = 0; 1253 g->scanout[i].width = 0; 1254 g->scanout[i].height = 0; 1255 g->scanout[i].x = 0; 1256 g->scanout[i].y = 0; 1257 g->scanout[i].ds = NULL; 1258 } 1259 1260 #ifdef CONFIG_VIRGL 1261 if (g->use_virgl_renderer) { 1262 virtio_gpu_virgl_reset(g); 1263 g->use_virgl_renderer = 0; 1264 } 1265 #endif 1266 } 1267 1268 /* 1269 * For historical reasons virtio_gpu does not adhere to virtio migration 1270 * scheme as described in doc/virtio-migration.txt, in a sense that no 1271 * save/load callback are provided to the core. Instead the device data 1272 * is saved/loaded after the core data. 1273 * 1274 * Because of this we need a special vmsd. 1275 */ 1276 static const VMStateDescription vmstate_virtio_gpu = { 1277 .name = "virtio-gpu", 1278 .minimum_version_id = VIRTIO_GPU_VM_VERSION, 1279 .version_id = VIRTIO_GPU_VM_VERSION, 1280 .fields = (VMStateField[]) { 1281 VMSTATE_VIRTIO_DEVICE /* core */, 1282 { 1283 .name = "virtio-gpu", 1284 .info = &(const VMStateInfo) { 1285 .name = "virtio-gpu", 1286 .get = virtio_gpu_load, 1287 .put = virtio_gpu_save, 1288 }, 1289 .flags = VMS_SINGLE, 1290 } /* device */, 1291 VMSTATE_END_OF_LIST() 1292 }, 1293 }; 1294 1295 static Property virtio_gpu_properties[] = { 1296 DEFINE_PROP_UINT32("max_outputs", VirtIOGPU, conf.max_outputs, 1), 1297 DEFINE_PROP_SIZE("max_hostmem", VirtIOGPU, conf.max_hostmem, 1298 256 * 1024 * 1024), 1299 #ifdef CONFIG_VIRGL 1300 DEFINE_PROP_BIT("virgl", VirtIOGPU, conf.flags, 1301 VIRTIO_GPU_FLAG_VIRGL_ENABLED, true), 1302 DEFINE_PROP_BIT("stats", VirtIOGPU, conf.flags, 1303 VIRTIO_GPU_FLAG_STATS_ENABLED, false), 1304 #endif 1305 DEFINE_PROP_UINT32("xres", VirtIOGPU, conf.xres, 1024), 1306 DEFINE_PROP_UINT32("yres", VirtIOGPU, conf.yres, 768), 1307 DEFINE_PROP_END_OF_LIST(), 1308 }; 1309 1310 static void virtio_gpu_class_init(ObjectClass *klass, void *data) 1311 { 1312 DeviceClass *dc = DEVICE_CLASS(klass); 1313 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 1314 1315 vdc->realize = virtio_gpu_device_realize; 1316 vdc->unrealize = virtio_gpu_device_unrealize; 1317 vdc->get_config = virtio_gpu_get_config; 1318 vdc->set_config = virtio_gpu_set_config; 1319 vdc->get_features = virtio_gpu_get_features; 1320 vdc->set_features = virtio_gpu_set_features; 1321 1322 vdc->reset = virtio_gpu_reset; 1323 1324 dc->props = virtio_gpu_properties; 1325 dc->vmsd = &vmstate_virtio_gpu; 1326 dc->hotpluggable = false; 1327 } 1328 1329 static const TypeInfo virtio_gpu_info = { 1330 .name = TYPE_VIRTIO_GPU, 1331 .parent = TYPE_VIRTIO_DEVICE, 1332 .instance_size = sizeof(VirtIOGPU), 1333 .instance_init = virtio_gpu_instance_init, 1334 .class_init = virtio_gpu_class_init, 1335 }; 1336 1337 static void virtio_register_types(void) 1338 { 1339 type_register_static(&virtio_gpu_info); 1340 } 1341 1342 type_init(virtio_register_types) 1343 1344 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctrl_hdr) != 24); 1345 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_update_cursor) != 56); 1346 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_unref) != 32); 1347 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_create_2d) != 40); 1348 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_set_scanout) != 48); 1349 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_flush) != 48); 1350 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_transfer_to_host_2d) != 56); 1351 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_mem_entry) != 16); 1352 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_attach_backing) != 32); 1353 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_detach_backing) != 32); 1354 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_display_info) != 408); 1355 1356 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_transfer_host_3d) != 72); 1357 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_create_3d) != 72); 1358 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_create) != 96); 1359 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_destroy) != 24); 1360 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_resource) != 32); 1361 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_cmd_submit) != 32); 1362 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_get_capset_info) != 32); 1363 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_capset_info) != 40); 1364 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_get_capset) != 32); 1365 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_capset) != 24); 1366