hw/virtio/vhost-vsock.c

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