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