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