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 virtio_add_feature(&features, VIRTIO_BLK_F_RO); 207 208 if (s->config_wce) { 209 virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE); 210 } 211 if (s->num_queues > 1) { 212 virtio_add_feature(&features, VIRTIO_BLK_F_MQ); 213 } 214 215 return vhost_get_features(&s->dev, user_feature_bits, features); 216 } 217 218 static void vhost_user_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) 219 { 220 VHostUserBlk *s = VHOST_USER_BLK(vdev); 221 int i; 222 223 if (!(virtio_host_has_feature(vdev, VIRTIO_F_VERSION_1) && 224 !virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1))) { 225 return; 226 } 227 228 if (s->dev.started) { 229 return; 230 } 231 232 /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start 233 * vhost here instead of waiting for .set_status(). 234 */ 235 vhost_user_blk_start(vdev); 236 237 /* Kick right away to begin processing requests already in vring */ 238 for (i = 0; i < s->dev.nvqs; i++) { 239 VirtQueue *kick_vq = virtio_get_queue(vdev, i); 240 241 if (!virtio_queue_get_desc_addr(vdev, i)) { 242 continue; 243 } 244 event_notifier_set(virtio_queue_get_host_notifier(kick_vq)); 245 } 246 } 247 248 static void vhost_user_blk_device_realize(DeviceState *dev, Error **errp) 249 { 250 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 251 VHostUserBlk *s = VHOST_USER_BLK(vdev); 252 VhostUserState *user; 253 struct vhost_virtqueue *vqs = NULL; 254 int i, ret; 255 256 if (!s->chardev.chr) { 257 error_setg(errp, "vhost-user-blk: chardev is mandatory"); 258 return; 259 } 260 261 if (!s->num_queues || s->num_queues > VIRTIO_QUEUE_MAX) { 262 error_setg(errp, "vhost-user-blk: invalid number of IO queues"); 263 return; 264 } 265 266 if (!s->queue_size) { 267 error_setg(errp, "vhost-user-blk: queue size must be non-zero"); 268 return; 269 } 270 271 user = vhost_user_init(); 272 if (!user) { 273 error_setg(errp, "vhost-user-blk: failed to init vhost_user"); 274 return; 275 } 276 277 user->chr = &s->chardev; 278 s->vhost_user = user; 279 280 virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, 281 sizeof(struct virtio_blk_config)); 282 283 for (i = 0; i < s->num_queues; i++) { 284 virtio_add_queue(vdev, s->queue_size, 285 vhost_user_blk_handle_output); 286 } 287 288 s->dev.nvqs = s->num_queues; 289 s->dev.vqs = g_new(struct vhost_virtqueue, s->dev.nvqs); 290 s->dev.vq_index = 0; 291 s->dev.backend_features = 0; 292 vqs = s->dev.vqs; 293 294 vhost_dev_set_config_notifier(&s->dev, &blk_ops); 295 296 ret = vhost_dev_init(&s->dev, s->vhost_user, VHOST_BACKEND_TYPE_USER, 0); 297 if (ret < 0) { 298 error_setg(errp, "vhost-user-blk: vhost initialization failed: %s", 299 strerror(-ret)); 300 goto virtio_err; 301 } 302 303 ret = vhost_dev_get_config(&s->dev, (uint8_t *)&s->blkcfg, 304 sizeof(struct virtio_blk_config)); 305 if (ret < 0) { 306 error_setg(errp, "vhost-user-blk: get block config failed"); 307 goto vhost_err; 308 } 309 310 if (s->blkcfg.num_queues != s->num_queues) { 311 s->blkcfg.num_queues = s->num_queues; 312 } 313 314 return; 315 316 vhost_err: 317 vhost_dev_cleanup(&s->dev); 318 virtio_err: 319 g_free(vqs); 320 virtio_cleanup(vdev); 321 322 vhost_user_cleanup(user); 323 g_free(user); 324 s->vhost_user = NULL; 325 } 326 327 static void vhost_user_blk_device_unrealize(DeviceState *dev, Error **errp) 328 { 329 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 330 VHostUserBlk *s = VHOST_USER_BLK(dev); 331 struct vhost_virtqueue *vqs = s->dev.vqs; 332 333 vhost_user_blk_set_status(vdev, 0); 334 vhost_dev_cleanup(&s->dev); 335 g_free(vqs); 336 virtio_cleanup(vdev); 337 338 if (s->vhost_user) { 339 vhost_user_cleanup(s->vhost_user); 340 g_free(s->vhost_user); 341 s->vhost_user = NULL; 342 } 343 } 344 345 static void vhost_user_blk_instance_init(Object *obj) 346 { 347 VHostUserBlk *s = VHOST_USER_BLK(obj); 348 349 device_add_bootindex_property(obj, &s->bootindex, "bootindex", 350 "/disk@0,0", DEVICE(obj), NULL); 351 } 352 353 static const VMStateDescription vmstate_vhost_user_blk = { 354 .name = "vhost-user-blk", 355 .minimum_version_id = 1, 356 .version_id = 1, 357 .fields = (VMStateField[]) { 358 VMSTATE_VIRTIO_DEVICE, 359 VMSTATE_END_OF_LIST() 360 }, 361 }; 362 363 static Property vhost_user_blk_properties[] = { 364 DEFINE_PROP_CHR("chardev", VHostUserBlk, chardev), 365 DEFINE_PROP_UINT16("num-queues", VHostUserBlk, num_queues, 1), 366 DEFINE_PROP_UINT32("queue-size", VHostUserBlk, queue_size, 128), 367 DEFINE_PROP_BIT("config-wce", VHostUserBlk, config_wce, 0, true), 368 DEFINE_PROP_END_OF_LIST(), 369 }; 370 371 static void vhost_user_blk_class_init(ObjectClass *klass, void *data) 372 { 373 DeviceClass *dc = DEVICE_CLASS(klass); 374 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 375 376 dc->props = vhost_user_blk_properties; 377 dc->vmsd = &vmstate_vhost_user_blk; 378 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 379 vdc->realize = vhost_user_blk_device_realize; 380 vdc->unrealize = vhost_user_blk_device_unrealize; 381 vdc->get_config = vhost_user_blk_update_config; 382 vdc->set_config = vhost_user_blk_set_config; 383 vdc->get_features = vhost_user_blk_get_features; 384 vdc->set_status = vhost_user_blk_set_status; 385 } 386 387 static const TypeInfo vhost_user_blk_info = { 388 .name = TYPE_VHOST_USER_BLK, 389 .parent = TYPE_VIRTIO_DEVICE, 390 .instance_size = sizeof(VHostUserBlk), 391 .instance_init = vhost_user_blk_instance_init, 392 .class_init = vhost_user_blk_class_init, 393 }; 394 395 static void virtio_register_types(void) 396 { 397 type_register_static(&vhost_user_blk_info); 398 } 399 400 type_init(virtio_register_types) 401