2 * vhost-user GPU Device
4 * Copyright Red Hat, Inc. 2018
7 * Marc-André Lureau <marcandre.lureau@redhat.com>
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.
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"
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
;
38 typedef struct VhostUserGpuDisplayInfoReply
{
39 struct virtio_gpu_resp_display_info info
;
40 } VhostUserGpuDisplayInfoReply
;
42 typedef struct VhostUserGpuCursorPos
{
46 } QEMU_PACKED VhostUserGpuCursorPos
;
48 typedef struct VhostUserGpuCursorUpdate
{
49 VhostUserGpuCursorPos pos
;
52 uint32_t data
[64 * 64];
53 } QEMU_PACKED VhostUserGpuCursorUpdate
;
55 typedef struct VhostUserGpuScanout
{
59 } QEMU_PACKED VhostUserGpuScanout
;
61 typedef struct VhostUserGpuUpdate
{
68 } QEMU_PACKED VhostUserGpuUpdate
;
70 typedef struct VhostUserGpuDMABUFScanout
{
81 } QEMU_PACKED VhostUserGpuDMABUFScanout
;
83 typedef struct VhostUserGpuDMABUFScanout2
{
84 struct VhostUserGpuDMABUFScanout dmabuf_scanout
;
86 } QEMU_PACKED VhostUserGpuDMABUFScanout2
;
88 typedef struct VhostUserGpuEdidRequest
{
90 } QEMU_PACKED VhostUserGpuEdidRequest
;
92 typedef struct VhostUserGpuMsg
{
93 uint32_t request
; /* VhostUserGpuRequest */
95 uint32_t size
; /* the following payload size */
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
;
108 } QEMU_PACKED VhostUserGpuMsg
;
110 static VhostUserGpuMsg m
__attribute__ ((unused
));
111 #define VHOST_USER_GPU_HDR_SIZE \
112 (sizeof(m.request) + sizeof(m.size) + sizeof(m.flags))
114 #define VHOST_USER_GPU_MSG_FLAG_REPLY 0x4
116 #define VHOST_USER_GPU_PROTOCOL_F_EDID 0
117 #define VHOST_USER_GPU_PROTOCOL_F_DMABUF2 1
119 static void vhost_user_gpu_update_blocked(VhostUserGPU
*g
, bool blocked
);
122 vhost_user_gpu_handle_cursor(VhostUserGPU
*g
, VhostUserGpuMsg
*msg
)
124 VhostUserGpuCursorPos
*pos
= &msg
->payload
.cursor_pos
;
125 struct virtio_gpu_scanout
*s
;
127 if (pos
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
130 s
= &g
->parent_obj
.scanout
[pos
->scanout_id
];
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);
138 s
->current_cursor
->hot_x
= up
->hot_x
;
139 s
->current_cursor
->hot_y
= up
->hot_y
;
141 memcpy(s
->current_cursor
->data
, up
->data
,
142 64 * 64 * sizeof(uint32_t));
144 dpy_cursor_define(s
->con
, s
->current_cursor
);
147 dpy_mouse_set(s
->con
, pos
->x
, pos
->y
,
148 msg
->request
!= VHOST_USER_GPU_CURSOR_POS_HIDE
);
152 vhost_user_gpu_send_msg(VhostUserGPU
*g
, const VhostUserGpuMsg
*msg
)
154 qemu_chr_fe_write(&g
->vhost_chr
, (uint8_t *)msg
,
155 VHOST_USER_GPU_HDR_SIZE
+ msg
->size
);
159 vhost_user_gpu_unblock(VhostUserGPU
*g
)
161 VhostUserGpuMsg msg
= {
162 .request
= VHOST_USER_GPU_DMABUF_UPDATE
,
163 .flags
= VHOST_USER_GPU_MSG_FLAG_REPLY
,
166 vhost_user_gpu_send_msg(g
, &msg
);
170 vhost_user_gpu_handle_display(VhostUserGPU
*g
, VhostUserGpuMsg
*msg
)
172 QemuConsole
*con
= NULL
;
173 struct virtio_gpu_scanout
*s
;
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),
182 .u64
= (1 << VHOST_USER_GPU_PROTOCOL_F_EDID
) |
183 (1 << VHOST_USER_GPU_PROTOCOL_F_DMABUF2
)
187 vhost_user_gpu_send_msg(g
, &reply
);
190 case VHOST_USER_GPU_SET_PROTOCOL_FEATURES
: {
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
),
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
);
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
),
217 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
218 error_report("invalid scanout: %d", m
->scanout_id
);
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
);
228 case VHOST_USER_GPU_SCANOUT
: {
229 VhostUserGpuScanout
*m
= &msg
->payload
.scanout
;
231 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
235 g
->parent_obj
.enable
= 1;
236 s
= &g
->parent_obj
.scanout
[m
->scanout_id
];
240 dpy_gfx_replace_surface(con
, NULL
);
242 s
->ds
= qemu_create_displaysurface(m
->width
, m
->height
);
243 /* replace surface on next update */
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
);
254 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
255 error_report("invalid scanout: %d", m
->scanout_id
);
262 g
->parent_obj
.enable
= 1;
263 con
= g
->parent_obj
.scanout
[m
->scanout_id
].con
;
264 dmabuf
= &g
->dmabuf
[m
->scanout_id
];
265 if (dmabuf
->fd
>= 0) {
269 dpy_gl_release_dmabuf(con
, dmabuf
);
271 dpy_gl_scanout_disable(con
);
274 *dmabuf
= (QemuDmaBuf
) {
276 .width
= m
->fd_width
,
277 .height
= m
->fd_height
,
278 .stride
= m
->fd_stride
,
279 .fourcc
= m
->fd_drm_fourcc
,
280 .y0_top
= m
->fd_flags
& VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP
,
282 if (msg
->request
== VHOST_USER_GPU_DMABUF_SCANOUT2
) {
283 VhostUserGpuDMABUFScanout2
*m2
= &msg
->payload
.dmabuf_scanout2
;
284 dmabuf
->modifier
= m2
->modifier
;
287 dpy_gl_scanout_dmabuf(con
, dmabuf
);
290 case VHOST_USER_GPU_DMABUF_UPDATE
: {
291 VhostUserGpuUpdate
*m
= &msg
->payload
.update
;
293 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
||
294 !g
->parent_obj
.scanout
[m
->scanout_id
].con
) {
295 error_report("invalid scanout update: %d", m
->scanout_id
);
296 vhost_user_gpu_unblock(g
);
300 con
= g
->parent_obj
.scanout
[m
->scanout_id
].con
;
301 if (!console_has_gl(con
)) {
302 error_report("console doesn't support GL!");
303 vhost_user_gpu_unblock(g
);
306 g
->backend_blocked
= true;
307 dpy_gl_update(con
, m
->x
, m
->y
, m
->width
, m
->height
);
311 case VHOST_USER_GPU_UPDATE
: {
312 VhostUserGpuUpdate
*m
= &msg
->payload
.update
;
314 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
317 s
= &g
->parent_obj
.scanout
[m
->scanout_id
];
319 pixman_image_t
*image
=
320 pixman_image_create_bits(PIXMAN_x8r8g8b8
,
326 pixman_image_composite(PIXMAN_OP_SRC
,
327 image
, NULL
, s
->ds
->image
,
328 0, 0, 0, 0, m
->x
, m
->y
, m
->width
, m
->height
);
330 pixman_image_unref(image
);
331 if (qemu_console_surface(con
) != s
->ds
) {
332 dpy_gfx_replace_surface(con
, s
->ds
);
334 dpy_gfx_update(con
, m
->x
, m
->y
, m
->width
, m
->height
);
340 g_warning("unhandled message %d %d", msg
->request
, msg
->size
);
343 if (con
&& qemu_console_is_gl_blocked(con
)) {
344 vhost_user_gpu_update_blocked(g
, true);
349 vhost_user_gpu_chr_read(void *opaque
)
351 VhostUserGPU
*g
= opaque
;
352 VhostUserGpuMsg
*msg
= NULL
;
353 VhostUserGpuRequest request
;
354 uint32_t size
, flags
;
357 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
358 (uint8_t *)&request
, sizeof(uint32_t));
359 if (r
!= sizeof(uint32_t)) {
360 error_report("failed to read msg header: %d, %d", r
, errno
);
364 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
365 (uint8_t *)&flags
, sizeof(uint32_t));
366 if (r
!= sizeof(uint32_t)) {
367 error_report("failed to read msg flags");
371 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
372 (uint8_t *)&size
, sizeof(uint32_t));
373 if (r
!= sizeof(uint32_t)) {
374 error_report("failed to read msg size");
378 msg
= g_malloc(VHOST_USER_GPU_HDR_SIZE
+ size
);
380 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
381 (uint8_t *)&msg
->payload
, size
);
383 error_report("failed to read msg payload %d != %d", r
, size
);
387 msg
->request
= request
;
391 if (request
== VHOST_USER_GPU_CURSOR_UPDATE
||
392 request
== VHOST_USER_GPU_CURSOR_POS
||
393 request
== VHOST_USER_GPU_CURSOR_POS_HIDE
) {
394 vhost_user_gpu_handle_cursor(g
, msg
);
396 vhost_user_gpu_handle_display(g
, msg
);
404 vhost_user_gpu_update_blocked(VhostUserGPU
*g
, bool blocked
)
406 qemu_set_fd_handler(g
->vhost_gpu_fd
,
407 blocked
? NULL
: vhost_user_gpu_chr_read
, NULL
, g
);
411 vhost_user_gpu_gl_flushed(VirtIOGPUBase
*b
)
413 VhostUserGPU
*g
= VHOST_USER_GPU(b
);
415 if (g
->backend_blocked
) {
416 vhost_user_gpu_unblock(g
);
417 g
->backend_blocked
= false;
420 vhost_user_gpu_update_blocked(g
, false);
424 vhost_user_gpu_do_set_socket(VhostUserGPU
*g
, Error
**errp
)
429 if (qemu_socketpair(PF_UNIX
, SOCK_STREAM
, 0, sv
) == -1) {
430 error_setg_errno(errp
, errno
, "socketpair() failed");
434 chr
= CHARDEV(object_new(TYPE_CHARDEV_SOCKET
));
435 if (!chr
|| qemu_chr_add_client(chr
, sv
[0]) == -1) {
436 error_setg(errp
, "Failed to make socket chardev");
439 if (!qemu_chr_fe_init(&g
->vhost_chr
, chr
, errp
)) {
442 if (vhost_user_gpu_set_socket(&g
->vhost
->dev
, sv
[1]) < 0) {
443 error_setg(errp
, "Failed to set vhost-user-gpu socket");
444 qemu_chr_fe_deinit(&g
->vhost_chr
, false);
448 g
->vhost_gpu_fd
= sv
[0];
449 vhost_user_gpu_update_blocked(g
, false);
457 object_unref(OBJECT(chr
));
463 vhost_user_gpu_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
465 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
466 VirtIOGPUBase
*b
= VIRTIO_GPU_BASE(vdev
);
467 struct virtio_gpu_config
*vgconfig
=
468 (struct virtio_gpu_config
*)config_data
;
469 Error
*local_err
= NULL
;
472 memset(config_data
, 0, sizeof(struct virtio_gpu_config
));
474 ret
= vhost_dev_get_config(&g
->vhost
->dev
,
475 config_data
, sizeof(struct virtio_gpu_config
),
478 error_report_err(local_err
);
482 /* those fields are managed by qemu */
483 vgconfig
->num_scanouts
= b
->virtio_config
.num_scanouts
;
484 vgconfig
->events_read
= b
->virtio_config
.events_read
;
485 vgconfig
->events_clear
= b
->virtio_config
.events_clear
;
489 vhost_user_gpu_set_config(VirtIODevice
*vdev
,
490 const uint8_t *config_data
)
492 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
493 VirtIOGPUBase
*b
= VIRTIO_GPU_BASE(vdev
);
494 const struct virtio_gpu_config
*vgconfig
=
495 (const struct virtio_gpu_config
*)config_data
;
498 if (vgconfig
->events_clear
) {
499 b
->virtio_config
.events_read
&= ~vgconfig
->events_clear
;
502 ret
= vhost_dev_set_config(&g
->vhost
->dev
, config_data
,
503 0, sizeof(struct virtio_gpu_config
),
504 VHOST_SET_CONFIG_TYPE_FRONTEND
);
506 error_report("vhost-user-gpu: set device config space failed");
512 vhost_user_gpu_set_status(VirtIODevice
*vdev
, uint8_t val
)
514 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
517 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
&& vdev
->vm_running
) {
518 if (!vhost_user_gpu_do_set_socket(g
, &err
)) {
519 error_report_err(err
);
522 vhost_user_backend_start(g
->vhost
);
524 /* unblock any wait and stop processing */
525 if (g
->vhost_gpu_fd
!= -1) {
526 vhost_user_gpu_update_blocked(g
, true);
527 qemu_chr_fe_deinit(&g
->vhost_chr
, true);
528 g
->vhost_gpu_fd
= -1;
530 vhost_user_backend_stop(g
->vhost
);
535 vhost_user_gpu_guest_notifier_pending(VirtIODevice
*vdev
, int idx
)
537 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
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
545 if (idx
== VIRTIO_CONFIG_IRQ_IDX
) {
548 return vhost_virtqueue_pending(&g
->vhost
->dev
, idx
);
552 vhost_user_gpu_guest_notifier_mask(VirtIODevice
*vdev
, int idx
, bool mask
)
554 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
557 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
558 * as the macro of configure interrupt's IDX, If this driver does not
559 * support, the function will return
562 if (idx
== VIRTIO_CONFIG_IRQ_IDX
) {
565 vhost_virtqueue_mask(&g
->vhost
->dev
, vdev
, idx
, mask
);
569 vhost_user_gpu_instance_init(Object
*obj
)
571 VhostUserGPU
*g
= VHOST_USER_GPU(obj
);
573 g
->vhost
= VHOST_USER_BACKEND(object_new(TYPE_VHOST_USER_BACKEND
));
574 object_property_add_alias(obj
, "chardev",
575 OBJECT(g
->vhost
), "chardev");
579 vhost_user_gpu_instance_finalize(Object
*obj
)
581 VhostUserGPU
*g
= VHOST_USER_GPU(obj
);
583 object_unref(OBJECT(g
->vhost
));
587 vhost_user_gpu_reset(VirtIODevice
*vdev
)
589 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
591 virtio_gpu_base_reset(VIRTIO_GPU_BASE(vdev
));
593 vhost_user_backend_stop(g
->vhost
);
597 vhost_user_gpu_config_change(struct vhost_dev
*dev
)
599 error_report("vhost-user-gpu: unhandled backend config change");
603 static const VhostDevConfigOps config_ops
= {
604 .vhost_dev_config_notifier
= vhost_user_gpu_config_change
,
608 vhost_user_gpu_device_realize(DeviceState
*qdev
, Error
**errp
)
610 VhostUserGPU
*g
= VHOST_USER_GPU(qdev
);
611 VirtIODevice
*vdev
= VIRTIO_DEVICE(g
);
613 vhost_dev_set_config_notifier(&g
->vhost
->dev
, &config_ops
);
614 if (vhost_user_backend_dev_init(g
->vhost
, vdev
, 2, errp
) < 0) {
618 /* existing backend may send DMABUF, so let's add that requirement */
619 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_DMABUF_ENABLED
;
620 if (virtio_has_feature(g
->vhost
->dev
.features
, VIRTIO_GPU_F_VIRGL
)) {
621 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED
;
623 if (virtio_has_feature(g
->vhost
->dev
.features
, VIRTIO_GPU_F_EDID
)) {
624 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_EDID_ENABLED
;
626 error_report("EDID requested but the backend doesn't support it.");
627 g
->parent_obj
.conf
.flags
&= ~(1 << VIRTIO_GPU_FLAG_EDID_ENABLED
);
630 if (!virtio_gpu_base_device_realize(qdev
, NULL
, NULL
, errp
)) {
634 g
->vhost_gpu_fd
= -1;
637 static struct vhost_dev
*vhost_user_gpu_get_vhost(VirtIODevice
*vdev
)
639 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
640 return &g
->vhost
->dev
;
643 static Property vhost_user_gpu_properties
[] = {
644 VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU
, parent_obj
.conf
),
645 DEFINE_PROP_END_OF_LIST(),
649 vhost_user_gpu_class_init(ObjectClass
*klass
, void *data
)
651 DeviceClass
*dc
= DEVICE_CLASS(klass
);
652 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
653 VirtIOGPUBaseClass
*vgc
= VIRTIO_GPU_BASE_CLASS(klass
);
655 vgc
->gl_flushed
= vhost_user_gpu_gl_flushed
;
657 vdc
->realize
= vhost_user_gpu_device_realize
;
658 vdc
->reset
= vhost_user_gpu_reset
;
659 vdc
->set_status
= vhost_user_gpu_set_status
;
660 vdc
->guest_notifier_mask
= vhost_user_gpu_guest_notifier_mask
;
661 vdc
->guest_notifier_pending
= vhost_user_gpu_guest_notifier_pending
;
662 vdc
->get_config
= vhost_user_gpu_get_config
;
663 vdc
->set_config
= vhost_user_gpu_set_config
;
664 vdc
->get_vhost
= vhost_user_gpu_get_vhost
;
666 device_class_set_props(dc
, vhost_user_gpu_properties
);
669 static const TypeInfo vhost_user_gpu_info
= {
670 .name
= TYPE_VHOST_USER_GPU
,
671 .parent
= TYPE_VIRTIO_GPU_BASE
,
672 .instance_size
= sizeof(VhostUserGPU
),
673 .instance_init
= vhost_user_gpu_instance_init
,
674 .instance_finalize
= vhost_user_gpu_instance_finalize
,
675 .class_init
= vhost_user_gpu_class_init
,
677 module_obj(TYPE_VHOST_USER_GPU
);
678 module_kconfig(VHOST_USER_GPU
);
680 static void vhost_user_gpu_register_types(void)
682 type_register_static(&vhost_user_gpu_info
);
685 type_init(vhost_user_gpu_register_types
)