block/block-backend.c

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