1
2
3
4
5
6
7
8
9
10
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
22typedef 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
36typedef struct VhostUserGpuDisplayInfoReply {
37 struct virtio_gpu_resp_display_info info;
38} VhostUserGpuDisplayInfoReply;
39
40typedef struct VhostUserGpuCursorPos {
41 uint32_t scanout_id;
42 uint32_t x;
43 uint32_t y;
44} QEMU_PACKED VhostUserGpuCursorPos;
45
46typedef 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
53typedef struct VhostUserGpuScanout {
54 uint32_t scanout_id;
55 uint32_t width;
56 uint32_t height;
57} QEMU_PACKED VhostUserGpuScanout;
58
59typedef 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
68typedef 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
81typedef struct VhostUserGpuMsg {
82 uint32_t request;
83 uint32_t flags;
84 uint32_t 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
96static 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
102static void vhost_user_gpu_update_blocked(VhostUserGPU *g, bool blocked);
103
104static void
105vhost_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
134static void
135vhost_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
141static void
142vhost_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
152static void
153vhost_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
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
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
306static void
307vhost_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
358end:
359 g_free(msg);
360}
361
362static void
363vhost_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
369static void
370vhost_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
382static bool
383vhost_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
412err:
413 close(sv[0]);
414 close(sv[1]);
415 if (chr) {
416 object_unref(OBJECT(chr));
417 }
418 return false;
419}
420
421static void
422vhost_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
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
445static void
446vhost_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
468static void
469vhost_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
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
491static bool
492vhost_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
499static void
500vhost_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
507static void
508vhost_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
517static void
518vhost_user_gpu_instance_finalize(Object *obj)
519{
520 VhostUserGPU *g = VHOST_USER_GPU(obj);
521
522 object_unref(OBJECT(g->vhost));
523}
524
525static void
526vhost_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
535static int
536vhost_user_gpu_config_change(struct vhost_dev *dev)
537{
538 error_report("vhost-user-gpu: unhandled backend config change");
539 return -1;
540}
541
542static const VhostDevConfigOps config_ops = {
543 .vhost_dev_config_notifier = vhost_user_gpu_config_change,
544};
545
546static void
547vhost_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
568static Property vhost_user_gpu_properties[] = {
569 VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU, parent_obj.conf),
570 DEFINE_PROP_END_OF_LIST(),
571};
572
573static void
574vhost_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
593static 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
602static void vhost_user_gpu_register_types(void)
603{
604 type_register_static(&vhost_user_gpu_info);
605}
606
607type_init(vhost_user_gpu_register_types)
608
