block/block-backend.c

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