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/sockets.h"
15 #include "hw/qdev-properties.h"
16 #include "hw/virtio/virtio-gpu.h"
17 #include "chardev/char-fe.h"
18 #include "qapi/error.h"
19 #include "migration/blocker.h"
21 typedef enum VhostUserGpuRequest
{
22 VHOST_USER_GPU_NONE
= 0,
23 VHOST_USER_GPU_GET_PROTOCOL_FEATURES
,
24 VHOST_USER_GPU_SET_PROTOCOL_FEATURES
,
25 VHOST_USER_GPU_GET_DISPLAY_INFO
,
26 VHOST_USER_GPU_CURSOR_POS
,
27 VHOST_USER_GPU_CURSOR_POS_HIDE
,
28 VHOST_USER_GPU_CURSOR_UPDATE
,
29 VHOST_USER_GPU_SCANOUT
,
30 VHOST_USER_GPU_UPDATE
,
31 VHOST_USER_GPU_DMABUF_SCANOUT
,
32 VHOST_USER_GPU_DMABUF_UPDATE
,
33 } VhostUserGpuRequest
;
35 typedef struct VhostUserGpuDisplayInfoReply
{
36 struct virtio_gpu_resp_display_info info
;
37 } VhostUserGpuDisplayInfoReply
;
39 typedef struct VhostUserGpuCursorPos
{
43 } QEMU_PACKED VhostUserGpuCursorPos
;
45 typedef struct VhostUserGpuCursorUpdate
{
46 VhostUserGpuCursorPos pos
;
49 uint32_t data
[64 * 64];
50 } QEMU_PACKED VhostUserGpuCursorUpdate
;
52 typedef struct VhostUserGpuScanout
{
56 } QEMU_PACKED VhostUserGpuScanout
;
58 typedef struct VhostUserGpuUpdate
{
65 } QEMU_PACKED VhostUserGpuUpdate
;
67 typedef struct VhostUserGpuDMABUFScanout
{
78 } QEMU_PACKED VhostUserGpuDMABUFScanout
;
80 typedef struct VhostUserGpuMsg
{
81 uint32_t request
; /* VhostUserGpuRequest */
83 uint32_t size
; /* the following payload size */
85 VhostUserGpuCursorPos cursor_pos
;
86 VhostUserGpuCursorUpdate cursor_update
;
87 VhostUserGpuScanout scanout
;
88 VhostUserGpuUpdate update
;
89 VhostUserGpuDMABUFScanout dmabuf_scanout
;
90 struct virtio_gpu_resp_display_info display_info
;
93 } QEMU_PACKED VhostUserGpuMsg
;
95 static VhostUserGpuMsg m
__attribute__ ((unused
));
96 #define VHOST_USER_GPU_HDR_SIZE \
97 (sizeof(m.request) + sizeof(m.size) + sizeof(m.flags))
99 #define VHOST_USER_GPU_MSG_FLAG_REPLY 0x4
101 static void vhost_user_gpu_update_blocked(VhostUserGPU
*g
, bool blocked
);
104 vhost_user_gpu_handle_cursor(VhostUserGPU
*g
, VhostUserGpuMsg
*msg
)
106 VhostUserGpuCursorPos
*pos
= &msg
->payload
.cursor_pos
;
107 struct virtio_gpu_scanout
*s
;
109 if (pos
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
112 s
= &g
->parent_obj
.scanout
[pos
->scanout_id
];
114 if (msg
->request
== VHOST_USER_GPU_CURSOR_UPDATE
) {
115 VhostUserGpuCursorUpdate
*up
= &msg
->payload
.cursor_update
;
116 if (!s
->current_cursor
) {
117 s
->current_cursor
= cursor_alloc(64, 64);
120 s
->current_cursor
->hot_x
= up
->hot_x
;
121 s
->current_cursor
->hot_y
= up
->hot_y
;
123 memcpy(s
->current_cursor
->data
, up
->data
,
124 64 * 64 * sizeof(uint32_t));
126 dpy_cursor_define(s
->con
, s
->current_cursor
);
129 dpy_mouse_set(s
->con
, pos
->x
, pos
->y
,
130 msg
->request
!= VHOST_USER_GPU_CURSOR_POS_HIDE
);
134 vhost_user_gpu_send_msg(VhostUserGPU
*g
, const VhostUserGpuMsg
*msg
)
136 qemu_chr_fe_write(&g
->vhost_chr
, (uint8_t *)msg
,
137 VHOST_USER_GPU_HDR_SIZE
+ msg
->size
);
141 vhost_user_gpu_unblock(VhostUserGPU
*g
)
143 VhostUserGpuMsg msg
= {
144 .request
= VHOST_USER_GPU_DMABUF_UPDATE
,
145 .flags
= VHOST_USER_GPU_MSG_FLAG_REPLY
,
148 vhost_user_gpu_send_msg(g
, &msg
);
152 vhost_user_gpu_handle_display(VhostUserGPU
*g
, VhostUserGpuMsg
*msg
)
154 QemuConsole
*con
= NULL
;
155 struct virtio_gpu_scanout
*s
;
157 switch (msg
->request
) {
158 case VHOST_USER_GPU_GET_PROTOCOL_FEATURES
: {
159 VhostUserGpuMsg reply
= {
160 .request
= msg
->request
,
161 .flags
= VHOST_USER_GPU_MSG_FLAG_REPLY
,
162 .size
= sizeof(uint64_t),
165 vhost_user_gpu_send_msg(g
, &reply
);
168 case VHOST_USER_GPU_SET_PROTOCOL_FEATURES
: {
171 case VHOST_USER_GPU_GET_DISPLAY_INFO
: {
172 struct virtio_gpu_resp_display_info display_info
= { {} };
173 VhostUserGpuMsg reply
= {
174 .request
= msg
->request
,
175 .flags
= VHOST_USER_GPU_MSG_FLAG_REPLY
,
176 .size
= sizeof(struct virtio_gpu_resp_display_info
),
179 display_info
.hdr
.type
= VIRTIO_GPU_RESP_OK_DISPLAY_INFO
;
180 virtio_gpu_base_fill_display_info(VIRTIO_GPU_BASE(g
), &display_info
);
181 memcpy(&reply
.payload
.display_info
, &display_info
,
182 sizeof(display_info
));
183 vhost_user_gpu_send_msg(g
, &reply
);
186 case VHOST_USER_GPU_SCANOUT
: {
187 VhostUserGpuScanout
*m
= &msg
->payload
.scanout
;
189 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
193 g
->parent_obj
.enable
= 1;
194 s
= &g
->parent_obj
.scanout
[m
->scanout_id
];
198 dpy_gfx_replace_surface(con
, NULL
);
200 s
->ds
= qemu_create_displaysurface(m
->width
, m
->height
);
201 /* replace surface on next update */
206 case VHOST_USER_GPU_DMABUF_SCANOUT
: {
207 VhostUserGpuDMABUFScanout
*m
= &msg
->payload
.dmabuf_scanout
;
208 int fd
= qemu_chr_fe_get_msgfd(&g
->vhost_chr
);
211 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
212 error_report("invalid scanout: %d", m
->scanout_id
);
219 g
->parent_obj
.enable
= 1;
220 con
= g
->parent_obj
.scanout
[m
->scanout_id
].con
;
221 dmabuf
= &g
->dmabuf
[m
->scanout_id
];
222 if (dmabuf
->fd
>= 0) {
226 dpy_gl_release_dmabuf(con
, dmabuf
);
228 dpy_gl_scanout_disable(con
);
231 *dmabuf
= (QemuDmaBuf
) {
233 .width
= m
->fd_width
,
234 .height
= m
->fd_height
,
235 .stride
= m
->fd_stride
,
236 .fourcc
= m
->fd_drm_fourcc
,
237 .y0_top
= m
->fd_flags
& VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP
,
239 dpy_gl_scanout_dmabuf(con
, dmabuf
);
242 case VHOST_USER_GPU_DMABUF_UPDATE
: {
243 VhostUserGpuUpdate
*m
= &msg
->payload
.update
;
245 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
||
246 !g
->parent_obj
.scanout
[m
->scanout_id
].con
) {
247 error_report("invalid scanout update: %d", m
->scanout_id
);
248 vhost_user_gpu_unblock(g
);
252 con
= g
->parent_obj
.scanout
[m
->scanout_id
].con
;
253 if (!console_has_gl(con
)) {
254 error_report("console doesn't support GL!");
255 vhost_user_gpu_unblock(g
);
258 g
->backend_blocked
= true;
259 dpy_gl_update(con
, m
->x
, m
->y
, m
->width
, m
->height
);
262 case VHOST_USER_GPU_UPDATE
: {
263 VhostUserGpuUpdate
*m
= &msg
->payload
.update
;
265 if (m
->scanout_id
>= g
->parent_obj
.conf
.max_outputs
) {
268 s
= &g
->parent_obj
.scanout
[m
->scanout_id
];
270 pixman_image_t
*image
=
271 pixman_image_create_bits(PIXMAN_x8r8g8b8
,
277 pixman_image_composite(PIXMAN_OP_SRC
,
278 image
, NULL
, s
->ds
->image
,
279 0, 0, 0, 0, m
->x
, m
->y
, m
->width
, m
->height
);
281 pixman_image_unref(image
);
282 if (qemu_console_surface(con
) != s
->ds
) {
283 dpy_gfx_replace_surface(con
, s
->ds
);
285 dpy_gfx_update(con
, m
->x
, m
->y
, m
->width
, m
->height
);
290 g_warning("unhandled message %d %d", msg
->request
, msg
->size
);
293 if (con
&& qemu_console_is_gl_blocked(con
)) {
294 vhost_user_gpu_update_blocked(g
, true);
299 vhost_user_gpu_chr_read(void *opaque
)
301 VhostUserGPU
*g
= opaque
;
302 VhostUserGpuMsg
*msg
= NULL
;
303 VhostUserGpuRequest request
;
304 uint32_t size
, flags
;
307 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
308 (uint8_t *)&request
, sizeof(uint32_t));
309 if (r
!= sizeof(uint32_t)) {
310 error_report("failed to read msg header: %d, %d", r
, errno
);
314 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
315 (uint8_t *)&flags
, sizeof(uint32_t));
316 if (r
!= sizeof(uint32_t)) {
317 error_report("failed to read msg flags");
321 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
322 (uint8_t *)&size
, sizeof(uint32_t));
323 if (r
!= sizeof(uint32_t)) {
324 error_report("failed to read msg size");
328 msg
= g_malloc(VHOST_USER_GPU_HDR_SIZE
+ size
);
330 r
= qemu_chr_fe_read_all(&g
->vhost_chr
,
331 (uint8_t *)&msg
->payload
, size
);
333 error_report("failed to read msg payload %d != %d", r
, size
);
337 msg
->request
= request
;
341 if (request
== VHOST_USER_GPU_CURSOR_UPDATE
||
342 request
== VHOST_USER_GPU_CURSOR_POS
||
343 request
== VHOST_USER_GPU_CURSOR_POS_HIDE
) {
344 vhost_user_gpu_handle_cursor(g
, msg
);
346 vhost_user_gpu_handle_display(g
, msg
);
354 vhost_user_gpu_update_blocked(VhostUserGPU
*g
, bool blocked
)
356 qemu_set_fd_handler(g
->vhost_gpu_fd
,
357 blocked
? NULL
: vhost_user_gpu_chr_read
, NULL
, g
);
361 vhost_user_gpu_gl_flushed(VirtIOGPUBase
*b
)
363 VhostUserGPU
*g
= VHOST_USER_GPU(b
);
365 if (g
->backend_blocked
) {
366 vhost_user_gpu_unblock(VHOST_USER_GPU(g
));
367 g
->backend_blocked
= false;
370 vhost_user_gpu_update_blocked(VHOST_USER_GPU(g
), false);
374 vhost_user_gpu_do_set_socket(VhostUserGPU
*g
, Error
**errp
)
379 if (qemu_socketpair(PF_UNIX
, SOCK_STREAM
, 0, sv
) == -1) {
380 error_setg_errno(errp
, errno
, "socketpair() failed");
384 chr
= CHARDEV(object_new(TYPE_CHARDEV_SOCKET
));
385 if (!chr
|| qemu_chr_add_client(chr
, sv
[0]) == -1) {
386 error_setg(errp
, "Failed to make socket chardev");
389 if (!qemu_chr_fe_init(&g
->vhost_chr
, chr
, errp
)) {
392 if (vhost_user_gpu_set_socket(&g
->vhost
->dev
, sv
[1]) < 0) {
393 error_setg(errp
, "Failed to set vhost-user-gpu socket");
394 qemu_chr_fe_deinit(&g
->vhost_chr
, false);
398 g
->vhost_gpu_fd
= sv
[0];
399 vhost_user_gpu_update_blocked(g
, false);
407 object_unref(OBJECT(chr
));
413 vhost_user_gpu_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
415 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
416 VirtIOGPUBase
*b
= VIRTIO_GPU_BASE(vdev
);
417 struct virtio_gpu_config
*vgconfig
=
418 (struct virtio_gpu_config
*)config_data
;
419 Error
*local_err
= NULL
;
422 memset(config_data
, 0, sizeof(struct virtio_gpu_config
));
424 ret
= vhost_dev_get_config(&g
->vhost
->dev
,
425 config_data
, sizeof(struct virtio_gpu_config
),
428 error_report_err(local_err
);
432 /* those fields are managed by qemu */
433 vgconfig
->num_scanouts
= b
->virtio_config
.num_scanouts
;
434 vgconfig
->events_read
= b
->virtio_config
.events_read
;
435 vgconfig
->events_clear
= b
->virtio_config
.events_clear
;
439 vhost_user_gpu_set_config(VirtIODevice
*vdev
,
440 const uint8_t *config_data
)
442 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
443 VirtIOGPUBase
*b
= VIRTIO_GPU_BASE(vdev
);
444 const struct virtio_gpu_config
*vgconfig
=
445 (const struct virtio_gpu_config
*)config_data
;
448 if (vgconfig
->events_clear
) {
449 b
->virtio_config
.events_read
&= ~vgconfig
->events_clear
;
452 ret
= vhost_dev_set_config(&g
->vhost
->dev
, config_data
,
453 0, sizeof(struct virtio_gpu_config
),
454 VHOST_SET_CONFIG_TYPE_MASTER
);
456 error_report("vhost-user-gpu: set device config space failed");
462 vhost_user_gpu_set_status(VirtIODevice
*vdev
, uint8_t val
)
464 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
467 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
&& vdev
->vm_running
) {
468 if (!vhost_user_gpu_do_set_socket(g
, &err
)) {
469 error_report_err(err
);
472 vhost_user_backend_start(g
->vhost
);
474 /* unblock any wait and stop processing */
475 if (g
->vhost_gpu_fd
!= -1) {
476 vhost_user_gpu_update_blocked(g
, true);
477 qemu_chr_fe_deinit(&g
->vhost_chr
, true);
478 g
->vhost_gpu_fd
= -1;
480 vhost_user_backend_stop(g
->vhost
);
485 vhost_user_gpu_guest_notifier_pending(VirtIODevice
*vdev
, int idx
)
487 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
490 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
491 * as the Marco of configure interrupt's IDX, If this driver does not
492 * support, the function will return
495 if (idx
== VIRTIO_CONFIG_IRQ_IDX
) {
498 return vhost_virtqueue_pending(&g
->vhost
->dev
, idx
);
502 vhost_user_gpu_guest_notifier_mask(VirtIODevice
*vdev
, int idx
, bool mask
)
504 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
507 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
508 * as the Marco of configure interrupt's IDX, If this driver does not
509 * support, the function will return
512 if (idx
== VIRTIO_CONFIG_IRQ_IDX
) {
515 vhost_virtqueue_mask(&g
->vhost
->dev
, vdev
, idx
, mask
);
519 vhost_user_gpu_instance_init(Object
*obj
)
521 VhostUserGPU
*g
= VHOST_USER_GPU(obj
);
523 g
->vhost
= VHOST_USER_BACKEND(object_new(TYPE_VHOST_USER_BACKEND
));
524 object_property_add_alias(obj
, "chardev",
525 OBJECT(g
->vhost
), "chardev");
529 vhost_user_gpu_instance_finalize(Object
*obj
)
531 VhostUserGPU
*g
= VHOST_USER_GPU(obj
);
533 object_unref(OBJECT(g
->vhost
));
537 vhost_user_gpu_reset(VirtIODevice
*vdev
)
539 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
541 virtio_gpu_base_reset(VIRTIO_GPU_BASE(vdev
));
543 vhost_user_backend_stop(g
->vhost
);
547 vhost_user_gpu_config_change(struct vhost_dev
*dev
)
549 error_report("vhost-user-gpu: unhandled backend config change");
553 static const VhostDevConfigOps config_ops
= {
554 .vhost_dev_config_notifier
= vhost_user_gpu_config_change
,
558 vhost_user_gpu_device_realize(DeviceState
*qdev
, Error
**errp
)
560 VhostUserGPU
*g
= VHOST_USER_GPU(qdev
);
561 VirtIODevice
*vdev
= VIRTIO_DEVICE(g
);
563 vhost_dev_set_config_notifier(&g
->vhost
->dev
, &config_ops
);
564 if (vhost_user_backend_dev_init(g
->vhost
, vdev
, 2, errp
) < 0) {
568 /* existing backend may send DMABUF, so let's add that requirement */
569 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_DMABUF_ENABLED
;
570 if (virtio_has_feature(g
->vhost
->dev
.features
, VIRTIO_GPU_F_VIRGL
)) {
571 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED
;
573 if (virtio_has_feature(g
->vhost
->dev
.features
, VIRTIO_GPU_F_EDID
)) {
574 g
->parent_obj
.conf
.flags
|= 1 << VIRTIO_GPU_FLAG_EDID_ENABLED
;
576 error_report("EDID requested but the backend doesn't support it.");
577 g
->parent_obj
.conf
.flags
&= ~(1 << VIRTIO_GPU_FLAG_EDID_ENABLED
);
580 if (!virtio_gpu_base_device_realize(qdev
, NULL
, NULL
, errp
)) {
584 g
->vhost_gpu_fd
= -1;
587 static struct vhost_dev
*vhost_user_gpu_get_vhost(VirtIODevice
*vdev
)
589 VhostUserGPU
*g
= VHOST_USER_GPU(vdev
);
590 return &g
->vhost
->dev
;
593 static Property vhost_user_gpu_properties
[] = {
594 VIRTIO_GPU_BASE_PROPERTIES(VhostUserGPU
, parent_obj
.conf
),
595 DEFINE_PROP_END_OF_LIST(),
599 vhost_user_gpu_class_init(ObjectClass
*klass
, void *data
)
601 DeviceClass
*dc
= DEVICE_CLASS(klass
);
602 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
603 VirtIOGPUBaseClass
*vgc
= VIRTIO_GPU_BASE_CLASS(klass
);
605 vgc
->gl_flushed
= vhost_user_gpu_gl_flushed
;
607 vdc
->realize
= vhost_user_gpu_device_realize
;
608 vdc
->reset
= vhost_user_gpu_reset
;
609 vdc
->set_status
= vhost_user_gpu_set_status
;
610 vdc
->guest_notifier_mask
= vhost_user_gpu_guest_notifier_mask
;
611 vdc
->guest_notifier_pending
= vhost_user_gpu_guest_notifier_pending
;
612 vdc
->get_config
= vhost_user_gpu_get_config
;
613 vdc
->set_config
= vhost_user_gpu_set_config
;
614 vdc
->get_vhost
= vhost_user_gpu_get_vhost
;
616 device_class_set_props(dc
, vhost_user_gpu_properties
);
619 static const TypeInfo vhost_user_gpu_info
= {
620 .name
= TYPE_VHOST_USER_GPU
,
621 .parent
= TYPE_VIRTIO_GPU_BASE
,
622 .instance_size
= sizeof(VhostUserGPU
),
623 .instance_init
= vhost_user_gpu_instance_init
,
624 .instance_finalize
= vhost_user_gpu_instance_finalize
,
625 .class_init
= vhost_user_gpu_class_init
,
627 module_obj(TYPE_VHOST_USER_GPU
);
628 module_kconfig(VHOST_USER_GPU
);
630 static void vhost_user_gpu_register_types(void)
632 type_register_static(&vhost_user_gpu_info
);
635 type_init(vhost_user_gpu_register_types
)