1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "qemu/osdep.h"
15#include <sys/ioctl.h>
16#include "standard-headers/linux/virtio_vsock.h"
17#include "qapi/error.h"
18#include "hw/virtio/virtio-bus.h"
19#include "hw/virtio/virtio-access.h"
20#include "qemu/error-report.h"
21#include "hw/qdev-properties.h"
22#include "hw/virtio/vhost-vsock.h"
23#include "qemu/iov.h"
24#include "qemu/module.h"
25#include "monitor/monitor.h"
26
27enum {
28 VHOST_VSOCK_SAVEVM_VERSION = 0,
29
30 VHOST_VSOCK_QUEUE_SIZE = 128,
31};
32
33static void vhost_vsock_get_config(VirtIODevice *vdev, uint8_t *config)
34{
35 VHostVSock *vsock = VHOST_VSOCK(vdev);
36 struct virtio_vsock_config vsockcfg = {};
37
38 virtio_stq_p(vdev, &vsockcfg.guest_cid, vsock->conf.guest_cid);
39 memcpy(config, &vsockcfg, sizeof(vsockcfg));
40}
41
42static int vhost_vsock_set_guest_cid(VHostVSock *vsock)
43{
44 const VhostOps *vhost_ops = vsock->vhost_dev.vhost_ops;
45 int ret;
46
47 if (!vhost_ops->vhost_vsock_set_guest_cid) {
48 return -ENOSYS;
49 }
50
51 ret = vhost_ops->vhost_vsock_set_guest_cid(&vsock->vhost_dev,
52 vsock->conf.guest_cid);
53 if (ret < 0) {
54 return -errno;
55 }
56 return 0;
57}
58
59static int vhost_vsock_set_running(VHostVSock *vsock, int start)
60{
61 const VhostOps *vhost_ops = vsock->vhost_dev.vhost_ops;
62 int ret;
63
64 if (!vhost_ops->vhost_vsock_set_running) {
65 return -ENOSYS;
66 }
67
68 ret = vhost_ops->vhost_vsock_set_running(&vsock->vhost_dev, start);
69 if (ret < 0) {
70 return -errno;
71 }
72 return 0;
73}
74
75static void vhost_vsock_start(VirtIODevice *vdev)
76{
77 VHostVSock *vsock = VHOST_VSOCK(vdev);
78 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
79 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
80 int ret;
81 int i;
82
83 if (!k->set_guest_notifiers) {
84 error_report("binding does not support guest notifiers");
85 return;
86 }
87
88 ret = vhost_dev_enable_notifiers(&vsock->vhost_dev, vdev);
89 if (ret < 0) {
90 error_report("Error enabling host notifiers: %d", -ret);
91 return;
92 }
93
94 ret = k->set_guest_notifiers(qbus->parent, vsock->vhost_dev.nvqs, true);
95 if (ret < 0) {
96 error_report("Error binding guest notifier: %d", -ret);
97 goto err_host_notifiers;
98 }
99
100 vsock->vhost_dev.acked_features = vdev->guest_features;
101 ret = vhost_dev_start(&vsock->vhost_dev, vdev);
102 if (ret < 0) {
103 error_report("Error starting vhost: %d", -ret);
104 goto err_guest_notifiers;
105 }
106
107 ret = vhost_vsock_set_running(vsock, 1);
108 if (ret < 0) {
109 error_report("Error starting vhost vsock: %d", -ret);
110 goto err_dev_start;
111 }
112
113
114
115
116
117 for (i = 0; i < vsock->vhost_dev.nvqs; i++) {
118 vhost_virtqueue_mask(&vsock->vhost_dev, vdev, i, false);
119 }
120
121 return;
122
123err_dev_start:
124 vhost_dev_stop(&vsock->vhost_dev, vdev);
125err_guest_notifiers:
126 k->set_guest_notifiers(qbus->parent, vsock->vhost_dev.nvqs, false);
127err_host_notifiers:
128 vhost_dev_disable_notifiers(&vsock->vhost_dev, vdev);
129}
130
131static void vhost_vsock_stop(VirtIODevice *vdev)
132{
133 VHostVSock *vsock = VHOST_VSOCK(vdev);
134 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
135 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
136 int ret;
137
138 if (!k->set_guest_notifiers) {
139 return;
140 }
141
142 ret = vhost_vsock_set_running(vsock, 0);
143 if (ret < 0) {
144 error_report("vhost vsock set running failed: %d", ret);
145 return;
146 }
147
148 vhost_dev_stop(&vsock->vhost_dev, vdev);
149
150 ret = k->set_guest_notifiers(qbus->parent, vsock->vhost_dev.nvqs, false);
151 if (ret < 0) {
152 error_report("vhost guest notifier cleanup failed: %d", ret);
153 return;
154 }
155
156 vhost_dev_disable_notifiers(&vsock->vhost_dev, vdev);
157}
158
159static void vhost_vsock_set_status(VirtIODevice *vdev, uint8_t status)
160{
161 VHostVSock *vsock = VHOST_VSOCK(vdev);
162 bool should_start = status & VIRTIO_CONFIG_S_DRIVER_OK;
163
164 if (!vdev->vm_running) {
165 should_start = false;
166 }
167
168 if (vsock->vhost_dev.started == should_start) {
169 return;
170 }
171
172 if (should_start) {
173 vhost_vsock_start(vdev);
174 } else {
175 vhost_vsock_stop(vdev);
176 }
177}
178
179static uint64_t vhost_vsock_get_features(VirtIODevice *vdev,
180 uint64_t requested_features,
181 Error **errp)
182{
183
184 return requested_features;
185}
186
187static void vhost_vsock_handle_output(VirtIODevice *vdev, VirtQueue *vq)
188{
189
190}
191
192static void vhost_vsock_guest_notifier_mask(VirtIODevice *vdev, int idx,
193 bool mask)
194{
195 VHostVSock *vsock = VHOST_VSOCK(vdev);
196
197 vhost_virtqueue_mask(&vsock->vhost_dev, vdev, idx, mask);
198}
199
200static bool vhost_vsock_guest_notifier_pending(VirtIODevice *vdev, int idx)
201{
202 VHostVSock *vsock = VHOST_VSOCK(vdev);
203
204 return vhost_virtqueue_pending(&vsock->vhost_dev, idx);
205}
206
207static void vhost_vsock_send_transport_reset(VHostVSock *vsock)
208{
209 VirtQueueElement *elem;
210 VirtQueue *vq = vsock->event_vq;
211 struct virtio_vsock_event event = {
212 .id = cpu_to_le32(VIRTIO_VSOCK_EVENT_TRANSPORT_RESET),
213 };
214
215 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
216 if (!elem) {
217 error_report("vhost-vsock missed transport reset event");
218 return;
219 }
220
221 if (elem->out_num) {
222 error_report("invalid vhost-vsock event virtqueue element with "
223 "out buffers");
224 goto out;
225 }
226
227 if (iov_from_buf(elem->in_sg, elem->in_num, 0,
228 &event, sizeof(event)) != sizeof(event)) {
229 error_report("vhost-vsock event virtqueue element is too short");
230 goto out;
231 }
232
233 virtqueue_push(vq, elem, sizeof(event));
234 virtio_notify(VIRTIO_DEVICE(vsock), vq);
235
236out:
237 g_free(elem);
238}
239
240static void vhost_vsock_post_load_timer_cleanup(VHostVSock *vsock)
241{
242 if (!vsock->post_load_timer) {
243 return;
244 }
245
246 timer_del(vsock->post_load_timer);
247 timer_free(vsock->post_load_timer);
248 vsock->post_load_timer = NULL;
249}
250
251static void vhost_vsock_post_load_timer_cb(void *opaque)
252{
253 VHostVSock *vsock = opaque;
254
255 vhost_vsock_post_load_timer_cleanup(vsock);
256 vhost_vsock_send_transport_reset(vsock);
257}
258
259static int vhost_vsock_pre_save(void *opaque)
260{
261 VHostVSock *vsock = opaque;
262
263
264
265 assert(!vsock->vhost_dev.started);
266
267 return 0;
268}
269
270static int vhost_vsock_post_load(void *opaque, int version_id)
271{
272 VHostVSock *vsock = opaque;
273 VirtIODevice *vdev = VIRTIO_DEVICE(vsock);
274
275 if (virtio_queue_get_addr(vdev, 2)) {
276
277
278
279 assert(!vsock->post_load_timer);
280 vsock->post_load_timer =
281 timer_new_ns(QEMU_CLOCK_VIRTUAL,
282 vhost_vsock_post_load_timer_cb,
283 vsock);
284 timer_mod(vsock->post_load_timer, 1);
285 }
286 return 0;
287}
288
289static const VMStateDescription vmstate_virtio_vhost_vsock = {
290 .name = "virtio-vhost_vsock",
291 .minimum_version_id = VHOST_VSOCK_SAVEVM_VERSION,
292 .version_id = VHOST_VSOCK_SAVEVM_VERSION,
293 .fields = (VMStateField[]) {
294 VMSTATE_VIRTIO_DEVICE,
295 VMSTATE_END_OF_LIST()
296 },
297 .pre_save = vhost_vsock_pre_save,
298 .post_load = vhost_vsock_post_load,
299};
300
301static void vhost_vsock_device_realize(DeviceState *dev, Error **errp)
302{
303 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
304 VHostVSock *vsock = VHOST_VSOCK(dev);
305 int vhostfd;
306 int ret;
307
308
309 if (vsock->conf.guest_cid <= 2) {
310 error_setg(errp, "guest-cid property must be greater than 2");
311 return;
312 }
313
314 if (vsock->conf.guest_cid > UINT32_MAX) {
315 error_setg(errp, "guest-cid property must be a 32-bit number");
316 return;
317 }
318
319 if (vsock->conf.vhostfd) {
320 vhostfd = monitor_fd_param(cur_mon, vsock->conf.vhostfd, errp);
321 if (vhostfd == -1) {
322 error_prepend(errp, "vhost-vsock: unable to parse vhostfd: ");
323 return;
324 }
325 } else {
326 vhostfd = open("/dev/vhost-vsock", O_RDWR);
327 if (vhostfd < 0) {
328 error_setg_errno(errp, errno,
329 "vhost-vsock: failed to open vhost device");
330 return;
331 }
332 }
333
334 virtio_init(vdev, "vhost-vsock", VIRTIO_ID_VSOCK,
335 sizeof(struct virtio_vsock_config));
336
337
338 vsock->recv_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
339 vhost_vsock_handle_output);
340 vsock->trans_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
341 vhost_vsock_handle_output);
342
343
344 vsock->event_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
345 vhost_vsock_handle_output);
346
347 vsock->vhost_dev.nvqs = ARRAY_SIZE(vsock->vhost_vqs);
348 vsock->vhost_dev.vqs = vsock->vhost_vqs;
349 ret = vhost_dev_init(&vsock->vhost_dev, (void *)(uintptr_t)vhostfd,
350 VHOST_BACKEND_TYPE_KERNEL, 0);
351 if (ret < 0) {
352 error_setg_errno(errp, -ret, "vhost-vsock: vhost_dev_init failed");
353 goto err_virtio;
354 }
355
356 ret = vhost_vsock_set_guest_cid(vsock);
357 if (ret < 0) {
358 error_setg_errno(errp, -ret, "vhost-vsock: unable to set guest cid");
359 goto err_vhost_dev;
360 }
361
362 vsock->post_load_timer = NULL;
363 return;
364
365err_vhost_dev:
366 vhost_dev_cleanup(&vsock->vhost_dev);
367
368 vhostfd = -1;
369err_virtio:
370 virtio_delete_queue(vsock->recv_vq);
371 virtio_delete_queue(vsock->trans_vq);
372 virtio_delete_queue(vsock->event_vq);
373 virtio_cleanup(vdev);
374 if (vhostfd >= 0) {
375 close(vhostfd);
376 }
377 return;
378}
379
380static void vhost_vsock_device_unrealize(DeviceState *dev, Error **errp)
381{
382 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
383 VHostVSock *vsock = VHOST_VSOCK(dev);
384
385 vhost_vsock_post_load_timer_cleanup(vsock);
386
387
388 vhost_vsock_set_status(vdev, 0);
389
390 vhost_dev_cleanup(&vsock->vhost_dev);
391 virtio_delete_queue(vsock->recv_vq);
392 virtio_delete_queue(vsock->trans_vq);
393 virtio_delete_queue(vsock->event_vq);
394 virtio_cleanup(vdev);
395}
396
397static Property vhost_vsock_properties[] = {
398 DEFINE_PROP_UINT64("guest-cid", VHostVSock, conf.guest_cid, 0),
399 DEFINE_PROP_STRING("vhostfd", VHostVSock, conf.vhostfd),
400 DEFINE_PROP_END_OF_LIST(),
401};
402
403static void vhost_vsock_class_init(ObjectClass *klass, void *data)
404{
405 DeviceClass *dc = DEVICE_CLASS(klass);
406 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
407
408 device_class_set_props(dc, vhost_vsock_properties);
409 dc->vmsd = &vmstate_virtio_vhost_vsock;
410 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
411 vdc->realize = vhost_vsock_device_realize;
412 vdc->unrealize = vhost_vsock_device_unrealize;
413 vdc->get_features = vhost_vsock_get_features;
414 vdc->get_config = vhost_vsock_get_config;
415 vdc->set_status = vhost_vsock_set_status;
416 vdc->guest_notifier_mask = vhost_vsock_guest_notifier_mask;
417 vdc->guest_notifier_pending = vhost_vsock_guest_notifier_pending;
418}
419
420static const TypeInfo vhost_vsock_info = {
421 .name = TYPE_VHOST_VSOCK,
422 .parent = TYPE_VIRTIO_DEVICE,
423 .instance_size = sizeof(VHostVSock),
424 .class_init = vhost_vsock_class_init,
425};
426
427static void vhost_vsock_register_types(void)
428{
429 type_register_static(&vhost_vsock_info);
430}
431
432type_init(vhost_vsock_register_types)
433