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