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