block/block-backend.c

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