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