block/block-backend.c

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