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 "qom/object.h"
  24 #include "hw/qdev-core.h"
  25 #include "hw/virtio/vhost.h"
  26 #include "hw/virtio/vhost-user-blk.h"
  27 #include "hw/virtio/virtio.h"
  28 #include "hw/virtio/virtio-bus.h"
  29 #include "hw/virtio/virtio-access.h"
  30
  31 static const int user_feature_bits[] = {
  32     VIRTIO_BLK_F_SIZE_MAX,
  33     VIRTIO_BLK_F_SEG_MAX,
  34     VIRTIO_BLK_F_GEOMETRY,
  35     VIRTIO_BLK_F_BLK_SIZE,
  36     VIRTIO_BLK_F_TOPOLOGY,
  37     VIRTIO_BLK_F_MQ,
  38     VIRTIO_BLK_F_RO,
  39     VIRTIO_BLK_F_FLUSH,
  40     VIRTIO_BLK_F_CONFIG_WCE,
  41     VIRTIO_F_VERSION_1,
  42     VIRTIO_RING_F_INDIRECT_DESC,
  43     VIRTIO_RING_F_EVENT_IDX,
  44     VIRTIO_F_NOTIFY_ON_EMPTY,
  45     VHOST_INVALID_FEATURE_BIT
  46 };
  47
  48 static void vhost_user_blk_update_config(VirtIODevice *vdev, uint8_t *config)
  49 {
  50     VHostUserBlk *s = VHOST_USER_BLK(vdev);
  51
  52     memcpy(config, &s->blkcfg, sizeof(struct virtio_blk_config));
  53 }
  54
  55 static void vhost_user_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
  56 {
  57     VHostUserBlk *s = VHOST_USER_BLK(vdev);
  58     struct virtio_blk_config *blkcfg = (struct virtio_blk_config *)config;
  59     int ret;
  60
  61     if (blkcfg->wce == s->blkcfg.wce) {
  62         return;
  63     }
  64
  65     ret = vhost_dev_set_config(&s->dev, &blkcfg->wce,
  66                                offsetof(struct virtio_blk_config, wce),
  67                                sizeof(blkcfg->wce),
  68                                VHOST_SET_CONFIG_TYPE_MASTER);
  69     if (ret) {
  70         error_report("set device config space failed");
  71         return;
  72     }
  73
  74     s->blkcfg.wce = blkcfg->wce;
  75 }
  76
  77 static int vhost_user_blk_handle_config_change(struct vhost_dev *dev)
  78 {
  79     int ret;
  80     struct virtio_blk_config blkcfg;
  81     VHostUserBlk *s = VHOST_USER_BLK(dev->vdev);
  82
  83     ret = vhost_dev_get_config(dev, (uint8_t *)&blkcfg,
  84                                sizeof(struct virtio_blk_config));
  85     if (ret < 0) {
  86         error_report("get config space failed");
  87         return -1;
  88     }
  89
  90     /* valid for resize only */
  91     if (blkcfg.capacity != s->blkcfg.capacity) {
  92         s->blkcfg.capacity = blkcfg.capacity;
  93         memcpy(dev->vdev->config, &s->blkcfg, sizeof(struct virtio_blk_config));
  94         virtio_notify_config(dev->vdev);
  95     }
  96
  97     return 0;
  98 }
  99
 100 const VhostDevConfigOps blk_ops = {
 101     .vhost_dev_config_notifier = vhost_user_blk_handle_config_change,
 102 };
 103
 104 static void vhost_user_blk_start(VirtIODevice *vdev)
 105 {
 106     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 107     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
 108     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 109     int i, ret;
 110
 111     if (!k->set_guest_notifiers) {
 112         error_report("binding does not support guest notifiers");
 113         return;
 114     }
 115
 116     ret = vhost_dev_enable_notifiers(&s->dev, vdev);
 117     if (ret < 0) {
 118         error_report("Error enabling host notifiers: %d", -ret);
 119         return;
 120     }
 121
 122     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);
 123     if (ret < 0) {
 124         error_report("Error binding guest notifier: %d", -ret);
 125         goto err_host_notifiers;
 126     }
 127
 128     s->dev.acked_features = vdev->guest_features;
 129     ret = vhost_dev_start(&s->dev, vdev);
 130     if (ret < 0) {
 131         error_report("Error starting vhost: %d", -ret);
 132         goto err_guest_notifiers;
 133     }
 134
 135     /* guest_notifier_mask/pending not used yet, so just unmask
 136      * everything here. virtio-pci will do the right thing by
 137      * enabling/disabling irqfd.
 138      */
 139     for (i = 0; i < s->dev.nvqs; i++) {
 140         vhost_virtqueue_mask(&s->dev, vdev, i, false);
 141     }
 142
 143     return;
 144
 145 err_guest_notifiers:
 146     k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
 147 err_host_notifiers:
 148     vhost_dev_disable_notifiers(&s->dev, vdev);
 149 }
 150
 151 static void vhost_user_blk_stop(VirtIODevice *vdev)
 152 {
 153     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 154     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
 155     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
 156     int ret;
 157
 158     if (!k->set_guest_notifiers) {
 159         return;
 160     }
 161
 162     vhost_dev_stop(&s->dev, vdev);
 163
 164     ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
 165     if (ret < 0) {
 166         error_report("vhost guest notifier cleanup failed: %d", ret);
 167         return;
 168     }
 169
 170     vhost_dev_disable_notifiers(&s->dev, vdev);
 171 }
 172
 173 static void vhost_user_blk_set_status(VirtIODevice *vdev, uint8_t status)
 174 {
 175     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 176     bool should_start = status & VIRTIO_CONFIG_S_DRIVER_OK;
 177
 178     if (!vdev->vm_running) {
 179         should_start = false;
 180     }
 181
 182     if (s->dev.started == should_start) {
 183         return;
 184     }
 185
 186     if (should_start) {
 187         vhost_user_blk_start(vdev);
 188     } else {
 189         vhost_user_blk_stop(vdev);
 190     }
 191
 192 }
 193
 194 static uint64_t vhost_user_blk_get_features(VirtIODevice *vdev,
 195                                             uint64_t features,
 196                                             Error **errp)
 197 {
 198     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 199
 200     /* Turn on pre-defined features */
 201     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
 202     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
 203     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
 204     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
 205     virtio_add_feature(&features, VIRTIO_BLK_F_FLUSH);
 206
 207     if (s->config_wce) {
 208         virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE);
 209     }
 210     if (s->config_ro) {
 211         virtio_add_feature(&features, VIRTIO_BLK_F_RO);
 212     }
 213     if (s->num_queues > 1) {
 214         virtio_add_feature(&features, VIRTIO_BLK_F_MQ);
 215     }
 216
 217     return vhost_get_features(&s->dev, user_feature_bits, features);
 218 }
 219
 220 static void vhost_user_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 221 {
 222
 223 }
 224
 225 static void vhost_user_blk_device_realize(DeviceState *dev, Error **errp)
 226 {
 227     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 228     VHostUserBlk *s = VHOST_USER_BLK(vdev);
 229     VhostUserState *user;
 230     int i, ret;
 231
 232     if (!s->chardev.chr) {
 233         error_setg(errp, "vhost-user-blk: chardev is mandatory");
 234         return;
 235     }
 236
 237     if (!s->num_queues || s->num_queues > VIRTIO_QUEUE_MAX) {
 238         error_setg(errp, "vhost-user-blk: invalid number of IO queues");
 239         return;
 240     }
 241
 242     if (!s->queue_size) {
 243         error_setg(errp, "vhost-user-blk: queue size must be non-zero");
 244         return;
 245     }
 246
 247     user = vhost_user_init();
 248     if (!user) {
 249         error_setg(errp, "vhost-user-blk: failed to init vhost_user");
 250         return;
 251     }
 252
 253     user->chr = &s->chardev;
 254     s->vhost_user = user;
 255
 256     virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
 257                 sizeof(struct virtio_blk_config));
 258
 259     for (i = 0; i < s->num_queues; i++) {
 260         virtio_add_queue(vdev, s->queue_size,
 261                          vhost_user_blk_handle_output);
 262     }
 263
 264     s->dev.nvqs = s->num_queues;
 265     s->dev.vqs = g_new(struct vhost_virtqueue, s->dev.nvqs);
 266     s->dev.vq_index = 0;
 267     s->dev.backend_features = 0;
 268
 269     vhost_dev_set_config_notifier(&s->dev, &blk_ops);
 270
 271     ret = vhost_dev_init(&s->dev, s->vhost_user, VHOST_BACKEND_TYPE_USER, 0);
 272     if (ret < 0) {
 273         error_setg(errp, "vhost-user-blk: vhost initialization failed: %s",
 274                    strerror(-ret));
 275         goto virtio_err;
 276     }
 277
 278     ret = vhost_dev_get_config(&s->dev, (uint8_t *)&s->blkcfg,
 279                               sizeof(struct virtio_blk_config));
 280     if (ret < 0) {
 281         error_setg(errp, "vhost-user-blk: get block config failed");
 282         goto vhost_err;
 283     }
 284
 285     if (s->blkcfg.num_queues != s->num_queues) {
 286         s->blkcfg.num_queues = s->num_queues;
 287     }
 288
 289     return;
 290
 291 vhost_err:
 292     vhost_dev_cleanup(&s->dev);
 293 virtio_err:
 294     g_free(s->dev.vqs);
 295     virtio_cleanup(vdev);
 296
 297     vhost_user_cleanup(user);
 298     g_free(user);
 299     s->vhost_user = NULL;
 300 }
 301
 302 static void vhost_user_blk_device_unrealize(DeviceState *dev, Error **errp)
 303 {
 304     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 305     VHostUserBlk *s = VHOST_USER_BLK(dev);
 306
 307     vhost_user_blk_set_status(vdev, 0);
 308     vhost_dev_cleanup(&s->dev);
 309     g_free(s->dev.vqs);
 310     virtio_cleanup(vdev);
 311
 312     if (s->vhost_user) {
 313         vhost_user_cleanup(s->vhost_user);
 314         g_free(s->vhost_user);
 315         s->vhost_user = NULL;
 316     }
 317 }
 318
 319 static void vhost_user_blk_instance_init(Object *obj)
 320 {
 321     VHostUserBlk *s = VHOST_USER_BLK(obj);
 322
 323     device_add_bootindex_property(obj, &s->bootindex, "bootindex",
 324                                   "/disk@0,0", DEVICE(obj), NULL);
 325 }
 326
 327 static const VMStateDescription vmstate_vhost_user_blk = {
 328     .name = "vhost-user-blk",
 329     .minimum_version_id = 1,
 330     .version_id = 1,
 331     .fields = (VMStateField[]) {
 332         VMSTATE_VIRTIO_DEVICE,
 333         VMSTATE_END_OF_LIST()
 334     },
 335 };
 336
 337 static Property vhost_user_blk_properties[] = {
 338     DEFINE_PROP_CHR("chardev", VHostUserBlk, chardev),
 339     DEFINE_PROP_UINT16("num-queues", VHostUserBlk, num_queues, 1),
 340     DEFINE_PROP_UINT32("queue-size", VHostUserBlk, queue_size, 128),
 341     DEFINE_PROP_BIT("config-wce", VHostUserBlk, config_wce, 0, true),
 342     DEFINE_PROP_BIT("config-ro", VHostUserBlk, config_ro, 0, false),
 343     DEFINE_PROP_END_OF_LIST(),
 344 };
 345
 346 static void vhost_user_blk_class_init(ObjectClass *klass, void *data)
 347 {
 348     DeviceClass *dc = DEVICE_CLASS(klass);
 349     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 350
 351     dc->props = vhost_user_blk_properties;
 352     dc->vmsd = &vmstate_vhost_user_blk;
 353     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 354     vdc->realize = vhost_user_blk_device_realize;
 355     vdc->unrealize = vhost_user_blk_device_unrealize;
 356     vdc->get_config = vhost_user_blk_update_config;
 357     vdc->set_config = vhost_user_blk_set_config;
 358     vdc->get_features = vhost_user_blk_get_features;
 359     vdc->set_status = vhost_user_blk_set_status;
 360 }
 361
 362 static const TypeInfo vhost_user_blk_info = {
 363     .name = TYPE_VHOST_USER_BLK,
 364     .parent = TYPE_VIRTIO_DEVICE,
 365     .instance_size = sizeof(VHostUserBlk),
 366     .instance_init = vhost_user_blk_instance_init,
 367     .class_init = vhost_user_blk_class_init,
 368 };
 369
 370 static void virtio_register_types(void)
 371 {
 372     type_register_static(&vhost_user_blk_info);
 373 }
 374
 375 type_init(virtio_register_types)