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