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