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