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 "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/virtio/vhost-vsock.h"
  22 #include "qemu/iov.h"
  23 #include "qemu/module.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 int 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     return 0;
 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)