jcs.org
qemu with hax to log dma reads & writes
jcs.org/2018/11/12/vfio
hw/display: add vhost-user-vga & gpu-pci
Add new virtio-gpu devices with a "vhost-user" property. The
associated vhost-user backend is used to handle the virtio rings and
provide rendering results thanks to the vhost-user-gpu protocol.
Example usage:
-object vhost-user-backend,id=vug,cmd="./vhost-user-gpu"
-device vhost-user-vga,vhost-user=vug
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-id: 20190524130946.31736-10-marcandre.lureau@redhat.com
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
authored by
Marc-André Lureau
and committed by
Gerd Hoffmann
267f6646
c68082c4
+779
-23
+10
hw/display/Kconfig
+10
hw/display/Kconfig
···
111
111
depends on VIRTIO_PCI
112
112
select VGA
113
113
114
+
config VHOST_USER_GPU
115
+
bool
116
+
default y
117
+
depends on VIRTIO_GPU && VHOST_USER
118
+
119
+
config VHOST_USER_VGA
120
+
bool
121
+
default y
122
+
depends on VIRTIO_VGA && VHOST_USER_GPU
123
+
114
124
config DPCD
115
125
bool
116
126
select AUX
+3
hw/display/Makefile.objs
+3
hw/display/Makefile.objs
···
44
44
common-obj-$(CONFIG_QXL) += qxl.o qxl-logger.o qxl-render.o
45
45
46
46
obj-$(CONFIG_VIRTIO_GPU) += virtio-gpu-base.o virtio-gpu.o virtio-gpu-3d.o
47
+
obj-$(CONFIG_VHOST_USER_GPU) += vhost-user-gpu.o
47
48
obj-$(call land,$(CONFIG_VIRTIO_GPU),$(CONFIG_VIRTIO_PCI)) += virtio-gpu-pci.o
49
+
obj-$(call land,$(CONFIG_VHOST_USER_GPU),$(CONFIG_VIRTIO_PCI)) += vhost-user-gpu-pci.o
48
50
obj-$(CONFIG_VIRTIO_VGA) += virtio-vga.o
51
+
obj-$(CONFIG_VHOST_USER_VGA) += vhost-user-vga.o
49
52
virtio-gpu.o-cflags := $(VIRGL_CFLAGS)
50
53
virtio-gpu.o-libs += $(VIRGL_LIBS)
51
54
virtio-gpu-3d.o-cflags := $(VIRGL_CFLAGS)
+51
hw/display/vhost-user-gpu-pci.c
+51
hw/display/vhost-user-gpu-pci.c
···
1
+
/*
2
+
* vhost-user GPU PCI device
3
+
*
4
+
* Copyright Red Hat, Inc. 2018
5
+
*
6
+
* This work is licensed under the terms of the GNU GPL, version 2 or later.
7
+
* See the COPYING file in the top-level directory.
8
+
*
9
+
*/
10
+
11
+
#include "qemu/osdep.h"
12
+
#include "qapi/error.h"
13
+
#include "hw/virtio/virtio-gpu-pci.h"
14
+
15
+
#define TYPE_VHOST_USER_GPU_PCI "vhost-user-gpu-pci"
16
+
#define VHOST_USER_GPU_PCI(obj) \
17
+
OBJECT_CHECK(VhostUserGPUPCI, (obj), TYPE_VHOST_USER_GPU_PCI)
18
+
19
+
typedef struct VhostUserGPUPCI {
20
+
VirtIOGPUPCIBase parent_obj;
21
+
22
+
VhostUserGPU vdev;
23
+
} VhostUserGPUPCI;
24
+
25
+
static void vhost_user_gpu_pci_initfn(Object *obj)
26
+
{
27
+
VhostUserGPUPCI *dev = VHOST_USER_GPU_PCI(obj);
28
+
29
+
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
30
+
TYPE_VHOST_USER_GPU);
31
+
32
+
VIRTIO_GPU_PCI_BASE(obj)->vgpu = VIRTIO_GPU_BASE(&dev->vdev);
33
+
34
+
object_property_add_alias(obj, "chardev",
35
+
OBJECT(&dev->vdev), "chardev",
36
+
&error_abort);
37
+
}
38
+
39
+
static const VirtioPCIDeviceTypeInfo vhost_user_gpu_pci_info = {
40
+
.generic_name = TYPE_VHOST_USER_GPU_PCI,
41
+
.parent = TYPE_VIRTIO_GPU_PCI_BASE,
42
+
.instance_size = sizeof(VhostUserGPUPCI),
43
+
.instance_init = vhost_user_gpu_pci_initfn,
44
+
};
45
+
46
+
static void vhost_user_gpu_pci_register_types(void)
47
+
{
48
+
virtio_pci_types_register(&vhost_user_gpu_pci_info);
49
+
}
50
+
51
+
type_init(vhost_user_gpu_pci_register_types)
+607
hw/display/vhost-user-gpu.c
+607
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 "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)
+52
hw/display/vhost-user-vga.c
+52
hw/display/vhost-user-vga.c
···
1
+
/*
2
+
* vhost-user VGA device
3
+
*
4
+
* Copyright Red Hat, Inc. 2018
5
+
*
6
+
* This work is licensed under the terms of the GNU GPL, version 2 or later.
7
+
* See the COPYING file in the top-level directory.
8
+
*
9
+
*/
10
+
11
+
#include "qemu/osdep.h"
12
+
#include "qapi/error.h"
13
+
#include "virtio-vga.h"
14
+
15
+
#define TYPE_VHOST_USER_VGA "vhost-user-vga"
16
+
17
+
#define VHOST_USER_VGA(obj) \
18
+
OBJECT_CHECK(VhostUserVGA, (obj), TYPE_VHOST_USER_VGA)
19
+
20
+
typedef struct VhostUserVGA {
21
+
VirtIOVGABase parent_obj;
22
+
23
+
VhostUserGPU vdev;
24
+
} VhostUserVGA;
25
+
26
+
static void vhost_user_vga_inst_initfn(Object *obj)
27
+
{
28
+
VhostUserVGA *dev = VHOST_USER_VGA(obj);
29
+
30
+
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
31
+
TYPE_VHOST_USER_GPU);
32
+
33
+
VIRTIO_VGA_BASE(dev)->vgpu = VIRTIO_GPU_BASE(&dev->vdev);
34
+
35
+
object_property_add_alias(obj, "chardev",
36
+
OBJECT(&dev->vdev), "chardev",
37
+
&error_abort);
38
+
}
39
+
40
+
static const VirtioPCIDeviceTypeInfo vhost_user_vga_info = {
41
+
.generic_name = TYPE_VHOST_USER_VGA,
42
+
.parent = TYPE_VIRTIO_VGA_BASE,
43
+
.instance_size = sizeof(struct VhostUserVGA),
44
+
.instance_init = vhost_user_vga_inst_initfn,
45
+
};
46
+
47
+
static void vhost_user_vga_register_types(void)
48
+
{
49
+
virtio_pci_types_register(&vhost_user_vga_info);
50
+
}
51
+
52
+
type_init(vhost_user_vga_register_types)
+1
-16
hw/display/virtio-gpu-pci.c
+1
-16
hw/display/virtio-gpu-pci.c
···
16
16
#include "hw/pci/pci.h"
17
17
#include "hw/virtio/virtio.h"
18
18
#include "hw/virtio/virtio-bus.h"
19
-
#include "hw/virtio/virtio-pci.h"
20
-
#include "hw/virtio/virtio-gpu.h"
21
-
22
-
typedef struct VirtIOGPUPCIBase VirtIOGPUPCIBase;
23
-
24
-
/*
25
-
* virtio-gpu-pci-base: This extends VirtioPCIProxy.
26
-
*/
27
-
#define TYPE_VIRTIO_GPU_PCI_BASE "virtio-gpu-pci-base"
28
-
#define VIRTIO_GPU_PCI_BASE(obj) \
29
-
OBJECT_CHECK(VirtIOGPUPCIBase, (obj), TYPE_VIRTIO_GPU_PCI_BASE)
30
-
31
-
struct VirtIOGPUPCIBase {
32
-
VirtIOPCIProxy parent_obj;
33
-
VirtIOGPUBase *vgpu;
34
-
};
19
+
#include "hw/virtio/virtio-gpu-pci.h"
35
20
36
21
static Property virtio_gpu_pci_base_properties[] = {
37
22
DEFINE_VIRTIO_GPU_PCI_PROPERTIES(VirtIOPCIProxy),
+1
-1
hw/display/virtio-vga.h
+1
-1
hw/display/virtio-vga.h
+40
include/hw/virtio/virtio-gpu-pci.h
+40
include/hw/virtio/virtio-gpu-pci.h
···
1
+
/*
2
+
* Virtio GPU PCI Device
3
+
*
4
+
* Copyright Red Hat, Inc. 2013-2014
5
+
*
6
+
* Authors:
7
+
* Dave Airlie <airlied@redhat.com>
8
+
* Gerd Hoffmann <kraxel@redhat.com>
9
+
*
10
+
* This work is licensed under the terms of the GNU GPL, version 2.
11
+
* See the COPYING file in the top-level directory.
12
+
*/
13
+
14
+
#ifndef HW_VIRTIO_GPU_PCI_H
15
+
#define HW_VIRTIO_GPU_PCI_H
16
+
17
+
#include "hw/virtio/virtio-pci.h"
18
+
#include "hw/virtio/virtio-gpu.h"
19
+
20
+
typedef struct VirtIOGPUPCIBase VirtIOGPUPCIBase;
21
+
22
+
/*
23
+
* virtio-gpu-pci-base: This extends VirtioPCIProxy.
24
+
*/
25
+
#define TYPE_VIRTIO_GPU_PCI_BASE "virtio-gpu-pci-base"
26
+
#define VIRTIO_GPU_PCI_BASE(obj) \
27
+
OBJECT_CHECK(VirtIOGPUPCIBase, (obj), TYPE_VIRTIO_GPU_PCI_BASE)
28
+
29
+
struct VirtIOGPUPCIBase {
30
+
VirtIOPCIProxy parent_obj;
31
+
VirtIOGPUBase *vgpu;
32
+
};
33
+
34
+
/* to share between PCI and VGA */
35
+
#define DEFINE_VIRTIO_GPU_PCI_PROPERTIES(_state) \
36
+
DEFINE_PROP_BIT("ioeventfd", _state, flags, \
37
+
VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false), \
38
+
DEFINE_PROP_UINT32("vectors", _state, nvectors, 3)
39
+
40
+
#endif /* HW_VIRTIO_GPU_PCI_H */
+13
-6
include/hw/virtio/virtio-gpu.h
+13
-6
include/hw/virtio/virtio-gpu.h
···
19
19
#include "ui/console.h"
20
20
#include "hw/virtio/virtio.h"
21
21
#include "qemu/log.h"
22
+
#include "sysemu/vhost-user-backend.h"
22
23
23
24
#include "standard-headers/linux/virtio_gpu.h"
24
25
···
33
34
#define TYPE_VIRTIO_GPU "virtio-gpu-device"
34
35
#define VIRTIO_GPU(obj) \
35
36
OBJECT_CHECK(VirtIOGPU, (obj), TYPE_VIRTIO_GPU)
37
+
38
+
#define TYPE_VHOST_USER_GPU "vhost-user-gpu"
36
39
37
40
#define VIRTIO_ID_GPU 16
38
41
···
157
160
} stats;
158
161
} VirtIOGPU;
159
162
160
-
extern const GraphicHwOps virtio_gpu_ops;
163
+
typedef struct VhostUserGPU {
164
+
VirtIOGPUBase parent_obj;
161
165
162
-
/* to share between PCI and VGA */
163
-
#define DEFINE_VIRTIO_GPU_PCI_PROPERTIES(_state) \
164
-
DEFINE_PROP_BIT("ioeventfd", _state, flags, \
165
-
VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false), \
166
-
DEFINE_PROP_UINT32("vectors", _state, nvectors, 3)
166
+
VhostUserBackend *vhost;
167
+
int vhost_gpu_fd; /* closed by the chardev */
168
+
CharBackend vhost_chr;
169
+
QemuDmaBuf dmabuf[VIRTIO_GPU_MAX_SCANOUTS];
170
+
bool backend_blocked;
171
+
} VhostUserGPU;
172
+
173
+
extern const GraphicHwOps virtio_gpu_ops;
167
174
168
175
#define VIRTIO_GPU_FILL_CMD(out) do { \
169
176
size_t s; \
+1
vl.c
+1
vl.c