hw/block/vhost-user-blk.c

   1 /*
   2  * vhost-user-blk host device
   3  *
   4  * Copyright(C) 2017 Intel Corporation.
   5  *
   6  * Authors:
   7  *  Changpeng Liu <changpeng.liu@intel.com>
   8  *
   9  * Largely based on the "vhost-user-scsi.c" and "vhost-scsi.c" implemented by:
  10  * Felipe Franciosi <felipe@nutanix.com>
  11  * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
  12  * Nicholas Bellinger <nab@risingtidesystems.com>
  13  *
  14  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  15  * See the COPYING.LIB file in the top-level directory.
  16  *
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include "qapi/error.h"
  21 #include "qemu/error-report.h"
  22 #include "qemu/cutils.h"
  23 #include "hw/qdev-core.h"
  24 #include "hw/qdev-properties.h"
  25 #include "hw/qdev-properties-system.h"
  26 #include "hw/virtio/virtio-blk-common.h"
  27 #include "hw/virtio/vhost.h"
  28 #include "hw/virtio/vhost-user-blk.h"
  29 #include "hw/virtio/virtio.h"
  30 #include "hw/virtio/virtio-bus.h"
  31 #include "hw/virtio/virtio-access.h"
  32 #include "sysemu/sysemu.h"
  33 #include "sysemu/runstate.h"
  34
  35 static const int user_feature_bits[] = {
  36     VIRTIO_BLK_F_SIZE_MAX,
  37     VIRTIO_BLK_F_SEG_MAX,
  38     VIRTIO_BLK_F_GEOMETRY,
  39     VIRTIO_BLK_F_BLK_SIZE,
  40     VIRTIO_BLK_F_TOPOLOGY,
  41     VIRTIO_BLK_F_MQ,
  42     VIRTIO_BLK_F_RO,
  43     VIRTIO_BLK_F_FLUSH,
  44     VIRTIO_BLK_F_CONFIG_WCE,
  45     VIRTIO_BLK_F_DISCARD,
  46     VIRTIO_BLK_F_WRITE_ZEROES,
  47     VIRTIO_F_VERSION_1,
  48     VIRTIO_RING_F_INDIRECT_DESC,
  49     VIRTIO_RING_F_EVENT_IDX,
  50     VIRTIO_F_NOTIFY_ON_EMPTY,
  51     VIRTIO_F_RING_PACKED,
  52     VIRTIO_F_IOMMU_PLATFORM,
  53     VIRTIO_F_RING_RESET,
  54     VHOST_INVALID_FEATURE_BIT
  55 };
  56
  57 static void vhost_user_blk_event(void *opaque, QEMUChrEvent event);
  58
  59 static void vhost_user_blk_update_config(VirtIODevice *vdev, uint8_t *config)
  60 {
  61     VHostUserBlk *s = VHOST_USER_BLK(vdev);
  62
  63     /* Our num_queues overrides the device backend */
  64     virtio_stw_p(vdev, &s->blkcfg.num_queues, s->num_queues);
  65
  66     memcpy(config, &s->blkcfg, vdev->config_len);
  67 }
  68
  69 static void vhost_user_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
  70 {
  71     VHostUserBlk *s = VHOST_USER_BLK(vdev);
  72     struct virtio_blk_config *blkcfg = (struct virtio_blk_config *)config;
  73     int ret;
  74
  75     if (blkcfg->wce == s->blkcfg.wce) {
  76         return;
  77     }
  78
  79     ret = vhost_dev_set_config(&s->dev, &blkcfg->wce,
  80                                offsetof(struct virtio_blk_config, wce),
  81                                sizeof(blkcfg->wce),
  82                                VHOST_SET_CONFIG_TYPE_FRONTEND);
  83     if (ret) {
  84         error_report("set device config space failed");
  85         return;
  86     }
  87
  88     s->blkcfg.wce = blkcfg->wce;
  89 }
  90
  91 static int vhost_user_blk_handle_config_change(struct vhost_dev *dev)
  92 {
  93     int ret;
  94     VirtIODevice *vdev = dev->vdev;
  95     VHostUserBlk *s = VHOST_USER_BLK(dev->vdev);
  96     Error *local_err = NULL;
  97
  98     if (!dev->started) {
  99         return 0;
 100     }
 101
 102     ret = vhost_dev_get_config(dev, (uint8_t *)&s->blkcfg,
 103                                vdev->config_len, &local_err);
 104     if (ret < 0) {
 105         error_report_err(local_err);
 106         return ret;
 107     }
 108
 109     memcpy(dev->vdev->config, &s->blkcfg, vdev->config_len);
 110     virtio_notify_config(dev->vdev);
 111
 112     return 0;
 113 }
 114
 115 const VhostDevConfigOps blk_ops = {
 116     .vhost_dev_config_notifier = vhost_user_blk_handle_config_change,
 117 };
 118
 119 static int vhost_user_blk_start(VirtIODevice *vdev, Error **errp)
 120 {
 121     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 122     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
 123     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 124     int i, ret;
 125
 126     if (!k->set_guest_notifiers) {
 127         error_setg(errp, "binding does not support guest notifiers");
 128         return -ENOSYS;
 129     }
 130
 131     ret = vhost_dev_enable_notifiers(&s->dev, vdev);
 132     if (ret < 0) {
 133         error_setg_errno(errp, -ret, "Error enabling host notifiers");
 134         return ret;
 135     }
 136
 137     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);
 138     if (ret < 0) {
 139         error_setg_errno(errp, -ret, "Error binding guest notifier");
 140         goto err_host_notifiers;
 141     }
 142
 143     s->dev.acked_features = vdev->guest_features;
 144
 145     ret = vhost_dev_prepare_inflight(&s->dev, vdev);
 146     if (ret < 0) {
 147         error_setg_errno(errp, -ret, "Error setting inflight format");
 148         goto err_guest_notifiers;
 149     }
 150
 151     if (!s->inflight->addr) {
 152         ret = vhost_dev_get_inflight(&s->dev, s->queue_size, s->inflight);
 153         if (ret < 0) {
 154             error_setg_errno(errp, -ret, "Error getting inflight");
 155             goto err_guest_notifiers;
 156         }
 157     }
 158
 159     ret = vhost_dev_set_inflight(&s->dev, s->inflight);
 160     if (ret < 0) {
 161         error_setg_errno(errp, -ret, "Error setting inflight");
 162         goto err_guest_notifiers;
 163     }
 164
 165     /* guest_notifier_mask/pending not used yet, so just unmask
 166      * everything here. virtio-pci will do the right thing by
 167      * enabling/disabling irqfd.
 168      */
 169     for (i = 0; i < s->dev.nvqs; i++) {
 170         vhost_virtqueue_mask(&s->dev, vdev, i, false);
 171     }
 172
 173     s->dev.vq_index_end = s->dev.nvqs;
 174     ret = vhost_dev_start(&s->dev, vdev, true);
 175     if (ret < 0) {
 176         error_setg_errno(errp, -ret, "Error starting vhost");
 177         goto err_guest_notifiers;
 178     }
 179     s->started_vu = true;
 180
 181     return ret;
 182
 183 err_guest_notifiers:
 184     for (i = 0; i < s->dev.nvqs; i++) {
 185         vhost_virtqueue_mask(&s->dev, vdev, i, true);
 186     }
 187     k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
 188 err_host_notifiers:
 189     vhost_dev_disable_notifiers(&s->dev, vdev);
 190     return ret;
 191 }
 192
 193 static void vhost_user_blk_stop(VirtIODevice *vdev)
 194 {
 195     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 196     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
 197     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 198     int ret;
 199
 200     if (!s->started_vu) {
 201         return;
 202     }
 203     s->started_vu = false;
 204
 205     if (!k->set_guest_notifiers) {
 206         return;
 207     }
 208
 209     vhost_dev_stop(&s->dev, vdev, true);
 210
 211     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
 212     if (ret < 0) {
 213         error_report("vhost guest notifier cleanup failed: %d", ret);
 214         return;
 215     }
 216
 217     vhost_dev_disable_notifiers(&s->dev, vdev);
 218 }
 219
 220 static void vhost_user_blk_set_status(VirtIODevice *vdev, uint8_t status)
 221 {
 222     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 223     bool should_start = virtio_device_should_start(vdev, status);
 224     Error *local_err = NULL;
 225     int ret;
 226
 227     if (!s->connected) {
 228         return;
 229     }
 230
 231     if (vhost_dev_is_started(&s->dev) == should_start) {
 232         return;
 233     }
 234
 235     if (should_start) {
 236         ret = vhost_user_blk_start(vdev, &local_err);
 237         if (ret < 0) {
 238             error_reportf_err(local_err, "vhost-user-blk: vhost start failed: ");
 239             qemu_chr_fe_disconnect(&s->chardev);
 240         }
 241     } else {
 242         vhost_user_blk_stop(vdev);
 243     }
 244
 245 }
 246
 247 static uint64_t vhost_user_blk_get_features(VirtIODevice *vdev,
 248                                             uint64_t features,
 249                                             Error **errp)
 250 {
 251     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 252
 253     /* Turn on pre-defined features */
 254     virtio_add_feature(&features, VIRTIO_BLK_F_SIZE_MAX);
 255     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
 256     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
 257     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
 258     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
 259     virtio_add_feature(&features, VIRTIO_BLK_F_FLUSH);
 260     virtio_add_feature(&features, VIRTIO_BLK_F_RO);
 261
 262     if (s->num_queues > 1) {
 263         virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
 264     }
 265
 266     return vhost_get_features(&s->dev, user_feature_bits, features);
 267 }
 268
 269 static void vhost_user_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 270 {
 271     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 272     Error *local_err = NULL;
 273     int i, ret;
 274
 275     if (!vdev->start_on_kick) {
 276         return;
 277     }
 278
 279     if (!s->connected) {
 280         return;
 281     }
 282
 283     if (vhost_dev_is_started(&s->dev)) {
 284         return;
 285     }
 286
 287     /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
 288      * vhost here instead of waiting for .set_status().
 289      */
 290     ret = vhost_user_blk_start(vdev, &local_err);
 291     if (ret < 0) {
 292         error_reportf_err(local_err, "vhost-user-blk: vhost start failed: ");
 293         qemu_chr_fe_disconnect(&s->chardev);
 294         return;
 295     }
 296
 297     /* Kick right away to begin processing requests already in vring */
 298     for (i = 0; i < s->dev.nvqs; i++) {
 299         VirtQueue *kick_vq = virtio_get_queue(vdev, i);
 300
 301         if (!virtio_queue_get_desc_addr(vdev, i)) {
 302             continue;
 303         }
 304         event_notifier_set(virtio_queue_get_host_notifier(kick_vq));
 305     }
 306 }
 307
 308 static void vhost_user_blk_reset(VirtIODevice *vdev)
 309 {
 310     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 311
 312     vhost_dev_free_inflight(s->inflight);
 313 }
 314
 315 static int vhost_user_blk_connect(DeviceState *dev, Error **errp)
 316 {
 317     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 318     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 319     int ret = 0;
 320
 321     if (s->connected) {
 322         return 0;
 323     }
 324
 325     s->dev.num_queues = s->num_queues;
 326     s->dev.nvqs = s->num_queues;
 327     s->dev.vqs = s->vhost_vqs;
 328     s->dev.vq_index = 0;
 329     s->dev.backend_features = 0;
 330
 331     vhost_dev_set_config_notifier(&s->dev, &blk_ops);
 332
 333     s->vhost_user.supports_config = true;
 334     ret = vhost_dev_init(&s->dev, &s->vhost_user, VHOST_BACKEND_TYPE_USER, 0,
 335                          errp);
 336     if (ret < 0) {
 337         return ret;
 338     }
 339
 340     s->connected = true;
 341
 342     /* restore vhost state */
 343     if (virtio_device_started(vdev, vdev->status)) {
 344         ret = vhost_user_blk_start(vdev, errp);
 345     }
 346
 347     return ret;
 348 }
 349
 350 static void vhost_user_blk_disconnect(DeviceState *dev)
 351 {
 352     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 353     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 354
 355     if (!s->connected) {
 356         return;
 357     }
 358     s->connected = false;
 359
 360     vhost_user_blk_stop(vdev);
 361
 362     vhost_dev_cleanup(&s->dev);
 363
 364     /* Re-instate the event handler for new connections */
 365     qemu_chr_fe_set_handlers(&s->chardev, NULL, NULL, vhost_user_blk_event,
 366                              NULL, dev, NULL, true);
 367 }
 368
 369 static void vhost_user_blk_event(void *opaque, QEMUChrEvent event)
 370 {
 371     DeviceState *dev = opaque;
 372     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 373     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 374     Error *local_err = NULL;
 375
 376     switch (event) {
 377     case CHR_EVENT_OPENED:
 378         if (vhost_user_blk_connect(dev, &local_err) < 0) {
 379             error_report_err(local_err);
 380             qemu_chr_fe_disconnect(&s->chardev);
 381             return;
 382         }
 383         break;
 384     case CHR_EVENT_CLOSED:
 385         /* defer close until later to avoid circular close */
 386         vhost_user_async_close(dev, &s->chardev, &s->dev,
 387                                vhost_user_blk_disconnect, vhost_user_blk_event);
 388         break;
 389     case CHR_EVENT_BREAK:
 390     case CHR_EVENT_MUX_IN:
 391     case CHR_EVENT_MUX_OUT:
 392         /* Ignore */
 393         break;
 394     }
 395 }
 396
 397 static int vhost_user_blk_realize_connect(VHostUserBlk *s, Error **errp)
 398 {
 399     DeviceState *dev = DEVICE(s);
 400     int ret;
 401
 402     s->connected = false;
 403
 404     ret = qemu_chr_fe_wait_connected(&s->chardev, errp);
 405     if (ret < 0) {
 406         return ret;
 407     }
 408
 409     ret = vhost_user_blk_connect(dev, errp);
 410     if (ret < 0) {
 411         qemu_chr_fe_disconnect(&s->chardev);
 412         return ret;
 413     }
 414     assert(s->connected);
 415
 416     ret = vhost_dev_get_config(&s->dev, (uint8_t *)&s->blkcfg,
 417                                VIRTIO_DEVICE(s)->config_len, errp);
 418     if (ret < 0) {
 419         qemu_chr_fe_disconnect(&s->chardev);
 420         vhost_dev_cleanup(&s->dev);
 421         return ret;
 422     }
 423
 424     return 0;
 425 }
 426
 427 static void vhost_user_blk_device_realize(DeviceState *dev, Error **errp)
 428 {
 429     ERRP_GUARD();
 430     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 431     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 432     size_t config_size;
 433     int retries;
 434     int i, ret;
 435
 436     if (!s->chardev.chr) {
 437         error_setg(errp, "chardev is mandatory");
 438         return;
 439     }
 440
 441     if (s->num_queues == VHOST_USER_BLK_AUTO_NUM_QUEUES) {
 442         s->num_queues = 1;
 443     }
 444     if (!s->num_queues || s->num_queues > VIRTIO_QUEUE_MAX) {
 445         error_setg(errp, "invalid number of IO queues");
 446         return;
 447     }
 448
 449     if (!s->queue_size) {
 450         error_setg(errp, "queue size must be non-zero");
 451         return;
 452     }
 453     if (s->queue_size > VIRTQUEUE_MAX_SIZE) {
 454         error_setg(errp, "queue size must not exceed %d",
 455                    VIRTQUEUE_MAX_SIZE);
 456         return;
 457     }
 458
 459     if (!vhost_user_init(&s->vhost_user, &s->chardev, errp)) {
 460         return;
 461     }
 462
 463     config_size = virtio_get_config_size(&virtio_blk_cfg_size_params,
 464                                          vdev->host_features);
 465     virtio_init(vdev, VIRTIO_ID_BLOCK, config_size);
 466
 467     s->virtqs = g_new(VirtQueue *, s->num_queues);
 468     for (i = 0; i < s->num_queues; i++) {
 469         s->virtqs[i] = virtio_add_queue(vdev, s->queue_size,
 470                                         vhost_user_blk_handle_output);
 471     }
 472
 473     s->inflight = g_new0(struct vhost_inflight, 1);
 474     s->vhost_vqs = g_new0(struct vhost_virtqueue, s->num_queues);
 475
 476     retries = VU_REALIZE_CONN_RETRIES;
 477     assert(!*errp);
 478     do {
 479         if (*errp) {
 480             error_prepend(errp, "Reconnecting after error: ");
 481             error_report_err(*errp);
 482             *errp = NULL;
 483         }
 484         ret = vhost_user_blk_realize_connect(s, errp);
 485     } while (ret < 0 && retries--);
 486
 487     if (ret < 0) {
 488         goto virtio_err;
 489     }
 490
 491     /* we're fully initialized, now we can operate, so add the handler */
 492     qemu_chr_fe_set_handlers(&s->chardev,  NULL, NULL,
 493                              vhost_user_blk_event, NULL, (void *)dev,
 494                              NULL, true);
 495     return;
 496
 497 virtio_err:
 498     g_free(s->vhost_vqs);
 499     s->vhost_vqs = NULL;
 500     g_free(s->inflight);
 501     s->inflight = NULL;
 502     for (i = 0; i < s->num_queues; i++) {
 503         virtio_delete_queue(s->virtqs[i]);
 504     }
 505     g_free(s->virtqs);
 506     virtio_cleanup(vdev);
 507     vhost_user_cleanup(&s->vhost_user);
 508 }
 509
 510 static void vhost_user_blk_device_unrealize(DeviceState *dev)
 511 {
 512     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 513     VHostUserBlk *s = VHOST_USER_BLK(dev);
 514     int i;
 515
 516     virtio_set_status(vdev, 0);
 517     qemu_chr_fe_set_handlers(&s->chardev,  NULL, NULL, NULL,
 518                              NULL, NULL, NULL, false);
 519     vhost_dev_cleanup(&s->dev);
 520     vhost_dev_free_inflight(s->inflight);
 521     g_free(s->vhost_vqs);
 522     s->vhost_vqs = NULL;
 523     g_free(s->inflight);
 524     s->inflight = NULL;
 525
 526     for (i = 0; i < s->num_queues; i++) {
 527         virtio_delete_queue(s->virtqs[i]);
 528     }
 529     g_free(s->virtqs);
 530     virtio_cleanup(vdev);
 531     vhost_user_cleanup(&s->vhost_user);
 532 }
 533
 534 static void vhost_user_blk_instance_init(Object *obj)
 535 {
 536     VHostUserBlk *s = VHOST_USER_BLK(obj);
 537
 538     device_add_bootindex_property(obj, &s->bootindex, "bootindex",
 539                                   "/disk@0,0", DEVICE(obj));
 540 }
 541
 542 static struct vhost_dev *vhost_user_blk_get_vhost(VirtIODevice *vdev)
 543 {
 544     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 545     return &s->dev;
 546 }
 547
 548 static const VMStateDescription vmstate_vhost_user_blk = {
 549     .name = "vhost-user-blk",
 550     .minimum_version_id = 1,
 551     .version_id = 1,
 552     .fields = (const VMStateField[]) {
 553         VMSTATE_VIRTIO_DEVICE,
 554         VMSTATE_END_OF_LIST()
 555     },
 556 };
 557
 558 static Property vhost_user_blk_properties[] = {
 559     DEFINE_PROP_CHR("chardev", VHostUserBlk, chardev),
 560     DEFINE_PROP_UINT16("num-queues", VHostUserBlk, num_queues,
 561                        VHOST_USER_BLK_AUTO_NUM_QUEUES),
 562     DEFINE_PROP_UINT32("queue-size", VHostUserBlk, queue_size, 128),
 563     DEFINE_PROP_BIT64("config-wce", VHostUserBlk, parent_obj.host_features,
 564                       VIRTIO_BLK_F_CONFIG_WCE, true),
 565     DEFINE_PROP_BIT64("discard", VHostUserBlk, parent_obj.host_features,
 566                       VIRTIO_BLK_F_DISCARD, true),
 567     DEFINE_PROP_BIT64("write-zeroes", VHostUserBlk, parent_obj.host_features,
 568                       VIRTIO_BLK_F_WRITE_ZEROES, true),
 569     DEFINE_PROP_END_OF_LIST(),
 570 };
 571
 572 static void vhost_user_blk_class_init(ObjectClass *klass, void *data)
 573 {
 574     DeviceClass *dc = DEVICE_CLASS(klass);
 575     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 576
 577     device_class_set_props(dc, vhost_user_blk_properties);
 578     dc->vmsd = &vmstate_vhost_user_blk;
 579     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 580     vdc->realize = vhost_user_blk_device_realize;
 581     vdc->unrealize = vhost_user_blk_device_unrealize;
 582     vdc->get_config = vhost_user_blk_update_config;
 583     vdc->set_config = vhost_user_blk_set_config;
 584     vdc->get_features = vhost_user_blk_get_features;
 585     vdc->set_status = vhost_user_blk_set_status;
 586     vdc->reset = vhost_user_blk_reset;
 587     vdc->get_vhost = vhost_user_blk_get_vhost;
 588 }
 589
 590 static const TypeInfo vhost_user_blk_info = {
 591     .name = TYPE_VHOST_USER_BLK,
 592     .parent = TYPE_VIRTIO_DEVICE,
 593     .instance_size = sizeof(VHostUserBlk),
 594     .instance_init = vhost_user_blk_instance_init,
 595     .class_init = vhost_user_blk_class_init,
 596 };
 597
 598 static void virtio_register_types(void)
 599 {
 600     type_register_static(&vhost_user_blk_info);
 601 }
 602
 603 type_init(virtio_register_types)