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/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
  27 enum {
  28     VHOST_VSOCK_SAVEVM_VERSION = 0,
  29
  30     VHOST_VSOCK_QUEUE_SIZE = 128,
  31 };
  32
  33 static 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
  42 static 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
  59 static 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
  75 static 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     /* guest_notifier_mask/pending not used yet, so just unmask
 114      * everything here.  virtio-pci will do the right thing by
 115      * enabling/disabling irqfd.
 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
 123 err_dev_start:
 124     vhost_dev_stop(&vsock->vhost_dev, vdev);
 125 err_guest_notifiers:
 126     k->set_guest_notifiers(qbus->parent, vsock->vhost_dev.nvqs, false);
 127 err_host_notifiers:
 128     vhost_dev_disable_notifiers(&vsock->vhost_dev, vdev);
 129 }
 130
 131 static 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
 159 static 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
 179 static uint64_t vhost_vsock_get_features(VirtIODevice *vdev,
 180                                          uint64_t requested_features,
 181                                          Error **errp)
 182 {
 183     /* No feature bits used yet */
 184     return requested_features;
 185 }
 186
 187 static void vhost_vsock_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 188 {
 189     /* Do nothing */
 190 }
 191
 192 static 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
 200 static 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
 207 static 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
 236 out:
 237     g_free(elem);
 238 }
 239
 240 static 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
 251 static 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
 259 static int vhost_vsock_pre_save(void *opaque)
 260 {
 261     VHostVSock *vsock = opaque;
 262
 263     /* At this point, backend must be stopped, otherwise
 264      * it might keep writing to memory. */
 265     assert(!vsock->vhost_dev.started);
 266
 267     return 0;
 268 }
 269
 270 static 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         /* Defer transport reset event to a vm clock timer so that virtqueue
 277          * changes happen after migration has completed.
 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
 289 static 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
 301 static 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     /* Refuse to use reserved CID numbers */
 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     /* Receive and transmit queues belong to vhost */
 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     /* The event queue belongs to QEMU */
 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
 365 err_vhost_dev:
 366     vhost_dev_cleanup(&vsock->vhost_dev);
 367     /* vhost_dev_cleanup() closes the vhostfd passed to vhost_dev_init() */
 368     vhostfd = -1;
 369 err_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
 380 static void vhost_vsock_device_unrealize(DeviceState *dev)
 381 {
 382     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 383     VHostVSock *vsock = VHOST_VSOCK(dev);
 384
 385     vhost_vsock_post_load_timer_cleanup(vsock);
 386
 387     /* This will stop vhost backend if appropriate. */
 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
 397 static 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
 403 static 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
 420 static 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
 427 static void vhost_vsock_register_types(void)
 428 {
 429     type_register_static(&vhost_vsock_info);
 430 }
 431
 432 type_init(vhost_vsock_register_types)