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