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