2 * vhost-user-blk host device
4 * Copyright(C) 2017 Intel Corporation.
7 * Changpeng Liu <changpeng.liu@intel.com>
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>
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.
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"
35 static const int user_feature_bits
[] = {
36 VIRTIO_BLK_F_SIZE_MAX
,
38 VIRTIO_BLK_F_GEOMETRY
,
39 VIRTIO_BLK_F_BLK_SIZE
,
40 VIRTIO_BLK_F_TOPOLOGY
,
44 VIRTIO_BLK_F_CONFIG_WCE
,
46 VIRTIO_BLK_F_WRITE_ZEROES
,
48 VIRTIO_RING_F_INDIRECT_DESC
,
49 VIRTIO_RING_F_EVENT_IDX
,
50 VIRTIO_F_NOTIFY_ON_EMPTY
,
52 VIRTIO_F_IOMMU_PLATFORM
,
54 VHOST_INVALID_FEATURE_BIT
57 static void vhost_user_blk_event(void *opaque
, QEMUChrEvent event
);
59 static void vhost_user_blk_update_config(VirtIODevice
*vdev
, uint8_t *config
)
61 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
63 /* Our num_queues overrides the device backend */
64 virtio_stw_p(vdev
, &s
->blkcfg
.num_queues
, s
->num_queues
);
66 memcpy(config
, &s
->blkcfg
, vdev
->config_len
);
69 static void vhost_user_blk_set_config(VirtIODevice
*vdev
, const uint8_t *config
)
71 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
72 struct virtio_blk_config
*blkcfg
= (struct virtio_blk_config
*)config
;
75 if (blkcfg
->wce
== s
->blkcfg
.wce
) {
79 ret
= vhost_dev_set_config(&s
->dev
, &blkcfg
->wce
,
80 offsetof(struct virtio_blk_config
, wce
),
82 VHOST_SET_CONFIG_TYPE_FRONTEND
);
84 error_report("set device config space failed");
88 s
->blkcfg
.wce
= blkcfg
->wce
;
91 static int vhost_user_blk_handle_config_change(struct vhost_dev
*dev
)
94 struct virtio_blk_config blkcfg
;
95 VirtIODevice
*vdev
= dev
->vdev
;
96 VHostUserBlk
*s
= VHOST_USER_BLK(dev
->vdev
);
97 Error
*local_err
= NULL
;
103 ret
= vhost_dev_get_config(dev
, (uint8_t *)&blkcfg
,
104 vdev
->config_len
, &local_err
);
106 error_report_err(local_err
);
110 /* valid for resize only */
111 if (blkcfg
.capacity
!= s
->blkcfg
.capacity
) {
112 s
->blkcfg
.capacity
= blkcfg
.capacity
;
113 memcpy(dev
->vdev
->config
, &s
->blkcfg
, vdev
->config_len
);
114 virtio_notify_config(dev
->vdev
);
120 const VhostDevConfigOps blk_ops
= {
121 .vhost_dev_config_notifier
= vhost_user_blk_handle_config_change
,
124 static int vhost_user_blk_start(VirtIODevice
*vdev
, Error
**errp
)
126 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
127 BusState
*qbus
= BUS(qdev_get_parent_bus(DEVICE(vdev
)));
128 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
131 if (!k
->set_guest_notifiers
) {
132 error_setg(errp
, "binding does not support guest notifiers");
136 ret
= vhost_dev_enable_notifiers(&s
->dev
, vdev
);
138 error_setg_errno(errp
, -ret
, "Error enabling host notifiers");
142 ret
= k
->set_guest_notifiers(qbus
->parent
, s
->dev
.nvqs
, true);
144 error_setg_errno(errp
, -ret
, "Error binding guest notifier");
145 goto err_host_notifiers
;
148 s
->dev
.acked_features
= vdev
->guest_features
;
150 ret
= vhost_dev_prepare_inflight(&s
->dev
, vdev
);
152 error_setg_errno(errp
, -ret
, "Error setting inflight format");
153 goto err_guest_notifiers
;
156 if (!s
->inflight
->addr
) {
157 ret
= vhost_dev_get_inflight(&s
->dev
, s
->queue_size
, s
->inflight
);
159 error_setg_errno(errp
, -ret
, "Error getting inflight");
160 goto err_guest_notifiers
;
164 ret
= vhost_dev_set_inflight(&s
->dev
, s
->inflight
);
166 error_setg_errno(errp
, -ret
, "Error setting inflight");
167 goto err_guest_notifiers
;
170 /* guest_notifier_mask/pending not used yet, so just unmask
171 * everything here. virtio-pci will do the right thing by
172 * enabling/disabling irqfd.
174 for (i
= 0; i
< s
->dev
.nvqs
; i
++) {
175 vhost_virtqueue_mask(&s
->dev
, vdev
, i
, false);
178 s
->dev
.vq_index_end
= s
->dev
.nvqs
;
179 ret
= vhost_dev_start(&s
->dev
, vdev
, true);
181 error_setg_errno(errp
, -ret
, "Error starting vhost");
182 goto err_guest_notifiers
;
184 s
->started_vu
= true;
189 for (i
= 0; i
< s
->dev
.nvqs
; i
++) {
190 vhost_virtqueue_mask(&s
->dev
, vdev
, i
, true);
192 k
->set_guest_notifiers(qbus
->parent
, s
->dev
.nvqs
, false);
194 vhost_dev_disable_notifiers(&s
->dev
, vdev
);
198 static void vhost_user_blk_stop(VirtIODevice
*vdev
)
200 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
201 BusState
*qbus
= BUS(qdev_get_parent_bus(DEVICE(vdev
)));
202 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
205 if (!s
->started_vu
) {
208 s
->started_vu
= false;
210 if (!k
->set_guest_notifiers
) {
214 vhost_dev_stop(&s
->dev
, vdev
, true);
216 ret
= k
->set_guest_notifiers(qbus
->parent
, s
->dev
.nvqs
, false);
218 error_report("vhost guest notifier cleanup failed: %d", ret
);
222 vhost_dev_disable_notifiers(&s
->dev
, vdev
);
225 static void vhost_user_blk_set_status(VirtIODevice
*vdev
, uint8_t status
)
227 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
228 bool should_start
= virtio_device_should_start(vdev
, status
);
229 Error
*local_err
= NULL
;
236 if (vhost_dev_is_started(&s
->dev
) == should_start
) {
241 ret
= vhost_user_blk_start(vdev
, &local_err
);
243 error_reportf_err(local_err
, "vhost-user-blk: vhost start failed: ");
244 qemu_chr_fe_disconnect(&s
->chardev
);
247 vhost_user_blk_stop(vdev
);
252 static uint64_t vhost_user_blk_get_features(VirtIODevice
*vdev
,
256 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
258 /* Turn on pre-defined features */
259 virtio_add_feature(&features
, VIRTIO_BLK_F_SIZE_MAX
);
260 virtio_add_feature(&features
, VIRTIO_BLK_F_SEG_MAX
);
261 virtio_add_feature(&features
, VIRTIO_BLK_F_GEOMETRY
);
262 virtio_add_feature(&features
, VIRTIO_BLK_F_TOPOLOGY
);
263 virtio_add_feature(&features
, VIRTIO_BLK_F_BLK_SIZE
);
264 virtio_add_feature(&features
, VIRTIO_BLK_F_FLUSH
);
265 virtio_add_feature(&features
, VIRTIO_BLK_F_RO
);
267 if (s
->num_queues
> 1) {
268 virtio_add_feature(&features
, VIRTIO_BLK_F_MQ
);
271 return vhost_get_features(&s
->dev
, user_feature_bits
, features
);
274 static void vhost_user_blk_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
276 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
277 Error
*local_err
= NULL
;
280 if (!vdev
->start_on_kick
) {
288 if (vhost_dev_is_started(&s
->dev
)) {
292 /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
293 * vhost here instead of waiting for .set_status().
295 ret
= vhost_user_blk_start(vdev
, &local_err
);
297 error_reportf_err(local_err
, "vhost-user-blk: vhost start failed: ");
298 qemu_chr_fe_disconnect(&s
->chardev
);
302 /* Kick right away to begin processing requests already in vring */
303 for (i
= 0; i
< s
->dev
.nvqs
; i
++) {
304 VirtQueue
*kick_vq
= virtio_get_queue(vdev
, i
);
306 if (!virtio_queue_get_desc_addr(vdev
, i
)) {
309 event_notifier_set(virtio_queue_get_host_notifier(kick_vq
));
313 static void vhost_user_blk_reset(VirtIODevice
*vdev
)
315 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
317 vhost_dev_free_inflight(s
->inflight
);
320 static int vhost_user_blk_connect(DeviceState
*dev
, Error
**errp
)
322 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
323 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
330 s
->dev
.num_queues
= s
->num_queues
;
331 s
->dev
.nvqs
= s
->num_queues
;
332 s
->dev
.vqs
= s
->vhost_vqs
;
334 s
->dev
.backend_features
= 0;
336 vhost_dev_set_config_notifier(&s
->dev
, &blk_ops
);
338 s
->vhost_user
.supports_config
= true;
339 ret
= vhost_dev_init(&s
->dev
, &s
->vhost_user
, VHOST_BACKEND_TYPE_USER
, 0,
347 /* restore vhost state */
348 if (virtio_device_started(vdev
, vdev
->status
)) {
349 ret
= vhost_user_blk_start(vdev
, errp
);
355 static void vhost_user_blk_disconnect(DeviceState
*dev
)
357 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
358 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
363 s
->connected
= false;
365 vhost_user_blk_stop(vdev
);
367 vhost_dev_cleanup(&s
->dev
);
369 /* Re-instate the event handler for new connections */
370 qemu_chr_fe_set_handlers(&s
->chardev
, NULL
, NULL
, vhost_user_blk_event
,
371 NULL
, dev
, NULL
, true);
374 static void vhost_user_blk_event(void *opaque
, QEMUChrEvent event
)
376 DeviceState
*dev
= opaque
;
377 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
378 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
379 Error
*local_err
= NULL
;
382 case CHR_EVENT_OPENED
:
383 if (vhost_user_blk_connect(dev
, &local_err
) < 0) {
384 error_report_err(local_err
);
385 qemu_chr_fe_disconnect(&s
->chardev
);
389 case CHR_EVENT_CLOSED
:
390 /* defer close until later to avoid circular close */
391 vhost_user_async_close(dev
, &s
->chardev
, &s
->dev
,
392 vhost_user_blk_disconnect
, vhost_user_blk_event
);
394 case CHR_EVENT_BREAK
:
395 case CHR_EVENT_MUX_IN
:
396 case CHR_EVENT_MUX_OUT
:
402 static int vhost_user_blk_realize_connect(VHostUserBlk
*s
, Error
**errp
)
404 DeviceState
*dev
= DEVICE(s
);
407 s
->connected
= false;
409 ret
= qemu_chr_fe_wait_connected(&s
->chardev
, errp
);
414 ret
= vhost_user_blk_connect(dev
, errp
);
416 qemu_chr_fe_disconnect(&s
->chardev
);
419 assert(s
->connected
);
421 ret
= vhost_dev_get_config(&s
->dev
, (uint8_t *)&s
->blkcfg
,
422 VIRTIO_DEVICE(s
)->config_len
, errp
);
424 qemu_chr_fe_disconnect(&s
->chardev
);
425 vhost_dev_cleanup(&s
->dev
);
432 static void vhost_user_blk_device_realize(DeviceState
*dev
, Error
**errp
)
435 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
436 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
441 if (!s
->chardev
.chr
) {
442 error_setg(errp
, "chardev is mandatory");
446 if (s
->num_queues
== VHOST_USER_BLK_AUTO_NUM_QUEUES
) {
449 if (!s
->num_queues
|| s
->num_queues
> VIRTIO_QUEUE_MAX
) {
450 error_setg(errp
, "invalid number of IO queues");
454 if (!s
->queue_size
) {
455 error_setg(errp
, "queue size must be non-zero");
458 if (s
->queue_size
> VIRTQUEUE_MAX_SIZE
) {
459 error_setg(errp
, "queue size must not exceed %d",
464 if (!vhost_user_init(&s
->vhost_user
, &s
->chardev
, errp
)) {
468 config_size
= virtio_get_config_size(&virtio_blk_cfg_size_params
,
469 vdev
->host_features
);
470 virtio_init(vdev
, VIRTIO_ID_BLOCK
, config_size
);
472 s
->virtqs
= g_new(VirtQueue
*, s
->num_queues
);
473 for (i
= 0; i
< s
->num_queues
; i
++) {
474 s
->virtqs
[i
] = virtio_add_queue(vdev
, s
->queue_size
,
475 vhost_user_blk_handle_output
);
478 s
->inflight
= g_new0(struct vhost_inflight
, 1);
479 s
->vhost_vqs
= g_new0(struct vhost_virtqueue
, s
->num_queues
);
481 retries
= VU_REALIZE_CONN_RETRIES
;
485 error_prepend(errp
, "Reconnecting after error: ");
486 error_report_err(*errp
);
489 ret
= vhost_user_blk_realize_connect(s
, errp
);
490 } while (ret
< 0 && retries
--);
496 /* we're fully initialized, now we can operate, so add the handler */
497 qemu_chr_fe_set_handlers(&s
->chardev
, NULL
, NULL
,
498 vhost_user_blk_event
, NULL
, (void *)dev
,
503 g_free(s
->vhost_vqs
);
507 for (i
= 0; i
< s
->num_queues
; i
++) {
508 virtio_delete_queue(s
->virtqs
[i
]);
511 virtio_cleanup(vdev
);
512 vhost_user_cleanup(&s
->vhost_user
);
515 static void vhost_user_blk_device_unrealize(DeviceState
*dev
)
517 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
518 VHostUserBlk
*s
= VHOST_USER_BLK(dev
);
521 virtio_set_status(vdev
, 0);
522 qemu_chr_fe_set_handlers(&s
->chardev
, NULL
, NULL
, NULL
,
523 NULL
, NULL
, NULL
, false);
524 vhost_dev_cleanup(&s
->dev
);
525 vhost_dev_free_inflight(s
->inflight
);
526 g_free(s
->vhost_vqs
);
531 for (i
= 0; i
< s
->num_queues
; i
++) {
532 virtio_delete_queue(s
->virtqs
[i
]);
535 virtio_cleanup(vdev
);
536 vhost_user_cleanup(&s
->vhost_user
);
539 static void vhost_user_blk_instance_init(Object
*obj
)
541 VHostUserBlk
*s
= VHOST_USER_BLK(obj
);
543 device_add_bootindex_property(obj
, &s
->bootindex
, "bootindex",
544 "/disk@0,0", DEVICE(obj
));
547 static struct vhost_dev
*vhost_user_blk_get_vhost(VirtIODevice
*vdev
)
549 VHostUserBlk
*s
= VHOST_USER_BLK(vdev
);
553 static const VMStateDescription vmstate_vhost_user_blk
= {
554 .name
= "vhost-user-blk",
555 .minimum_version_id
= 1,
557 .fields
= (const VMStateField
[]) {
558 VMSTATE_VIRTIO_DEVICE
,
559 VMSTATE_END_OF_LIST()
563 static Property vhost_user_blk_properties
[] = {
564 DEFINE_PROP_CHR("chardev", VHostUserBlk
, chardev
),
565 DEFINE_PROP_UINT16("num-queues", VHostUserBlk
, num_queues
,
566 VHOST_USER_BLK_AUTO_NUM_QUEUES
),
567 DEFINE_PROP_UINT32("queue-size", VHostUserBlk
, queue_size
, 128),
568 DEFINE_PROP_BIT64("config-wce", VHostUserBlk
, parent_obj
.host_features
,
569 VIRTIO_BLK_F_CONFIG_WCE
, true),
570 DEFINE_PROP_BIT64("discard", VHostUserBlk
, parent_obj
.host_features
,
571 VIRTIO_BLK_F_DISCARD
, true),
572 DEFINE_PROP_BIT64("write-zeroes", VHostUserBlk
, parent_obj
.host_features
,
573 VIRTIO_BLK_F_WRITE_ZEROES
, true),
574 DEFINE_PROP_END_OF_LIST(),
577 static void vhost_user_blk_class_init(ObjectClass
*klass
, void *data
)
579 DeviceClass
*dc
= DEVICE_CLASS(klass
);
580 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
582 device_class_set_props(dc
, vhost_user_blk_properties
);
583 dc
->vmsd
= &vmstate_vhost_user_blk
;
584 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
585 vdc
->realize
= vhost_user_blk_device_realize
;
586 vdc
->unrealize
= vhost_user_blk_device_unrealize
;
587 vdc
->get_config
= vhost_user_blk_update_config
;
588 vdc
->set_config
= vhost_user_blk_set_config
;
589 vdc
->get_features
= vhost_user_blk_get_features
;
590 vdc
->set_status
= vhost_user_blk_set_status
;
591 vdc
->reset
= vhost_user_blk_reset
;
592 vdc
->get_vhost
= vhost_user_blk_get_vhost
;
595 static const TypeInfo vhost_user_blk_info
= {
596 .name
= TYPE_VHOST_USER_BLK
,
597 .parent
= TYPE_VIRTIO_DEVICE
,
598 .instance_size
= sizeof(VHostUserBlk
),
599 .instance_init
= vhost_user_blk_instance_init
,
600 .class_init
= vhost_user_blk_class_init
,
603 static void virtio_register_types(void)
605 type_register_static(&vhost_user_blk_info
);
608 type_init(virtio_register_types
)