1 /* 2 * QEMU Block backends 3 * 4 * Copyright (C) 2014-2016 Red Hat, Inc. 5 * 6 * Authors: 7 * Markus Armbruster <armbru@redhat.com>, 8 * 9 * This work is licensed under the terms of the GNU LGPL, version 2.1 10 * or later. See the COPYING.LIB file in the top-level directory. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "sysemu/block-backend.h" 15 #include "block/block_int.h" 16 #include "block/blockjob.h" 17 #include "block/throttle-groups.h" 18 #include "hw/qdev-core.h" 19 #include "sysemu/blockdev.h" 20 #include "sysemu/runstate.h" 21 #include "qapi/error.h" 22 #include "qapi/qapi-events-block.h" 23 #include "qemu/id.h" 24 #include "qemu/main-loop.h" 25 #include "qemu/option.h" 26 #include "trace.h" 27 #include "migration/misc.h" 28 29 /* Number of coroutines to reserve per attached device model */ 30 #define COROUTINE_POOL_RESERVATION 64 31 32 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 33 34 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb); 35 36 typedef struct BlockBackendAioNotifier { 37 void (*attached_aio_context)(AioContext *new_context, void *opaque); 38 void (*detach_aio_context)(void *opaque); 39 void *opaque; 40 QLIST_ENTRY(BlockBackendAioNotifier) list; 41 } BlockBackendAioNotifier; 42 43 struct BlockBackend { 44 char *name; 45 int refcnt; 46 BdrvChild *root; 47 AioContext *ctx; 48 DriveInfo *legacy_dinfo; /* null unless created by drive_new() */ 49 QTAILQ_ENTRY(BlockBackend) link; /* for block_backends */ 50 QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */ 51 BlockBackendPublic public; 52 53 DeviceState *dev; /* attached device model, if any */ 54 const BlockDevOps *dev_ops; 55 void *dev_opaque; 56 57 /* the block size for which the guest device expects atomicity */ 58 int guest_block_size; 59 60 /* If the BDS tree is removed, some of its options are stored here (which 61 * can be used to restore those options in the new BDS on insert) */ 62 BlockBackendRootState root_state; 63 64 bool enable_write_cache; 65 66 /* I/O stats (display with "info blockstats"). */ 67 BlockAcctStats stats; 68 69 BlockdevOnError on_read_error, on_write_error; 70 bool iostatus_enabled; 71 BlockDeviceIoStatus iostatus; 72 73 uint64_t perm; 74 uint64_t shared_perm; 75 bool disable_perm; 76 77 bool allow_aio_context_change; 78 bool allow_write_beyond_eof; 79 80 NotifierList remove_bs_notifiers, insert_bs_notifiers; 81 QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers; 82 83 int quiesce_counter; 84 VMChangeStateEntry *vmsh; 85 bool force_allow_inactivate; 86 87 /* Number of in-flight aio requests. BlockDriverState also counts 88 * in-flight requests but aio requests can exist even when blk->root is 89 * NULL, so we cannot rely on its counter for that case. 90 * Accessed with atomic ops. 91 */ 92 unsigned int in_flight; 93 }; 94 95 typedef struct BlockBackendAIOCB { 96 BlockAIOCB common; 97 BlockBackend *blk; 98 int ret; 99 } BlockBackendAIOCB; 100 101 static const AIOCBInfo block_backend_aiocb_info = { 102 .get_aio_context = blk_aiocb_get_aio_context, 103 .aiocb_size = sizeof(BlockBackendAIOCB), 104 }; 105 106 static void drive_info_del(DriveInfo *dinfo); 107 static BlockBackend *bdrv_first_blk(BlockDriverState *bs); 108 109 /* All BlockBackends */ 110 static QTAILQ_HEAD(, BlockBackend) block_backends = 111 QTAILQ_HEAD_INITIALIZER(block_backends); 112 113 /* All BlockBackends referenced by the monitor and which are iterated through by 114 * blk_next() */ 115 static QTAILQ_HEAD(, BlockBackend) monitor_block_backends = 116 QTAILQ_HEAD_INITIALIZER(monitor_block_backends); 117 118 static void blk_root_inherit_options(int *child_flags, QDict *child_options, 119 int parent_flags, QDict *parent_options) 120 { 121 /* We're not supposed to call this function for root nodes */ 122 abort(); 123 } 124 static void blk_root_drained_begin(BdrvChild *child); 125 static bool blk_root_drained_poll(BdrvChild *child); 126 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter); 127 128 static void blk_root_change_media(BdrvChild *child, bool load); 129 static void blk_root_resize(BdrvChild *child); 130 131 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx, 132 GSList **ignore, Error **errp); 133 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx, 134 GSList **ignore); 135 136 static char *blk_root_get_parent_desc(BdrvChild *child) 137 { 138 BlockBackend *blk = child->opaque; 139 char *dev_id; 140 141 if (blk->name) { 142 return g_strdup(blk->name); 143 } 144 145 dev_id = blk_get_attached_dev_id(blk); 146 if (*dev_id) { 147 return dev_id; 148 } else { 149 /* TODO Callback into the BB owner for something more detailed */ 150 g_free(dev_id); 151 return g_strdup("a block device"); 152 } 153 } 154 155 static const char *blk_root_get_name(BdrvChild *child) 156 { 157 return blk_name(child->opaque); 158 } 159 160 static void blk_vm_state_changed(void *opaque, int running, RunState state) 161 { 162 Error *local_err = NULL; 163 BlockBackend *blk = opaque; 164 165 if (state == RUN_STATE_INMIGRATE) { 166 return; 167 } 168 169 qemu_del_vm_change_state_handler(blk->vmsh); 170 blk->vmsh = NULL; 171 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err); 172 if (local_err) { 173 error_report_err(local_err); 174 } 175 } 176 177 /* 178 * Notifies the user of the BlockBackend that migration has completed. qdev 179 * devices can tighten their permissions in response (specifically revoke 180 * shared write permissions that we needed for storage migration). 181 * 182 * If an error is returned, the VM cannot be allowed to be resumed. 183 */ 184 static void blk_root_activate(BdrvChild *child, Error **errp) 185 { 186 BlockBackend *blk = child->opaque; 187 Error *local_err = NULL; 188 189 if (!blk->disable_perm) { 190 return; 191 } 192 193 blk->disable_perm = false; 194 195 blk_set_perm(blk, blk->perm, BLK_PERM_ALL, &local_err); 196 if (local_err) { 197 error_propagate(errp, local_err); 198 blk->disable_perm = true; 199 return; 200 } 201 202 if (runstate_check(RUN_STATE_INMIGRATE)) { 203 /* Activation can happen when migration process is still active, for 204 * example when nbd_server_add is called during non-shared storage 205 * migration. Defer the shared_perm update to migration completion. */ 206 if (!blk->vmsh) { 207 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed, 208 blk); 209 } 210 return; 211 } 212 213 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err); 214 if (local_err) { 215 error_propagate(errp, local_err); 216 blk->disable_perm = true; 217 return; 218 } 219 } 220 221 void blk_set_force_allow_inactivate(BlockBackend *blk) 222 { 223 blk->force_allow_inactivate = true; 224 } 225 226 static bool blk_can_inactivate(BlockBackend *blk) 227 { 228 /* If it is a guest device, inactivate is ok. */ 229 if (blk->dev || blk_name(blk)[0]) { 230 return true; 231 } 232 233 /* Inactivating means no more writes to the image can be done, 234 * even if those writes would be changes invisible to the 235 * guest. For block job BBs that satisfy this, we can just allow 236 * it. This is the case for mirror job source, which is required 237 * by libvirt non-shared block migration. */ 238 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) { 239 return true; 240 } 241 242 return blk->force_allow_inactivate; 243 } 244 245 static int blk_root_inactivate(BdrvChild *child) 246 { 247 BlockBackend *blk = child->opaque; 248 249 if (blk->disable_perm) { 250 return 0; 251 } 252 253 if (!blk_can_inactivate(blk)) { 254 return -EPERM; 255 } 256 257 blk->disable_perm = true; 258 if (blk->root) { 259 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort); 260 } 261 262 return 0; 263 } 264 265 static void blk_root_attach(BdrvChild *child) 266 { 267 BlockBackend *blk = child->opaque; 268 BlockBackendAioNotifier *notifier; 269 270 trace_blk_root_attach(child, blk, child->bs); 271 272 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { 273 bdrv_add_aio_context_notifier(child->bs, 274 notifier->attached_aio_context, 275 notifier->detach_aio_context, 276 notifier->opaque); 277 } 278 } 279 280 static void blk_root_detach(BdrvChild *child) 281 { 282 BlockBackend *blk = child->opaque; 283 BlockBackendAioNotifier *notifier; 284 285 trace_blk_root_detach(child, blk, child->bs); 286 287 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { 288 bdrv_remove_aio_context_notifier(child->bs, 289 notifier->attached_aio_context, 290 notifier->detach_aio_context, 291 notifier->opaque); 292 } 293 } 294 295 static const BdrvChildRole child_root = { 296 .inherit_options = blk_root_inherit_options, 297 298 .change_media = blk_root_change_media, 299 .resize = blk_root_resize, 300 .get_name = blk_root_get_name, 301 .get_parent_desc = blk_root_get_parent_desc, 302 303 .drained_begin = blk_root_drained_begin, 304 .drained_poll = blk_root_drained_poll, 305 .drained_end = blk_root_drained_end, 306 307 .activate = blk_root_activate, 308 .inactivate = blk_root_inactivate, 309 310 .attach = blk_root_attach, 311 .detach = blk_root_detach, 312 313 .can_set_aio_ctx = blk_root_can_set_aio_ctx, 314 .set_aio_ctx = blk_root_set_aio_ctx, 315 }; 316 317 /* 318 * Create a new BlockBackend with a reference count of one. 319 * 320 * @perm is a bitmasks of BLK_PERM_* constants which describes the permissions 321 * to request for a block driver node that is attached to this BlockBackend. 322 * @shared_perm is a bitmask which describes which permissions may be granted 323 * to other users of the attached node. 324 * Both sets of permissions can be changed later using blk_set_perm(). 325 * 326 * Return the new BlockBackend on success, null on failure. 327 */ 328 BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm) 329 { 330 BlockBackend *blk; 331 332 blk = g_new0(BlockBackend, 1); 333 blk->refcnt = 1; 334 blk->ctx = ctx; 335 blk->perm = perm; 336 blk->shared_perm = shared_perm; 337 blk_set_enable_write_cache(blk, true); 338 339 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT; 340 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; 341 342 block_acct_init(&blk->stats); 343 344 notifier_list_init(&blk->remove_bs_notifiers); 345 notifier_list_init(&blk->insert_bs_notifiers); 346 QLIST_INIT(&blk->aio_notifiers); 347 348 QTAILQ_INSERT_TAIL(&block_backends, blk, link); 349 return blk; 350 } 351 352 /* 353 * Creates a new BlockBackend, opens a new BlockDriverState, and connects both. 354 * The new BlockBackend is in the main AioContext. 355 * 356 * Just as with bdrv_open(), after having called this function the reference to 357 * @options belongs to the block layer (even on failure). 358 * 359 * TODO: Remove @filename and @flags; it should be possible to specify a whole 360 * BDS tree just by specifying the @options QDict (or @reference, 361 * alternatively). At the time of adding this function, this is not possible, 362 * though, so callers of this function have to be able to specify @filename and 363 * @flags. 364 */ 365 BlockBackend *blk_new_open(const char *filename, const char *reference, 366 QDict *options, int flags, Error **errp) 367 { 368 BlockBackend *blk; 369 BlockDriverState *bs; 370 uint64_t perm = 0; 371 372 /* blk_new_open() is mainly used in .bdrv_create implementations and the 373 * tools where sharing isn't a concern because the BDS stays private, so we 374 * just request permission according to the flags. 375 * 376 * The exceptions are xen_disk and blockdev_init(); in these cases, the 377 * caller of blk_new_open() doesn't make use of the permissions, but they 378 * shouldn't hurt either. We can still share everything here because the 379 * guest devices will add their own blockers if they can't share. */ 380 if ((flags & BDRV_O_NO_IO) == 0) { 381 perm |= BLK_PERM_CONSISTENT_READ; 382 if (flags & BDRV_O_RDWR) { 383 perm |= BLK_PERM_WRITE; 384 } 385 } 386 if (flags & BDRV_O_RESIZE) { 387 perm |= BLK_PERM_RESIZE; 388 } 389 390 blk = blk_new(qemu_get_aio_context(), perm, BLK_PERM_ALL); 391 bs = bdrv_open(filename, reference, options, flags, errp); 392 if (!bs) { 393 blk_unref(blk); 394 return NULL; 395 } 396 397 blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk->ctx, 398 perm, BLK_PERM_ALL, blk, errp); 399 if (!blk->root) { 400 blk_unref(blk); 401 return NULL; 402 } 403 404 return blk; 405 } 406 407 static void blk_delete(BlockBackend *blk) 408 { 409 assert(!blk->refcnt); 410 assert(!blk->name); 411 assert(!blk->dev); 412 if (blk->public.throttle_group_member.throttle_state) { 413 blk_io_limits_disable(blk); 414 } 415 if (blk->root) { 416 blk_remove_bs(blk); 417 } 418 if (blk->vmsh) { 419 qemu_del_vm_change_state_handler(blk->vmsh); 420 blk->vmsh = NULL; 421 } 422 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers)); 423 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers)); 424 assert(QLIST_EMPTY(&blk->aio_notifiers)); 425 QTAILQ_REMOVE(&block_backends, blk, link); 426 drive_info_del(blk->legacy_dinfo); 427 block_acct_cleanup(&blk->stats); 428 g_free(blk); 429 } 430 431 static void drive_info_del(DriveInfo *dinfo) 432 { 433 if (!dinfo) { 434 return; 435 } 436 qemu_opts_del(dinfo->opts); 437 g_free(dinfo); 438 } 439 440 int blk_get_refcnt(BlockBackend *blk) 441 { 442 return blk ? blk->refcnt : 0; 443 } 444 445 /* 446 * Increment @blk's reference count. 447 * @blk must not be null. 448 */ 449 void blk_ref(BlockBackend *blk) 450 { 451 assert(blk->refcnt > 0); 452 blk->refcnt++; 453 } 454 455 /* 456 * Decrement @blk's reference count. 457 * If this drops it to zero, destroy @blk. 458 * For convenience, do nothing if @blk is null. 459 */ 460 void blk_unref(BlockBackend *blk) 461 { 462 if (blk) { 463 assert(blk->refcnt > 0); 464 if (blk->refcnt > 1) { 465 blk->refcnt--; 466 } else { 467 blk_drain(blk); 468 /* blk_drain() cannot resurrect blk, nobody held a reference */ 469 assert(blk->refcnt == 1); 470 blk->refcnt = 0; 471 blk_delete(blk); 472 } 473 } 474 } 475 476 /* 477 * Behaves similarly to blk_next() but iterates over all BlockBackends, even the 478 * ones which are hidden (i.e. are not referenced by the monitor). 479 */ 480 BlockBackend *blk_all_next(BlockBackend *blk) 481 { 482 return blk ? QTAILQ_NEXT(blk, link) 483 : QTAILQ_FIRST(&block_backends); 484 } 485 486 void blk_remove_all_bs(void) 487 { 488 BlockBackend *blk = NULL; 489 490 while ((blk = blk_all_next(blk)) != NULL) { 491 AioContext *ctx = blk_get_aio_context(blk); 492 493 aio_context_acquire(ctx); 494 if (blk->root) { 495 blk_remove_bs(blk); 496 } 497 aio_context_release(ctx); 498 } 499 } 500 501 /* 502 * Return the monitor-owned BlockBackend after @blk. 503 * If @blk is null, return the first one. 504 * Else, return @blk's next sibling, which may be null. 505 * 506 * To iterate over all BlockBackends, do 507 * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 508 * ... 509 * } 510 */ 511 BlockBackend *blk_next(BlockBackend *blk) 512 { 513 return blk ? QTAILQ_NEXT(blk, monitor_link) 514 : QTAILQ_FIRST(&monitor_block_backends); 515 } 516 517 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by 518 * the monitor or attached to a BlockBackend */ 519 BlockDriverState *bdrv_next(BdrvNextIterator *it) 520 { 521 BlockDriverState *bs, *old_bs; 522 523 /* Must be called from the main loop */ 524 assert(qemu_get_current_aio_context() == qemu_get_aio_context()); 525 526 /* First, return all root nodes of BlockBackends. In order to avoid 527 * returning a BDS twice when multiple BBs refer to it, we only return it 528 * if the BB is the first one in the parent list of the BDS. */ 529 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) { 530 BlockBackend *old_blk = it->blk; 531 532 old_bs = old_blk ? blk_bs(old_blk) : NULL; 533 534 do { 535 it->blk = blk_all_next(it->blk); 536 bs = it->blk ? blk_bs(it->blk) : NULL; 537 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk)); 538 539 if (it->blk) { 540 blk_ref(it->blk); 541 } 542 blk_unref(old_blk); 543 544 if (bs) { 545 bdrv_ref(bs); 546 bdrv_unref(old_bs); 547 return bs; 548 } 549 it->phase = BDRV_NEXT_MONITOR_OWNED; 550 } else { 551 old_bs = it->bs; 552 } 553 554 /* Then return the monitor-owned BDSes without a BB attached. Ignore all 555 * BDSes that are attached to a BlockBackend here; they have been handled 556 * by the above block already */ 557 do { 558 it->bs = bdrv_next_monitor_owned(it->bs); 559 bs = it->bs; 560 } while (bs && bdrv_has_blk(bs)); 561 562 if (bs) { 563 bdrv_ref(bs); 564 } 565 bdrv_unref(old_bs); 566 567 return bs; 568 } 569 570 static void bdrv_next_reset(BdrvNextIterator *it) 571 { 572 *it = (BdrvNextIterator) { 573 .phase = BDRV_NEXT_BACKEND_ROOTS, 574 }; 575 } 576 577 BlockDriverState *bdrv_first(BdrvNextIterator *it) 578 { 579 bdrv_next_reset(it); 580 return bdrv_next(it); 581 } 582 583 /* Must be called when aborting a bdrv_next() iteration before 584 * bdrv_next() returns NULL */ 585 void bdrv_next_cleanup(BdrvNextIterator *it) 586 { 587 /* Must be called from the main loop */ 588 assert(qemu_get_current_aio_context() == qemu_get_aio_context()); 589 590 if (it->phase == BDRV_NEXT_BACKEND_ROOTS) { 591 if (it->blk) { 592 bdrv_unref(blk_bs(it->blk)); 593 blk_unref(it->blk); 594 } 595 } else { 596 bdrv_unref(it->bs); 597 } 598 599 bdrv_next_reset(it); 600 } 601 602 /* 603 * Add a BlockBackend into the list of backends referenced by the monitor, with 604 * the given @name acting as the handle for the monitor. 605 * Strictly for use by blockdev.c. 606 * 607 * @name must not be null or empty. 608 * 609 * Returns true on success and false on failure. In the latter case, an Error 610 * object is returned through @errp. 611 */ 612 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp) 613 { 614 assert(!blk->name); 615 assert(name && name[0]); 616 617 if (!id_wellformed(name)) { 618 error_setg(errp, "Invalid device name"); 619 return false; 620 } 621 if (blk_by_name(name)) { 622 error_setg(errp, "Device with id '%s' already exists", name); 623 return false; 624 } 625 if (bdrv_find_node(name)) { 626 error_setg(errp, 627 "Device name '%s' conflicts with an existing node name", 628 name); 629 return false; 630 } 631 632 blk->name = g_strdup(name); 633 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link); 634 return true; 635 } 636 637 /* 638 * Remove a BlockBackend from the list of backends referenced by the monitor. 639 * Strictly for use by blockdev.c. 640 */ 641 void monitor_remove_blk(BlockBackend *blk) 642 { 643 if (!blk->name) { 644 return; 645 } 646 647 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link); 648 g_free(blk->name); 649 blk->name = NULL; 650 } 651 652 /* 653 * Return @blk's name, a non-null string. 654 * Returns an empty string iff @blk is not referenced by the monitor. 655 */ 656 const char *blk_name(const BlockBackend *blk) 657 { 658 return blk->name ?: ""; 659 } 660 661 /* 662 * Return the BlockBackend with name @name if it exists, else null. 663 * @name must not be null. 664 */ 665 BlockBackend *blk_by_name(const char *name) 666 { 667 BlockBackend *blk = NULL; 668 669 assert(name); 670 while ((blk = blk_next(blk)) != NULL) { 671 if (!strcmp(name, blk->name)) { 672 return blk; 673 } 674 } 675 return NULL; 676 } 677 678 /* 679 * Return the BlockDriverState attached to @blk if any, else null. 680 */ 681 BlockDriverState *blk_bs(BlockBackend *blk) 682 { 683 return blk->root ? blk->root->bs : NULL; 684 } 685 686 static BlockBackend *bdrv_first_blk(BlockDriverState *bs) 687 { 688 BdrvChild *child; 689 QLIST_FOREACH(child, &bs->parents, next_parent) { 690 if (child->role == &child_root) { 691 return child->opaque; 692 } 693 } 694 695 return NULL; 696 } 697 698 /* 699 * Returns true if @bs has an associated BlockBackend. 700 */ 701 bool bdrv_has_blk(BlockDriverState *bs) 702 { 703 return bdrv_first_blk(bs) != NULL; 704 } 705 706 /* 707 * Returns true if @bs has only BlockBackends as parents. 708 */ 709 bool bdrv_is_root_node(BlockDriverState *bs) 710 { 711 BdrvChild *c; 712 713 QLIST_FOREACH(c, &bs->parents, next_parent) { 714 if (c->role != &child_root) { 715 return false; 716 } 717 } 718 719 return true; 720 } 721 722 /* 723 * Return @blk's DriveInfo if any, else null. 724 */ 725 DriveInfo *blk_legacy_dinfo(BlockBackend *blk) 726 { 727 return blk->legacy_dinfo; 728 } 729 730 /* 731 * Set @blk's DriveInfo to @dinfo, and return it. 732 * @blk must not have a DriveInfo set already. 733 * No other BlockBackend may have the same DriveInfo set. 734 */ 735 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo) 736 { 737 assert(!blk->legacy_dinfo); 738 return blk->legacy_dinfo = dinfo; 739 } 740 741 /* 742 * Return the BlockBackend with DriveInfo @dinfo. 743 * It must exist. 744 */ 745 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo) 746 { 747 BlockBackend *blk = NULL; 748 749 while ((blk = blk_next(blk)) != NULL) { 750 if (blk->legacy_dinfo == dinfo) { 751 return blk; 752 } 753 } 754 abort(); 755 } 756 757 /* 758 * Returns a pointer to the publicly accessible fields of @blk. 759 */ 760 BlockBackendPublic *blk_get_public(BlockBackend *blk) 761 { 762 return &blk->public; 763 } 764 765 /* 766 * Returns a BlockBackend given the associated @public fields. 767 */ 768 BlockBackend *blk_by_public(BlockBackendPublic *public) 769 { 770 return container_of(public, BlockBackend, public); 771 } 772 773 /* 774 * Disassociates the currently associated BlockDriverState from @blk. 775 */ 776 void blk_remove_bs(BlockBackend *blk) 777 { 778 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; 779 BlockDriverState *bs; 780 781 notifier_list_notify(&blk->remove_bs_notifiers, blk); 782 if (tgm->throttle_state) { 783 bs = blk_bs(blk); 784 bdrv_drained_begin(bs); 785 throttle_group_detach_aio_context(tgm); 786 throttle_group_attach_aio_context(tgm, qemu_get_aio_context()); 787 bdrv_drained_end(bs); 788 } 789 790 blk_update_root_state(blk); 791 792 /* bdrv_root_unref_child() will cause blk->root to become stale and may 793 * switch to a completion coroutine later on. Let's drain all I/O here 794 * to avoid that and a potential QEMU crash. 795 */ 796 blk_drain(blk); 797 bdrv_root_unref_child(blk->root); 798 blk->root = NULL; 799 } 800 801 /* 802 * Associates a new BlockDriverState with @blk. 803 */ 804 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp) 805 { 806 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; 807 bdrv_ref(bs); 808 blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk->ctx, 809 blk->perm, blk->shared_perm, blk, errp); 810 if (blk->root == NULL) { 811 return -EPERM; 812 } 813 814 notifier_list_notify(&blk->insert_bs_notifiers, blk); 815 if (tgm->throttle_state) { 816 throttle_group_detach_aio_context(tgm); 817 throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs)); 818 } 819 820 return 0; 821 } 822 823 /* 824 * Sets the permission bitmasks that the user of the BlockBackend needs. 825 */ 826 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm, 827 Error **errp) 828 { 829 int ret; 830 831 if (blk->root && !blk->disable_perm) { 832 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp); 833 if (ret < 0) { 834 return ret; 835 } 836 } 837 838 blk->perm = perm; 839 blk->shared_perm = shared_perm; 840 841 return 0; 842 } 843 844 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm) 845 { 846 *perm = blk->perm; 847 *shared_perm = blk->shared_perm; 848 } 849 850 /* 851 * Attach device model @dev to @blk. 852 * Return 0 on success, -EBUSY when a device model is attached already. 853 */ 854 int blk_attach_dev(BlockBackend *blk, DeviceState *dev) 855 { 856 if (blk->dev) { 857 return -EBUSY; 858 } 859 860 /* While migration is still incoming, we don't need to apply the 861 * permissions of guest device BlockBackends. We might still have a block 862 * job or NBD server writing to the image for storage migration. */ 863 if (runstate_check(RUN_STATE_INMIGRATE)) { 864 blk->disable_perm = true; 865 } 866 867 blk_ref(blk); 868 blk->dev = dev; 869 blk_iostatus_reset(blk); 870 871 return 0; 872 } 873 874 /* 875 * Detach device model @dev from @blk. 876 * @dev must be currently attached to @blk. 877 */ 878 void blk_detach_dev(BlockBackend *blk, DeviceState *dev) 879 { 880 assert(blk->dev == dev); 881 blk->dev = NULL; 882 blk->dev_ops = NULL; 883 blk->dev_opaque = NULL; 884 blk->guest_block_size = 512; 885 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort); 886 blk_unref(blk); 887 } 888 889 /* 890 * Return the device model attached to @blk if any, else null. 891 */ 892 DeviceState *blk_get_attached_dev(BlockBackend *blk) 893 { 894 return blk->dev; 895 } 896 897 /* Return the qdev ID, or if no ID is assigned the QOM path, of the block 898 * device attached to the BlockBackend. */ 899 char *blk_get_attached_dev_id(BlockBackend *blk) 900 { 901 DeviceState *dev = blk->dev; 902 903 if (!dev) { 904 return g_strdup(""); 905 } else if (dev->id) { 906 return g_strdup(dev->id); 907 } 908 909 return object_get_canonical_path(OBJECT(dev)) ?: g_strdup(""); 910 } 911 912 /* 913 * Return the BlockBackend which has the device model @dev attached if it 914 * exists, else null. 915 * 916 * @dev must not be null. 917 */ 918 BlockBackend *blk_by_dev(void *dev) 919 { 920 BlockBackend *blk = NULL; 921 922 assert(dev != NULL); 923 while ((blk = blk_all_next(blk)) != NULL) { 924 if (blk->dev == dev) { 925 return blk; 926 } 927 } 928 return NULL; 929 } 930 931 /* 932 * Set @blk's device model callbacks to @ops. 933 * @opaque is the opaque argument to pass to the callbacks. 934 * This is for use by device models. 935 */ 936 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, 937 void *opaque) 938 { 939 blk->dev_ops = ops; 940 blk->dev_opaque = opaque; 941 942 /* Are we currently quiesced? Should we enforce this right now? */ 943 if (blk->quiesce_counter && ops->drained_begin) { 944 ops->drained_begin(opaque); 945 } 946 } 947 948 /* 949 * Notify @blk's attached device model of media change. 950 * 951 * If @load is true, notify of media load. This action can fail, meaning that 952 * the medium cannot be loaded. @errp is set then. 953 * 954 * If @load is false, notify of media eject. This can never fail. 955 * 956 * Also send DEVICE_TRAY_MOVED events as appropriate. 957 */ 958 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp) 959 { 960 if (blk->dev_ops && blk->dev_ops->change_media_cb) { 961 bool tray_was_open, tray_is_open; 962 Error *local_err = NULL; 963 964 tray_was_open = blk_dev_is_tray_open(blk); 965 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err); 966 if (local_err) { 967 assert(load == true); 968 error_propagate(errp, local_err); 969 return; 970 } 971 tray_is_open = blk_dev_is_tray_open(blk); 972 973 if (tray_was_open != tray_is_open) { 974 char *id = blk_get_attached_dev_id(blk); 975 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open); 976 g_free(id); 977 } 978 } 979 } 980 981 static void blk_root_change_media(BdrvChild *child, bool load) 982 { 983 blk_dev_change_media_cb(child->opaque, load, NULL); 984 } 985 986 /* 987 * Does @blk's attached device model have removable media? 988 * %true if no device model is attached. 989 */ 990 bool blk_dev_has_removable_media(BlockBackend *blk) 991 { 992 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb); 993 } 994 995 /* 996 * Does @blk's attached device model have a tray? 997 */ 998 bool blk_dev_has_tray(BlockBackend *blk) 999 { 1000 return blk->dev_ops && blk->dev_ops->is_tray_open; 1001 } 1002 1003 /* 1004 * Notify @blk's attached device model of a media eject request. 1005 * If @force is true, the medium is about to be yanked out forcefully. 1006 */ 1007 void blk_dev_eject_request(BlockBackend *blk, bool force) 1008 { 1009 if (blk->dev_ops && blk->dev_ops->eject_request_cb) { 1010 blk->dev_ops->eject_request_cb(blk->dev_opaque, force); 1011 } 1012 } 1013 1014 /* 1015 * Does @blk's attached device model have a tray, and is it open? 1016 */ 1017 bool blk_dev_is_tray_open(BlockBackend *blk) 1018 { 1019 if (blk_dev_has_tray(blk)) { 1020 return blk->dev_ops->is_tray_open(blk->dev_opaque); 1021 } 1022 return false; 1023 } 1024 1025 /* 1026 * Does @blk's attached device model have the medium locked? 1027 * %false if the device model has no such lock. 1028 */ 1029 bool blk_dev_is_medium_locked(BlockBackend *blk) 1030 { 1031 if (blk->dev_ops && blk->dev_ops->is_medium_locked) { 1032 return blk->dev_ops->is_medium_locked(blk->dev_opaque); 1033 } 1034 return false; 1035 } 1036 1037 /* 1038 * Notify @blk's attached device model of a backend size change. 1039 */ 1040 static void blk_root_resize(BdrvChild *child) 1041 { 1042 BlockBackend *blk = child->opaque; 1043 1044 if (blk->dev_ops && blk->dev_ops->resize_cb) { 1045 blk->dev_ops->resize_cb(blk->dev_opaque); 1046 } 1047 } 1048 1049 void blk_iostatus_enable(BlockBackend *blk) 1050 { 1051 blk->iostatus_enabled = true; 1052 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 1053 } 1054 1055 /* The I/O status is only enabled if the drive explicitly 1056 * enables it _and_ the VM is configured to stop on errors */ 1057 bool blk_iostatus_is_enabled(const BlockBackend *blk) 1058 { 1059 return (blk->iostatus_enabled && 1060 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC || 1061 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP || 1062 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP)); 1063 } 1064 1065 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk) 1066 { 1067 return blk->iostatus; 1068 } 1069 1070 void blk_iostatus_disable(BlockBackend *blk) 1071 { 1072 blk->iostatus_enabled = false; 1073 } 1074 1075 void blk_iostatus_reset(BlockBackend *blk) 1076 { 1077 if (blk_iostatus_is_enabled(blk)) { 1078 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 1079 } 1080 } 1081 1082 void blk_iostatus_set_err(BlockBackend *blk, int error) 1083 { 1084 assert(blk_iostatus_is_enabled(blk)); 1085 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 1086 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 1087 BLOCK_DEVICE_IO_STATUS_FAILED; 1088 } 1089 } 1090 1091 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow) 1092 { 1093 blk->allow_write_beyond_eof = allow; 1094 } 1095 1096 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow) 1097 { 1098 blk->allow_aio_context_change = allow; 1099 } 1100 1101 static int blk_check_byte_request(BlockBackend *blk, int64_t offset, 1102 size_t size) 1103 { 1104 int64_t len; 1105 1106 if (size > INT_MAX) { 1107 return -EIO; 1108 } 1109 1110 if (!blk_is_available(blk)) { 1111 return -ENOMEDIUM; 1112 } 1113 1114 if (offset < 0) { 1115 return -EIO; 1116 } 1117 1118 if (!blk->allow_write_beyond_eof) { 1119 len = blk_getlength(blk); 1120 if (len < 0) { 1121 return len; 1122 } 1123 1124 if (offset > len || len - offset < size) { 1125 return -EIO; 1126 } 1127 } 1128 1129 return 0; 1130 } 1131 1132 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset, 1133 unsigned int bytes, QEMUIOVector *qiov, 1134 BdrvRequestFlags flags) 1135 { 1136 int ret; 1137 BlockDriverState *bs = blk_bs(blk); 1138 1139 trace_blk_co_preadv(blk, bs, offset, bytes, flags); 1140 1141 ret = blk_check_byte_request(blk, offset, bytes); 1142 if (ret < 0) { 1143 return ret; 1144 } 1145 1146 bdrv_inc_in_flight(bs); 1147 1148 /* throttling disk I/O */ 1149 if (blk->public.throttle_group_member.throttle_state) { 1150 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, 1151 bytes, false); 1152 } 1153 1154 ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags); 1155 bdrv_dec_in_flight(bs); 1156 return ret; 1157 } 1158 1159 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, 1160 unsigned int bytes, QEMUIOVector *qiov, 1161 BdrvRequestFlags flags) 1162 { 1163 int ret; 1164 BlockDriverState *bs = blk_bs(blk); 1165 1166 trace_blk_co_pwritev(blk, bs, offset, bytes, flags); 1167 1168 ret = blk_check_byte_request(blk, offset, bytes); 1169 if (ret < 0) { 1170 return ret; 1171 } 1172 1173 bdrv_inc_in_flight(bs); 1174 /* throttling disk I/O */ 1175 if (blk->public.throttle_group_member.throttle_state) { 1176 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, 1177 bytes, true); 1178 } 1179 1180 if (!blk->enable_write_cache) { 1181 flags |= BDRV_REQ_FUA; 1182 } 1183 1184 ret = bdrv_co_pwritev(blk->root, offset, bytes, qiov, flags); 1185 bdrv_dec_in_flight(bs); 1186 return ret; 1187 } 1188 1189 typedef struct BlkRwCo { 1190 BlockBackend *blk; 1191 int64_t offset; 1192 void *iobuf; 1193 int ret; 1194 BdrvRequestFlags flags; 1195 } BlkRwCo; 1196 1197 static void blk_read_entry(void *opaque) 1198 { 1199 BlkRwCo *rwco = opaque; 1200 QEMUIOVector *qiov = rwco->iobuf; 1201 1202 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, qiov->size, 1203 qiov, rwco->flags); 1204 aio_wait_kick(); 1205 } 1206 1207 static void blk_write_entry(void *opaque) 1208 { 1209 BlkRwCo *rwco = opaque; 1210 QEMUIOVector *qiov = rwco->iobuf; 1211 1212 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, qiov->size, 1213 qiov, rwco->flags); 1214 aio_wait_kick(); 1215 } 1216 1217 static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf, 1218 int64_t bytes, CoroutineEntry co_entry, 1219 BdrvRequestFlags flags) 1220 { 1221 QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); 1222 BlkRwCo rwco = { 1223 .blk = blk, 1224 .offset = offset, 1225 .iobuf = &qiov, 1226 .flags = flags, 1227 .ret = NOT_DONE, 1228 }; 1229 1230 if (qemu_in_coroutine()) { 1231 /* Fast-path if already in coroutine context */ 1232 co_entry(&rwco); 1233 } else { 1234 Coroutine *co = qemu_coroutine_create(co_entry, &rwco); 1235 bdrv_coroutine_enter(blk_bs(blk), co); 1236 BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE); 1237 } 1238 1239 return rwco.ret; 1240 } 1241 1242 int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf, 1243 int count) 1244 { 1245 int ret; 1246 1247 ret = blk_check_byte_request(blk, offset, count); 1248 if (ret < 0) { 1249 return ret; 1250 } 1251 1252 blk_root_drained_begin(blk->root); 1253 ret = blk_pread(blk, offset, buf, count); 1254 blk_root_drained_end(blk->root, NULL); 1255 return ret; 1256 } 1257 1258 int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset, 1259 int bytes, BdrvRequestFlags flags) 1260 { 1261 return blk_prw(blk, offset, NULL, bytes, blk_write_entry, 1262 flags | BDRV_REQ_ZERO_WRITE); 1263 } 1264 1265 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags) 1266 { 1267 return bdrv_make_zero(blk->root, flags); 1268 } 1269 1270 void blk_inc_in_flight(BlockBackend *blk) 1271 { 1272 atomic_inc(&blk->in_flight); 1273 } 1274 1275 void blk_dec_in_flight(BlockBackend *blk) 1276 { 1277 atomic_dec(&blk->in_flight); 1278 aio_wait_kick(); 1279 } 1280 1281 static void error_callback_bh(void *opaque) 1282 { 1283 struct BlockBackendAIOCB *acb = opaque; 1284 1285 blk_dec_in_flight(acb->blk); 1286 acb->common.cb(acb->common.opaque, acb->ret); 1287 qemu_aio_unref(acb); 1288 } 1289 1290 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk, 1291 BlockCompletionFunc *cb, 1292 void *opaque, int ret) 1293 { 1294 struct BlockBackendAIOCB *acb; 1295 1296 blk_inc_in_flight(blk); 1297 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque); 1298 acb->blk = blk; 1299 acb->ret = ret; 1300 1301 aio_bh_schedule_oneshot(blk_get_aio_context(blk), error_callback_bh, acb); 1302 return &acb->common; 1303 } 1304 1305 typedef struct BlkAioEmAIOCB { 1306 BlockAIOCB common; 1307 BlkRwCo rwco; 1308 int bytes; 1309 bool has_returned; 1310 } BlkAioEmAIOCB; 1311 1312 static const AIOCBInfo blk_aio_em_aiocb_info = { 1313 .aiocb_size = sizeof(BlkAioEmAIOCB), 1314 }; 1315 1316 static void blk_aio_complete(BlkAioEmAIOCB *acb) 1317 { 1318 if (acb->has_returned) { 1319 acb->common.cb(acb->common.opaque, acb->rwco.ret); 1320 blk_dec_in_flight(acb->rwco.blk); 1321 qemu_aio_unref(acb); 1322 } 1323 } 1324 1325 static void blk_aio_complete_bh(void *opaque) 1326 { 1327 BlkAioEmAIOCB *acb = opaque; 1328 assert(acb->has_returned); 1329 blk_aio_complete(acb); 1330 } 1331 1332 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes, 1333 void *iobuf, CoroutineEntry co_entry, 1334 BdrvRequestFlags flags, 1335 BlockCompletionFunc *cb, void *opaque) 1336 { 1337 BlkAioEmAIOCB *acb; 1338 Coroutine *co; 1339 1340 blk_inc_in_flight(blk); 1341 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); 1342 acb->rwco = (BlkRwCo) { 1343 .blk = blk, 1344 .offset = offset, 1345 .iobuf = iobuf, 1346 .flags = flags, 1347 .ret = NOT_DONE, 1348 }; 1349 acb->bytes = bytes; 1350 acb->has_returned = false; 1351 1352 co = qemu_coroutine_create(co_entry, acb); 1353 bdrv_coroutine_enter(blk_bs(blk), co); 1354 1355 acb->has_returned = true; 1356 if (acb->rwco.ret != NOT_DONE) { 1357 aio_bh_schedule_oneshot(blk_get_aio_context(blk), 1358 blk_aio_complete_bh, acb); 1359 } 1360 1361 return &acb->common; 1362 } 1363 1364 static void blk_aio_read_entry(void *opaque) 1365 { 1366 BlkAioEmAIOCB *acb = opaque; 1367 BlkRwCo *rwco = &acb->rwco; 1368 QEMUIOVector *qiov = rwco->iobuf; 1369 1370 assert(qiov->size == acb->bytes); 1371 rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes, 1372 qiov, rwco->flags); 1373 blk_aio_complete(acb); 1374 } 1375 1376 static void blk_aio_write_entry(void *opaque) 1377 { 1378 BlkAioEmAIOCB *acb = opaque; 1379 BlkRwCo *rwco = &acb->rwco; 1380 QEMUIOVector *qiov = rwco->iobuf; 1381 1382 assert(!qiov || qiov->size == acb->bytes); 1383 rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes, 1384 qiov, rwco->flags); 1385 blk_aio_complete(acb); 1386 } 1387 1388 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset, 1389 int count, BdrvRequestFlags flags, 1390 BlockCompletionFunc *cb, void *opaque) 1391 { 1392 return blk_aio_prwv(blk, offset, count, NULL, blk_aio_write_entry, 1393 flags | BDRV_REQ_ZERO_WRITE, cb, opaque); 1394 } 1395 1396 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count) 1397 { 1398 int ret = blk_prw(blk, offset, buf, count, blk_read_entry, 0); 1399 if (ret < 0) { 1400 return ret; 1401 } 1402 return count; 1403 } 1404 1405 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count, 1406 BdrvRequestFlags flags) 1407 { 1408 int ret = blk_prw(blk, offset, (void *) buf, count, blk_write_entry, 1409 flags); 1410 if (ret < 0) { 1411 return ret; 1412 } 1413 return count; 1414 } 1415 1416 int64_t blk_getlength(BlockBackend *blk) 1417 { 1418 if (!blk_is_available(blk)) { 1419 return -ENOMEDIUM; 1420 } 1421 1422 return bdrv_getlength(blk_bs(blk)); 1423 } 1424 1425 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr) 1426 { 1427 if (!blk_bs(blk)) { 1428 *nb_sectors_ptr = 0; 1429 } else { 1430 bdrv_get_geometry(blk_bs(blk), nb_sectors_ptr); 1431 } 1432 } 1433 1434 int64_t blk_nb_sectors(BlockBackend *blk) 1435 { 1436 if (!blk_is_available(blk)) { 1437 return -ENOMEDIUM; 1438 } 1439 1440 return bdrv_nb_sectors(blk_bs(blk)); 1441 } 1442 1443 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset, 1444 QEMUIOVector *qiov, BdrvRequestFlags flags, 1445 BlockCompletionFunc *cb, void *opaque) 1446 { 1447 return blk_aio_prwv(blk, offset, qiov->size, qiov, 1448 blk_aio_read_entry, flags, cb, opaque); 1449 } 1450 1451 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset, 1452 QEMUIOVector *qiov, BdrvRequestFlags flags, 1453 BlockCompletionFunc *cb, void *opaque) 1454 { 1455 return blk_aio_prwv(blk, offset, qiov->size, qiov, 1456 blk_aio_write_entry, flags, cb, opaque); 1457 } 1458 1459 static void blk_aio_flush_entry(void *opaque) 1460 { 1461 BlkAioEmAIOCB *acb = opaque; 1462 BlkRwCo *rwco = &acb->rwco; 1463 1464 rwco->ret = blk_co_flush(rwco->blk); 1465 blk_aio_complete(acb); 1466 } 1467 1468 BlockAIOCB *blk_aio_flush(BlockBackend *blk, 1469 BlockCompletionFunc *cb, void *opaque) 1470 { 1471 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque); 1472 } 1473 1474 static void blk_aio_pdiscard_entry(void *opaque) 1475 { 1476 BlkAioEmAIOCB *acb = opaque; 1477 BlkRwCo *rwco = &acb->rwco; 1478 1479 rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, acb->bytes); 1480 blk_aio_complete(acb); 1481 } 1482 1483 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, 1484 int64_t offset, int bytes, 1485 BlockCompletionFunc *cb, void *opaque) 1486 { 1487 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0, 1488 cb, opaque); 1489 } 1490 1491 void blk_aio_cancel(BlockAIOCB *acb) 1492 { 1493 bdrv_aio_cancel(acb); 1494 } 1495 1496 void blk_aio_cancel_async(BlockAIOCB *acb) 1497 { 1498 bdrv_aio_cancel_async(acb); 1499 } 1500 1501 int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf) 1502 { 1503 if (!blk_is_available(blk)) { 1504 return -ENOMEDIUM; 1505 } 1506 1507 return bdrv_co_ioctl(blk_bs(blk), req, buf); 1508 } 1509 1510 static void blk_ioctl_entry(void *opaque) 1511 { 1512 BlkRwCo *rwco = opaque; 1513 QEMUIOVector *qiov = rwco->iobuf; 1514 1515 rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset, 1516 qiov->iov[0].iov_base); 1517 aio_wait_kick(); 1518 } 1519 1520 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf) 1521 { 1522 return blk_prw(blk, req, buf, 0, blk_ioctl_entry, 0); 1523 } 1524 1525 static void blk_aio_ioctl_entry(void *opaque) 1526 { 1527 BlkAioEmAIOCB *acb = opaque; 1528 BlkRwCo *rwco = &acb->rwco; 1529 1530 rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset, rwco->iobuf); 1531 1532 blk_aio_complete(acb); 1533 } 1534 1535 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, 1536 BlockCompletionFunc *cb, void *opaque) 1537 { 1538 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque); 1539 } 1540 1541 int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes) 1542 { 1543 int ret = blk_check_byte_request(blk, offset, bytes); 1544 if (ret < 0) { 1545 return ret; 1546 } 1547 1548 return bdrv_co_pdiscard(blk->root, offset, bytes); 1549 } 1550 1551 int blk_co_flush(BlockBackend *blk) 1552 { 1553 if (!blk_is_available(blk)) { 1554 return -ENOMEDIUM; 1555 } 1556 1557 return bdrv_co_flush(blk_bs(blk)); 1558 } 1559 1560 static void blk_flush_entry(void *opaque) 1561 { 1562 BlkRwCo *rwco = opaque; 1563 rwco->ret = blk_co_flush(rwco->blk); 1564 aio_wait_kick(); 1565 } 1566 1567 int blk_flush(BlockBackend *blk) 1568 { 1569 return blk_prw(blk, 0, NULL, 0, blk_flush_entry, 0); 1570 } 1571 1572 void blk_drain(BlockBackend *blk) 1573 { 1574 BlockDriverState *bs = blk_bs(blk); 1575 1576 if (bs) { 1577 bdrv_drained_begin(bs); 1578 } 1579 1580 /* We may have -ENOMEDIUM completions in flight */ 1581 AIO_WAIT_WHILE(blk_get_aio_context(blk), 1582 atomic_mb_read(&blk->in_flight) > 0); 1583 1584 if (bs) { 1585 bdrv_drained_end(bs); 1586 } 1587 } 1588 1589 void blk_drain_all(void) 1590 { 1591 BlockBackend *blk = NULL; 1592 1593 bdrv_drain_all_begin(); 1594 1595 while ((blk = blk_all_next(blk)) != NULL) { 1596 AioContext *ctx = blk_get_aio_context(blk); 1597 1598 aio_context_acquire(ctx); 1599 1600 /* We may have -ENOMEDIUM completions in flight */ 1601 AIO_WAIT_WHILE(ctx, atomic_mb_read(&blk->in_flight) > 0); 1602 1603 aio_context_release(ctx); 1604 } 1605 1606 bdrv_drain_all_end(); 1607 } 1608 1609 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error, 1610 BlockdevOnError on_write_error) 1611 { 1612 blk->on_read_error = on_read_error; 1613 blk->on_write_error = on_write_error; 1614 } 1615 1616 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read) 1617 { 1618 return is_read ? blk->on_read_error : blk->on_write_error; 1619 } 1620 1621 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read, 1622 int error) 1623 { 1624 BlockdevOnError on_err = blk_get_on_error(blk, is_read); 1625 1626 switch (on_err) { 1627 case BLOCKDEV_ON_ERROR_ENOSPC: 1628 return (error == ENOSPC) ? 1629 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; 1630 case BLOCKDEV_ON_ERROR_STOP: 1631 return BLOCK_ERROR_ACTION_STOP; 1632 case BLOCKDEV_ON_ERROR_REPORT: 1633 return BLOCK_ERROR_ACTION_REPORT; 1634 case BLOCKDEV_ON_ERROR_IGNORE: 1635 return BLOCK_ERROR_ACTION_IGNORE; 1636 case BLOCKDEV_ON_ERROR_AUTO: 1637 default: 1638 abort(); 1639 } 1640 } 1641 1642 static void send_qmp_error_event(BlockBackend *blk, 1643 BlockErrorAction action, 1644 bool is_read, int error) 1645 { 1646 IoOperationType optype; 1647 BlockDriverState *bs = blk_bs(blk); 1648 1649 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE; 1650 qapi_event_send_block_io_error(blk_name(blk), !!bs, 1651 bs ? bdrv_get_node_name(bs) : NULL, optype, 1652 action, blk_iostatus_is_enabled(blk), 1653 error == ENOSPC, strerror(error)); 1654 } 1655 1656 /* This is done by device models because, while the block layer knows 1657 * about the error, it does not know whether an operation comes from 1658 * the device or the block layer (from a job, for example). 1659 */ 1660 void blk_error_action(BlockBackend *blk, BlockErrorAction action, 1661 bool is_read, int error) 1662 { 1663 assert(error >= 0); 1664 1665 if (action == BLOCK_ERROR_ACTION_STOP) { 1666 /* First set the iostatus, so that "info block" returns an iostatus 1667 * that matches the events raised so far (an additional error iostatus 1668 * is fine, but not a lost one). 1669 */ 1670 blk_iostatus_set_err(blk, error); 1671 1672 /* Then raise the request to stop the VM and the event. 1673 * qemu_system_vmstop_request_prepare has two effects. First, 1674 * it ensures that the STOP event always comes after the 1675 * BLOCK_IO_ERROR event. Second, it ensures that even if management 1676 * can observe the STOP event and do a "cont" before the STOP 1677 * event is issued, the VM will not stop. In this case, vm_start() 1678 * also ensures that the STOP/RESUME pair of events is emitted. 1679 */ 1680 qemu_system_vmstop_request_prepare(); 1681 send_qmp_error_event(blk, action, is_read, error); 1682 qemu_system_vmstop_request(RUN_STATE_IO_ERROR); 1683 } else { 1684 send_qmp_error_event(blk, action, is_read, error); 1685 } 1686 } 1687 1688 bool blk_is_read_only(BlockBackend *blk) 1689 { 1690 BlockDriverState *bs = blk_bs(blk); 1691 1692 if (bs) { 1693 return bdrv_is_read_only(bs); 1694 } else { 1695 return blk->root_state.read_only; 1696 } 1697 } 1698 1699 bool blk_is_sg(BlockBackend *blk) 1700 { 1701 BlockDriverState *bs = blk_bs(blk); 1702 1703 if (!bs) { 1704 return false; 1705 } 1706 1707 return bdrv_is_sg(bs); 1708 } 1709 1710 bool blk_enable_write_cache(BlockBackend *blk) 1711 { 1712 return blk->enable_write_cache; 1713 } 1714 1715 void blk_set_enable_write_cache(BlockBackend *blk, bool wce) 1716 { 1717 blk->enable_write_cache = wce; 1718 } 1719 1720 void blk_invalidate_cache(BlockBackend *blk, Error **errp) 1721 { 1722 BlockDriverState *bs = blk_bs(blk); 1723 1724 if (!bs) { 1725 error_setg(errp, "Device '%s' has no medium", blk->name); 1726 return; 1727 } 1728 1729 bdrv_invalidate_cache(bs, errp); 1730 } 1731 1732 bool blk_is_inserted(BlockBackend *blk) 1733 { 1734 BlockDriverState *bs = blk_bs(blk); 1735 1736 return bs && bdrv_is_inserted(bs); 1737 } 1738 1739 bool blk_is_available(BlockBackend *blk) 1740 { 1741 return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk); 1742 } 1743 1744 void blk_lock_medium(BlockBackend *blk, bool locked) 1745 { 1746 BlockDriverState *bs = blk_bs(blk); 1747 1748 if (bs) { 1749 bdrv_lock_medium(bs, locked); 1750 } 1751 } 1752 1753 void blk_eject(BlockBackend *blk, bool eject_flag) 1754 { 1755 BlockDriverState *bs = blk_bs(blk); 1756 char *id; 1757 1758 if (bs) { 1759 bdrv_eject(bs, eject_flag); 1760 } 1761 1762 /* Whether or not we ejected on the backend, 1763 * the frontend experienced a tray event. */ 1764 id = blk_get_attached_dev_id(blk); 1765 qapi_event_send_device_tray_moved(blk_name(blk), id, 1766 eject_flag); 1767 g_free(id); 1768 } 1769 1770 int blk_get_flags(BlockBackend *blk) 1771 { 1772 BlockDriverState *bs = blk_bs(blk); 1773 1774 if (bs) { 1775 return bdrv_get_flags(bs); 1776 } else { 1777 return blk->root_state.open_flags; 1778 } 1779 } 1780 1781 /* Returns the minimum request alignment, in bytes; guaranteed nonzero */ 1782 uint32_t blk_get_request_alignment(BlockBackend *blk) 1783 { 1784 BlockDriverState *bs = blk_bs(blk); 1785 return bs ? bs->bl.request_alignment : BDRV_SECTOR_SIZE; 1786 } 1787 1788 /* Returns the maximum transfer length, in bytes; guaranteed nonzero */ 1789 uint32_t blk_get_max_transfer(BlockBackend *blk) 1790 { 1791 BlockDriverState *bs = blk_bs(blk); 1792 uint32_t max = 0; 1793 1794 if (bs) { 1795 max = bs->bl.max_transfer; 1796 } 1797 return MIN_NON_ZERO(max, INT_MAX); 1798 } 1799 1800 int blk_get_max_iov(BlockBackend *blk) 1801 { 1802 return blk->root->bs->bl.max_iov; 1803 } 1804 1805 void blk_set_guest_block_size(BlockBackend *blk, int align) 1806 { 1807 blk->guest_block_size = align; 1808 } 1809 1810 void *blk_try_blockalign(BlockBackend *blk, size_t size) 1811 { 1812 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size); 1813 } 1814 1815 void *blk_blockalign(BlockBackend *blk, size_t size) 1816 { 1817 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size); 1818 } 1819 1820 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp) 1821 { 1822 BlockDriverState *bs = blk_bs(blk); 1823 1824 if (!bs) { 1825 return false; 1826 } 1827 1828 return bdrv_op_is_blocked(bs, op, errp); 1829 } 1830 1831 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason) 1832 { 1833 BlockDriverState *bs = blk_bs(blk); 1834 1835 if (bs) { 1836 bdrv_op_unblock(bs, op, reason); 1837 } 1838 } 1839 1840 void blk_op_block_all(BlockBackend *blk, Error *reason) 1841 { 1842 BlockDriverState *bs = blk_bs(blk); 1843 1844 if (bs) { 1845 bdrv_op_block_all(bs, reason); 1846 } 1847 } 1848 1849 void blk_op_unblock_all(BlockBackend *blk, Error *reason) 1850 { 1851 BlockDriverState *bs = blk_bs(blk); 1852 1853 if (bs) { 1854 bdrv_op_unblock_all(bs, reason); 1855 } 1856 } 1857 1858 AioContext *blk_get_aio_context(BlockBackend *blk) 1859 { 1860 BlockDriverState *bs = blk_bs(blk); 1861 1862 if (bs) { 1863 AioContext *ctx = bdrv_get_aio_context(blk_bs(blk)); 1864 assert(ctx == blk->ctx); 1865 } 1866 1867 return blk->ctx; 1868 } 1869 1870 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb) 1871 { 1872 BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb); 1873 return blk_get_aio_context(blk_acb->blk); 1874 } 1875 1876 static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context, 1877 bool update_root_node, Error **errp) 1878 { 1879 BlockDriverState *bs = blk_bs(blk); 1880 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; 1881 int ret; 1882 1883 if (bs) { 1884 if (update_root_node) { 1885 ret = bdrv_child_try_set_aio_context(bs, new_context, blk->root, 1886 errp); 1887 if (ret < 0) { 1888 return ret; 1889 } 1890 } 1891 if (tgm->throttle_state) { 1892 bdrv_drained_begin(bs); 1893 throttle_group_detach_aio_context(tgm); 1894 throttle_group_attach_aio_context(tgm, new_context); 1895 bdrv_drained_end(bs); 1896 } 1897 } 1898 1899 blk->ctx = new_context; 1900 return 0; 1901 } 1902 1903 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context, 1904 Error **errp) 1905 { 1906 return blk_do_set_aio_context(blk, new_context, true, errp); 1907 } 1908 1909 static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx, 1910 GSList **ignore, Error **errp) 1911 { 1912 BlockBackend *blk = child->opaque; 1913 1914 if (blk->allow_aio_context_change) { 1915 return true; 1916 } 1917 1918 /* Only manually created BlockBackends that are not attached to anything 1919 * can change their AioContext without updating their user. */ 1920 if (!blk->name || blk->dev) { 1921 /* TODO Add BB name/QOM path */ 1922 error_setg(errp, "Cannot change iothread of active block backend"); 1923 return false; 1924 } 1925 1926 return true; 1927 } 1928 1929 static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx, 1930 GSList **ignore) 1931 { 1932 BlockBackend *blk = child->opaque; 1933 blk_do_set_aio_context(blk, ctx, false, &error_abort); 1934 } 1935 1936 void blk_add_aio_context_notifier(BlockBackend *blk, 1937 void (*attached_aio_context)(AioContext *new_context, void *opaque), 1938 void (*detach_aio_context)(void *opaque), void *opaque) 1939 { 1940 BlockBackendAioNotifier *notifier; 1941 BlockDriverState *bs = blk_bs(blk); 1942 1943 notifier = g_new(BlockBackendAioNotifier, 1); 1944 notifier->attached_aio_context = attached_aio_context; 1945 notifier->detach_aio_context = detach_aio_context; 1946 notifier->opaque = opaque; 1947 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list); 1948 1949 if (bs) { 1950 bdrv_add_aio_context_notifier(bs, attached_aio_context, 1951 detach_aio_context, opaque); 1952 } 1953 } 1954 1955 void blk_remove_aio_context_notifier(BlockBackend *blk, 1956 void (*attached_aio_context)(AioContext *, 1957 void *), 1958 void (*detach_aio_context)(void *), 1959 void *opaque) 1960 { 1961 BlockBackendAioNotifier *notifier; 1962 BlockDriverState *bs = blk_bs(blk); 1963 1964 if (bs) { 1965 bdrv_remove_aio_context_notifier(bs, attached_aio_context, 1966 detach_aio_context, opaque); 1967 } 1968 1969 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { 1970 if (notifier->attached_aio_context == attached_aio_context && 1971 notifier->detach_aio_context == detach_aio_context && 1972 notifier->opaque == opaque) { 1973 QLIST_REMOVE(notifier, list); 1974 g_free(notifier); 1975 return; 1976 } 1977 } 1978 1979 abort(); 1980 } 1981 1982 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify) 1983 { 1984 notifier_list_add(&blk->remove_bs_notifiers, notify); 1985 } 1986 1987 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify) 1988 { 1989 notifier_list_add(&blk->insert_bs_notifiers, notify); 1990 } 1991 1992 void blk_io_plug(BlockBackend *blk) 1993 { 1994 BlockDriverState *bs = blk_bs(blk); 1995 1996 if (bs) { 1997 bdrv_io_plug(bs); 1998 } 1999 } 2000 2001 void blk_io_unplug(BlockBackend *blk) 2002 { 2003 BlockDriverState *bs = blk_bs(blk); 2004 2005 if (bs) { 2006 bdrv_io_unplug(bs); 2007 } 2008 } 2009 2010 BlockAcctStats *blk_get_stats(BlockBackend *blk) 2011 { 2012 return &blk->stats; 2013 } 2014 2015 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, 2016 BlockCompletionFunc *cb, void *opaque) 2017 { 2018 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque); 2019 } 2020 2021 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, 2022 int bytes, BdrvRequestFlags flags) 2023 { 2024 return blk_co_pwritev(blk, offset, bytes, NULL, 2025 flags | BDRV_REQ_ZERO_WRITE); 2026 } 2027 2028 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf, 2029 int count) 2030 { 2031 return blk_prw(blk, offset, (void *) buf, count, blk_write_entry, 2032 BDRV_REQ_WRITE_COMPRESSED); 2033 } 2034 2035 int blk_truncate(BlockBackend *blk, int64_t offset, PreallocMode prealloc, 2036 Error **errp) 2037 { 2038 if (!blk_is_available(blk)) { 2039 error_setg(errp, "No medium inserted"); 2040 return -ENOMEDIUM; 2041 } 2042 2043 return bdrv_truncate(blk->root, offset, prealloc, errp); 2044 } 2045 2046 static void blk_pdiscard_entry(void *opaque) 2047 { 2048 BlkRwCo *rwco = opaque; 2049 QEMUIOVector *qiov = rwco->iobuf; 2050 2051 rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, qiov->size); 2052 aio_wait_kick(); 2053 } 2054 2055 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes) 2056 { 2057 return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0); 2058 } 2059 2060 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, 2061 int64_t pos, int size) 2062 { 2063 int ret; 2064 2065 if (!blk_is_available(blk)) { 2066 return -ENOMEDIUM; 2067 } 2068 2069 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size); 2070 if (ret < 0) { 2071 return ret; 2072 } 2073 2074 if (ret == size && !blk->enable_write_cache) { 2075 ret = bdrv_flush(blk_bs(blk)); 2076 } 2077 2078 return ret < 0 ? ret : size; 2079 } 2080 2081 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size) 2082 { 2083 if (!blk_is_available(blk)) { 2084 return -ENOMEDIUM; 2085 } 2086 2087 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size); 2088 } 2089 2090 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz) 2091 { 2092 if (!blk_is_available(blk)) { 2093 return -ENOMEDIUM; 2094 } 2095 2096 return bdrv_probe_blocksizes(blk_bs(blk), bsz); 2097 } 2098 2099 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo) 2100 { 2101 if (!blk_is_available(blk)) { 2102 return -ENOMEDIUM; 2103 } 2104 2105 return bdrv_probe_geometry(blk_bs(blk), geo); 2106 } 2107 2108 /* 2109 * Updates the BlockBackendRootState object with data from the currently 2110 * attached BlockDriverState. 2111 */ 2112 void blk_update_root_state(BlockBackend *blk) 2113 { 2114 assert(blk->root); 2115 2116 blk->root_state.open_flags = blk->root->bs->open_flags; 2117 blk->root_state.read_only = blk->root->bs->read_only; 2118 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes; 2119 } 2120 2121 /* 2122 * Returns the detect-zeroes setting to be used for bdrv_open() of a 2123 * BlockDriverState which is supposed to inherit the root state. 2124 */ 2125 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk) 2126 { 2127 return blk->root_state.detect_zeroes; 2128 } 2129 2130 /* 2131 * Returns the flags to be used for bdrv_open() of a BlockDriverState which is 2132 * supposed to inherit the root state. 2133 */ 2134 int blk_get_open_flags_from_root_state(BlockBackend *blk) 2135 { 2136 int bs_flags; 2137 2138 bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR; 2139 bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR; 2140 2141 return bs_flags; 2142 } 2143 2144 BlockBackendRootState *blk_get_root_state(BlockBackend *blk) 2145 { 2146 return &blk->root_state; 2147 } 2148 2149 int blk_commit_all(void) 2150 { 2151 BlockBackend *blk = NULL; 2152 2153 while ((blk = blk_all_next(blk)) != NULL) { 2154 AioContext *aio_context = blk_get_aio_context(blk); 2155 2156 aio_context_acquire(aio_context); 2157 if (blk_is_inserted(blk) && blk->root->bs->backing) { 2158 int ret = bdrv_commit(blk->root->bs); 2159 if (ret < 0) { 2160 aio_context_release(aio_context); 2161 return ret; 2162 } 2163 } 2164 aio_context_release(aio_context); 2165 } 2166 return 0; 2167 } 2168 2169 2170 /* throttling disk I/O limits */ 2171 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg) 2172 { 2173 throttle_group_config(&blk->public.throttle_group_member, cfg); 2174 } 2175 2176 void blk_io_limits_disable(BlockBackend *blk) 2177 { 2178 BlockDriverState *bs = blk_bs(blk); 2179 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; 2180 assert(tgm->throttle_state); 2181 if (bs) { 2182 bdrv_drained_begin(bs); 2183 } 2184 throttle_group_unregister_tgm(tgm); 2185 if (bs) { 2186 bdrv_drained_end(bs); 2187 } 2188 } 2189 2190 /* should be called before blk_set_io_limits if a limit is set */ 2191 void blk_io_limits_enable(BlockBackend *blk, const char *group) 2192 { 2193 assert(!blk->public.throttle_group_member.throttle_state); 2194 throttle_group_register_tgm(&blk->public.throttle_group_member, 2195 group, blk_get_aio_context(blk)); 2196 } 2197 2198 void blk_io_limits_update_group(BlockBackend *blk, const char *group) 2199 { 2200 /* this BB is not part of any group */ 2201 if (!blk->public.throttle_group_member.throttle_state) { 2202 return; 2203 } 2204 2205 /* this BB is a part of the same group than the one we want */ 2206 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member), 2207 group)) { 2208 return; 2209 } 2210 2211 /* need to change the group this bs belong to */ 2212 blk_io_limits_disable(blk); 2213 blk_io_limits_enable(blk, group); 2214 } 2215 2216 static void blk_root_drained_begin(BdrvChild *child) 2217 { 2218 BlockBackend *blk = child->opaque; 2219 2220 if (++blk->quiesce_counter == 1) { 2221 if (blk->dev_ops && blk->dev_ops->drained_begin) { 2222 blk->dev_ops->drained_begin(blk->dev_opaque); 2223 } 2224 } 2225 2226 /* Note that blk->root may not be accessible here yet if we are just 2227 * attaching to a BlockDriverState that is drained. Use child instead. */ 2228 2229 if (atomic_fetch_inc(&blk->public.throttle_group_member.io_limits_disabled) == 0) { 2230 throttle_group_restart_tgm(&blk->public.throttle_group_member); 2231 } 2232 } 2233 2234 static bool blk_root_drained_poll(BdrvChild *child) 2235 { 2236 BlockBackend *blk = child->opaque; 2237 assert(blk->quiesce_counter); 2238 return !!blk->in_flight; 2239 } 2240 2241 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter) 2242 { 2243 BlockBackend *blk = child->opaque; 2244 assert(blk->quiesce_counter); 2245 2246 assert(blk->public.throttle_group_member.io_limits_disabled); 2247 atomic_dec(&blk->public.throttle_group_member.io_limits_disabled); 2248 2249 if (--blk->quiesce_counter == 0) { 2250 if (blk->dev_ops && blk->dev_ops->drained_end) { 2251 blk->dev_ops->drained_end(blk->dev_opaque); 2252 } 2253 } 2254 } 2255 2256 void blk_register_buf(BlockBackend *blk, void *host, size_t size) 2257 { 2258 bdrv_register_buf(blk_bs(blk), host, size); 2259 } 2260 2261 void blk_unregister_buf(BlockBackend *blk, void *host) 2262 { 2263 bdrv_unregister_buf(blk_bs(blk), host); 2264 } 2265 2266 int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, 2267 BlockBackend *blk_out, int64_t off_out, 2268 int bytes, BdrvRequestFlags read_flags, 2269 BdrvRequestFlags write_flags) 2270 { 2271 int r; 2272 r = blk_check_byte_request(blk_in, off_in, bytes); 2273 if (r) { 2274 return r; 2275 } 2276 r = blk_check_byte_request(blk_out, off_out, bytes); 2277 if (r) { 2278 return r; 2279 } 2280 return bdrv_co_copy_range(blk_in->root, off_in, 2281 blk_out->root, off_out, 2282 bytes, read_flags, write_flags); 2283 } 2284 2285 const BdrvChild *blk_root(BlockBackend *blk) 2286 { 2287 return blk->root; 2288 } 2289