hw/display/vhost-user-gpu.c

   1 /*
   2  * vhost-user GPU Device
   3  *
   4  * Copyright Red Hat, Inc. 2018
   5  *
   6  * Authors:
   7  *     Marc-André Lureau <marcandre.lureau@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "hw/qdev-properties.h"
  15 #include "hw/virtio/virtio-gpu.h"
  16 #include "chardev/char-fe.h"
  17 #include "qapi/error.h"
  18 #include "migration/blocker.h"
  19
  20 #define VHOST_USER_GPU(obj)                                    \
  21     OBJECT_CHECK(VhostUserGPU, (obj), TYPE_VHOST_USER_GPU)
  22
  23 typedef enum VhostUserGpuRequest {
  24     VHOST_USER_GPU_NONE = 0,
  25     VHOST_USER_GPU_GET_PROTOCOL_FEATURES,
  26     VHOST_USER_GPU_SET_PROTOCOL_FEATURES,
  27     VHOST_USER_GPU_GET_DISPLAY_INFO,
  28     VHOST_USER_GPU_CURSOR_POS,
  29     VHOST_USER_GPU_CURSOR_POS_HIDE,
  30     VHOST_USER_GPU_CURSOR_UPDATE,
  31     VHOST_USER_GPU_SCANOUT,
  32     VHOST_USER_GPU_UPDATE,
  33     VHOST_USER_GPU_DMABUF_SCANOUT,
  34     VHOST_USER_GPU_DMABUF_UPDATE,
  35 } VhostUserGpuRequest;
  36
  37 typedef struct VhostUserGpuDisplayInfoReply {
  38     struct virtio_gpu_resp_display_info info;
  39 } VhostUserGpuDisplayInfoReply;
  40
  41 typedef struct VhostUserGpuCursorPos {
  42     uint32_t scanout_id;
  43     uint32_t x;
  44     uint32_t y;
  45 } QEMU_PACKED VhostUserGpuCursorPos;
  46
  47 typedef struct VhostUserGpuCursorUpdate {
  48     VhostUserGpuCursorPos pos;
  49     uint32_t hot_x;
  50     uint32_t hot_y;
  51     uint32_t data[64 * 64];
  52 } QEMU_PACKED VhostUserGpuCursorUpdate;
  53
  54 typedef struct VhostUserGpuScanout {
  55     uint32_t scanout_id;
  56     uint32_t width;
  57     uint32_t height;
  58 } QEMU_PACKED VhostUserGpuScanout;
  59
  60 typedef struct VhostUserGpuUpdate {
  61     uint32_t scanout_id;
  62     uint32_t x;
  63     uint32_t y;
  64     uint32_t width;
  65     uint32_t height;
  66     uint8_t data[];
  67 } QEMU_PACKED VhostUserGpuUpdate;
  68
  69 typedef struct VhostUserGpuDMABUFScanout {
  70     uint32_t scanout_id;
  71     uint32_t x;
  72     uint32_t y;
  73     uint32_t width;
  74     uint32_t height;
  75     uint32_t fd_width;
  76     uint32_t fd_height;
  77     uint32_t fd_stride;
  78     uint32_t fd_flags;
  79     int fd_drm_fourcc;
  80 } QEMU_PACKED VhostUserGpuDMABUFScanout;
  81
  82 typedef struct VhostUserGpuMsg {
  83     uint32_t request; /* VhostUserGpuRequest */
  84     uint32_t flags;
  85     uint32_t size; /* the following payload size */
  86     union {
  87         VhostUserGpuCursorPos cursor_pos;
  88         VhostUserGpuCursorUpdate cursor_update;
  89         VhostUserGpuScanout scanout;
  90         VhostUserGpuUpdate update;
  91         VhostUserGpuDMABUFScanout dmabuf_scanout;
  92         struct virtio_gpu_resp_display_info display_info;
  93         uint64_t u64;
  94     } payload;
  95 } QEMU_PACKED VhostUserGpuMsg;
  96
  97 static VhostUserGpuMsg m __attribute__ ((unused));
  98 #define VHOST_USER_GPU_HDR_SIZE \
  99     (sizeof(m.request) + sizeof(m.size) + sizeof(m.flags))
 100
 101 #define VHOST_USER_GPU_MSG_FLAG_REPLY 0x4
 102
 103 static void vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked);
 104
 105 static void
 106 vhost_user_gpu_handle_cursor(VhostUserGPU *g, VhostUserGpuMsg *msg)
 107 {
 108     VhostUserGpuCursorPos *pos = &msg->payload.cursor_pos;
 109     struct virtio_gpu_scanout *s;
 110
 111     if (pos->scanout_id >= g->parent_obj.conf.max_outputs) {
 112         return;
 113     }
 114     s = &g->parent_obj.scanout[pos->scanout_id];
 115
 116     if (msg->request == VHOST_USER_GPU_CURSOR_UPDATE) {
 117         VhostUserGpuCursorUpdate *up = &msg->payload.cursor_update;
 118         if (!s->current_cursor) {
 119             s->current_cursor = cursor_alloc(64, 64);
 120         }
 121
 122         s->current_cursor->hot_x = up->hot_x;
 123         s->current_cursor->hot_y = up->hot_y;
 124
 125         memcpy(s->current_cursor->data, up->data,
 126                64 * 64 * sizeof(uint32_t));
 127
 128         dpy_cursor_define(s->con, s->current_cursor);
 129     }
 130
 131     dpy_mouse_set(s->con, pos->x, pos->y,
 132                   msg->request != VHOST_USER_GPU_CURSOR_POS_HIDE);
 133 }
 134
 135 static void
 136 vhost_user_gpu_send_msg(VhostUserGPU *g, const VhostUserGpuMsg *msg)
 137 {
 138     qemu_chr_fe_write(&g->vhost_chr, (uint8_t *)msg,
 139                       VHOST_USER_GPU_HDR_SIZE + msg->size);
 140 }
 141
 142 static void
 143 vhost_user_gpu_unblock(VhostUserGPU *g)
 144 {
 145     VhostUserGpuMsg msg = {
 146         .request = VHOST_USER_GPU_DMABUF_UPDATE,
 147         .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
 148     };
 149
 150     vhost_user_gpu_send_msg(g, &msg);
 151 }
 152
 153 static void
 154 vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
 155 {
 156     QemuConsole *con = NULL;
 157     struct virtio_gpu_scanout *s;
 158
 159     switch (msg->request) {
 160     case VHOST_USER_GPU_GET_PROTOCOL_FEATURES: {
 161         VhostUserGpuMsg reply = {
 162             .request = msg->request,
 163             .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
 164             .size = sizeof(uint64_t),
 165         };
 166
 167         vhost_user_gpu_send_msg(g, &reply);
 168         break;
 169     }
 170     case VHOST_USER_GPU_SET_PROTOCOL_FEATURES: {
 171         break;
 172     }
 173     case VHOST_USER_GPU_GET_DISPLAY_INFO: {
 174         struct virtio_gpu_resp_display_info display_info = { {} };
 175         VhostUserGpuMsg reply = {
 176             .request = msg->request,
 177             .flags = VHOST_USER_GPU_MSG_FLAG_REPLY,
 178             .size = sizeof(struct virtio_gpu_resp_display_info),
 179         };
 180
 181         display_info.hdr.type = VIRTIO_GPU_RESP_OK_DISPLAY_INFO;
 182         virtio_gpu_base_fill_display_info(VIRTIO_GPU_BASE(g), &display_info);
 183         memcpy(&reply.payload.display_info, &display_info,
 184                sizeof(display_info));
 185         vhost_user_gpu_send_msg(g, &reply);
 186         break;
 187     }
 188     case VHOST_USER_GPU_SCANOUT: {
 189         VhostUserGpuScanout *m = &msg->payload.scanout;
 190
 191         if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
 192             return;
 193         }
 194
 195         g->parent_obj.enable = 1;
 196         s = &g->parent_obj.scanout[m->scanout_id];
 197         con = s->con;
 198
 199         if (m->scanout_id == 0 && m->width == 0) {
 200             s->ds = qemu_create_message_surface(640, 480,
 201                                                 "Guest disabled display.");
 202             dpy_gfx_replace_surface(con, s->ds);
 203         } else {
 204             s->ds = qemu_create_displaysurface(m->width, m->height);
 205             /* replace surface on next update */
 206         }
 207
 208         break;
 209     }
 210     case VHOST_USER_GPU_DMABUF_SCANOUT: {
 211         VhostUserGpuDMABUFScanout *m = &msg->payload.dmabuf_scanout;
 212         int fd = qemu_chr_fe_get_msgfd(&g->vhost_chr);
 213         QemuDmaBuf *dmabuf;
 214
 215         if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
 216             error_report("invalid scanout: %d", m->scanout_id);
 217             if (fd >= 0) {
 218                 close(fd);
 219             }
 220             break;
 221         }
 222
 223         g->parent_obj.enable = 1;
 224         con = g->parent_obj.scanout[m->scanout_id].con;
 225         dmabuf = &g->dmabuf[m->scanout_id];
 226         if (dmabuf->fd >= 0) {
 227             close(dmabuf->fd);
 228             dmabuf->fd = -1;
 229         }
 230         if (!console_has_gl_dmabuf(con)) {
 231             /* it would be nice to report that error earlier */
 232             error_report("console doesn't support dmabuf!");
 233             break;
 234         }
 235         dpy_gl_release_dmabuf(con, dmabuf);
 236         if (fd == -1) {
 237             dpy_gl_scanout_disable(con);
 238             break;
 239         }
 240         *dmabuf = (QemuDmaBuf) {
 241             .fd = fd,
 242             .width = m->fd_width,
 243             .height = m->fd_height,
 244             .stride = m->fd_stride,
 245             .fourcc = m->fd_drm_fourcc,
 246             .y0_top = m->fd_flags & VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP,
 247         };
 248         dpy_gl_scanout_dmabuf(con, dmabuf);
 249         break;
 250     }
 251     case VHOST_USER_GPU_DMABUF_UPDATE: {
 252         VhostUserGpuUpdate *m = &msg->payload.update;
 253
 254         if (m->scanout_id >= g->parent_obj.conf.max_outputs ||
 255             !g->parent_obj.scanout[m->scanout_id].con) {
 256             error_report("invalid scanout update: %d", m->scanout_id);
 257             vhost_user_gpu_unblock(g);
 258             break;
 259         }
 260
 261         con = g->parent_obj.scanout[m->scanout_id].con;
 262         if (!console_has_gl(con)) {
 263             error_report("console doesn't support GL!");
 264             vhost_user_gpu_unblock(g);
 265             break;
 266         }
 267         dpy_gl_update(con, m->x, m->y, m->width, m->height);
 268         g->backend_blocked = true;
 269         break;
 270     }
 271     case VHOST_USER_GPU_UPDATE: {
 272         VhostUserGpuUpdate *m = &msg->payload.update;
 273
 274         if (m->scanout_id >= g->parent_obj.conf.max_outputs) {
 275             break;
 276         }
 277         s = &g->parent_obj.scanout[m->scanout_id];
 278         con = s->con;
 279         pixman_image_t *image =
 280             pixman_image_create_bits(PIXMAN_x8r8g8b8,
 281                                      m->width,
 282                                      m->height,
 283                                      (uint32_t *)m->data,
 284                                      m->width * 4);
 285
 286         pixman_image_composite(PIXMAN_OP_SRC,
 287                                image, NULL, s->ds->image,
 288                                0, 0, 0, 0, m->x, m->y, m->width, m->height);
 289
 290         pixman_image_unref(image);
 291         if (qemu_console_surface(con) != s->ds) {
 292             dpy_gfx_replace_surface(con, s->ds);
 293         } else {
 294             dpy_gfx_update(con, m->x, m->y, m->width, m->height);
 295         }
 296         break;
 297     }
 298     default:
 299         g_warning("unhandled message %d %d", msg->request, msg->size);
 300     }
 301
 302     if (con && qemu_console_is_gl_blocked(con)) {
 303         vhost_user_gpu_update_blocked(g, true);
 304     }
 305 }
 306
 307 static void
 308 vhost_user_gpu_chr_read(void *opaque)
 309 {
 310     VhostUserGPU *g = opaque;
 311     VhostUserGpuMsg *msg = NULL;
 312     VhostUserGpuRequest request;
 313     uint32_t size, flags;
 314     int r;
 315
 316     r = qemu_chr_fe_read_all(&g->vhost_chr,
 317                              (uint8_t *)&request, sizeof(uint32_t));
 318     if (r != sizeof(uint32_t)) {
 319         error_report("failed to read msg header: %d, %d", r, errno);
 320         goto end;
 321     }
 322
 323     r = qemu_chr_fe_read_all(&g->vhost_chr,
 324                              (uint8_t *)&flags, sizeof(uint32_t));
 325     if (r != sizeof(uint32_t)) {
 326         error_report("failed to read msg flags");
 327         goto end;
 328     }
 329
 330     r = qemu_chr_fe_read_all(&g->vhost_chr,
 331                              (uint8_t *)&size, sizeof(uint32_t));
 332     if (r != sizeof(uint32_t)) {
 333         error_report("failed to read msg size");
 334         goto end;
 335     }
 336
 337     msg = g_malloc(VHOST_USER_GPU_HDR_SIZE + size);
 338     g_return_if_fail(msg != NULL);
 339
 340     r = qemu_chr_fe_read_all(&g->vhost_chr,
 341                              (uint8_t *)&msg->payload, size);
 342     if (r != size) {
 343         error_report("failed to read msg payload %d != %d", r, size);
 344         goto end;
 345     }
 346
 347     msg->request = request;
 348     msg->flags = size;
 349     msg->size = size;
 350
 351     if (request == VHOST_USER_GPU_CURSOR_UPDATE ||
 352         request == VHOST_USER_GPU_CURSOR_POS ||
 353         request == VHOST_USER_GPU_CURSOR_POS_HIDE) {
 354         vhost_user_gpu_handle_cursor(g, msg);
 355     } else {
 356         vhost_user_gpu_handle_display(g, msg);
 357     }
 358
 359 end:
 360     g_free(msg);
 361 }
 362
 363 static void
 364 vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked)
 365 {
 366     qemu_set_fd_handler(g->vhost_gpu_fd,
 367                         blocked ? NULL : vhost_user_gpu_chr_read, NULL, g);
 368 }
 369
 370 static void
 371 vhost_user_gpu_gl_unblock(VirtIOGPUBase *b)
 372 {
 373     VhostUserGPU *g = VHOST_USER_GPU(b);
 374
 375     if (g->backend_blocked) {
 376         vhost_user_gpu_unblock(VHOST_USER_GPU(g));
 377         g->backend_blocked = false;
 378     }
 379
 380     vhost_user_gpu_update_blocked(VHOST_USER_GPU(g), false);
 381 }
 382
 383 static bool
 384 vhost_user_gpu_do_set_socket(VhostUserGPU *g, Error **errp)
 385 {
 386     Chardev *chr;
 387     int sv[2];
 388
 389     if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
 390         error_setg_errno(errp, errno, "socketpair() failed");
 391         return false;
 392     }
 393
 394     chr = CHARDEV(object_new(TYPE_CHARDEV_SOCKET));
 395     if (!chr || qemu_chr_add_client(chr, sv[0]) == -1) {
 396         error_setg(errp, "Failed to make socket chardev");
 397         goto err;
 398     }
 399     if (!qemu_chr_fe_init(&g->vhost_chr, chr, errp)) {
 400         goto err;
 401     }
 402     if (vhost_user_gpu_set_socket(&g->vhost->dev, sv[1]) < 0) {
 403         error_setg(errp, "Failed to set vhost-user-gpu socket");
 404         qemu_chr_fe_deinit(&g->vhost_chr, false);
 405         goto err;
 406     }
 407
 408     g->vhost_gpu_fd = sv[0];
 409     vhost_user_gpu_update_blocked(g, false);
 410     close(sv[1]);
 411     return true;
 412
 413 err:
 414     close(sv[0]);
 415     close(sv[1]);
 416     if (chr) {
 417         object_unref(OBJECT(chr));
 418     }
 419     return false;
 420 }
 421
 422 static void
 423 vhost_user_gpu_get_config(VirtIODevice *vdev, uint8_t *config_data)
 424 {
 425     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 426     VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
 427     struct virtio_gpu_config *vgconfig =
 428         (struct virtio_gpu_config *)config_data;
 429     int ret;
 430
 431     memset(config_data, 0, sizeof(struct virtio_gpu_config));
 432
 433     ret = vhost_dev_get_config(&g->vhost->dev,
 434                                config_data, sizeof(struct virtio_gpu_config));
 435     if (ret) {
 436         error_report("vhost-user-gpu: get device config space failed");
 437         return;
 438     }
 439
 440     /* those fields are managed by qemu */
 441     vgconfig->num_scanouts = b->virtio_config.num_scanouts;
 442     vgconfig->events_read = b->virtio_config.events_read;
 443     vgconfig->events_clear = b->virtio_config.events_clear;
 444 }
 445
 446 static void
 447 vhost_user_gpu_set_config(VirtIODevice *vdev,
 448                           const uint8_t *config_data)
 449 {
 450     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 451     VirtIOGPUBase *b = VIRTIO_GPU_BASE(vdev);
 452     const struct virtio_gpu_config *vgconfig =
 453         (const struct virtio_gpu_config *)config_data;
 454     int ret;
 455
 456     if (vgconfig->events_clear) {
 457         b->virtio_config.events_read &= ~vgconfig->events_clear;
 458     }
 459
 460     ret = vhost_dev_set_config(&g->vhost->dev, config_data,
 461                                0, sizeof(struct virtio_gpu_config),
 462                                VHOST_SET_CONFIG_TYPE_MASTER);
 463     if (ret) {
 464         error_report("vhost-user-gpu: set device config space failed");
 465         return;
 466     }
 467 }
 468
 469 static void
 470 vhost_user_gpu_set_status(VirtIODevice *vdev, uint8_t val)
 471 {
 472     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 473     Error *err = NULL;
 474
 475     if (val & VIRTIO_CONFIG_S_DRIVER_OK && vdev->vm_running) {
 476         if (!vhost_user_gpu_do_set_socket(g, &err)) {
 477             error_report_err(err);
 478             return;
 479         }
 480         vhost_user_backend_start(g->vhost);
 481     } else {
 482         /* unblock any wait and stop processing */
 483         if (g->vhost_gpu_fd != -1) {
 484             vhost_user_gpu_update_blocked(g, true);
 485             qemu_chr_fe_deinit(&g->vhost_chr, true);
 486             g->vhost_gpu_fd = -1;
 487         }
 488         vhost_user_backend_stop(g->vhost);
 489     }
 490 }
 491
 492 static bool
 493 vhost_user_gpu_guest_notifier_pending(VirtIODevice *vdev, int idx)
 494 {
 495     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 496
 497     return vhost_virtqueue_pending(&g->vhost->dev, idx);
 498 }
 499
 500 static void
 501 vhost_user_gpu_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
 502 {
 503     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 504
 505     vhost_virtqueue_mask(&g->vhost->dev, vdev, idx, mask);
 506 }
 507
 508 static void
 509 vhost_user_gpu_instance_init(Object *obj)
 510 {
 511     VhostUserGPU *g = VHOST_USER_GPU(obj);
 512
 513     g->vhost = VHOST_USER_BACKEND(object_new(TYPE_VHOST_USER_BACKEND));
 514     object_property_add_alias(obj, "chardev",
 515                               OBJECT(g->vhost), "chardev", &error_abort);
 516 }
 517
 518 static void
 519 vhost_user_gpu_instance_finalize(Object *obj)
 520 {
 521     VhostUserGPU *g = VHOST_USER_GPU(obj);
 522
 523     object_unref(OBJECT(g->vhost));
 524 }
 525
 526 static void
 527 vhost_user_gpu_reset(VirtIODevice *vdev)
 528 {
 529     VhostUserGPU *g = VHOST_USER_GPU(vdev);
 530
 531     virtio_gpu_base_reset(VIRTIO_GPU_BASE(vdev));
 532
 533     vhost_user_backend_stop(g->vhost);
 534 }
 535
 536 static int
 537 vhost_user_gpu_config_change(struct vhost_dev *dev)
 538 {
 539     error_report("vhost-user-gpu: unhandled backend config change");
 540     return -1;
 541 }
 542
 543 static const VhostDevConfigOps config_ops = {
 544     .vhost_dev_config_notifier = vhost_user_gpu_config_change,
 545 };
 546
 547 static void
 548 vhost_user_gpu_device_realize(DeviceState *qdev, Error **errp)
 549 {
 550     VhostUserGPU *g = VHOST_USER_GPU(qdev);
 551     VirtIODevice *vdev = VIRTIO_DEVICE(g);
 552
 553     vhost_dev_set_config_notifier(&g->vhost->dev, &config_ops);
 554     if (vhost_user_backend_dev_init(g->vhost, vdev, 2, errp) < 0) {
 555         return;
 556     }
 557
 558     if (virtio_has_feature(g->vhost->dev.features, VIRTIO_GPU_F_VIRGL)) {
 559         g->parent_obj.conf.flags |= 1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED;
 560     }
 561
 562     if (!virtio_gpu_base_device_realize(qdev, NULL, NULL, errp)) {
 563         return;
 564     }
 565
 566     g->vhost_gpu_fd = -1;
 567 }
 568
 569 static Property vhost_user_gpu_properties[] = {
 570     VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU, parent_obj.conf),
 571     DEFINE_PROP_END_OF_LIST(),
 572 };
 573
 574 static void
 575 vhost_user_gpu_class_init(ObjectClass *klass, void *data)
 576 {
 577     DeviceClass *dc = DEVICE_CLASS(klass);
 578     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 579     VirtIOGPUBaseClass *vgc = VIRTIO_GPU_BASE_CLASS(klass);
 580
 581     vgc->gl_unblock = vhost_user_gpu_gl_unblock;
 582
 583     vdc->realize = vhost_user_gpu_device_realize;
 584     vdc->reset = vhost_user_gpu_reset;
 585     vdc->set_status   = vhost_user_gpu_set_status;
 586     vdc->guest_notifier_mask = vhost_user_gpu_guest_notifier_mask;
 587     vdc->guest_notifier_pending = vhost_user_gpu_guest_notifier_pending;
 588     vdc->get_config = vhost_user_gpu_get_config;
 589     vdc->set_config = vhost_user_gpu_set_config;
 590
 591     device_class_set_props(dc, vhost_user_gpu_properties);
 592 }
 593
 594 static const TypeInfo vhost_user_gpu_info = {
 595     .name = TYPE_VHOST_USER_GPU,
 596     .parent = TYPE_VIRTIO_GPU_BASE,
 597     .instance_size = sizeof(VhostUserGPU),
 598     .instance_init = vhost_user_gpu_instance_init,
 599     .instance_finalize = vhost_user_gpu_instance_finalize,
 600     .class_init = vhost_user_gpu_class_init,
 601 };
 602
 603 static void vhost_user_gpu_register_types(void)
 604 {
 605     type_register_static(&vhost_user_gpu_info);
 606 }
 607
 608 type_init(vhost_user_gpu_register_types)