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