block/block-backend.c

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