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 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,
 646                                   BlockCompletionFunc *cb,
 647                                   void *opaque, int ret)
 648 {
 649     struct BlockBackendAIOCB *acb;
 650     QEMUBH *bh;
 651
 652     acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
 653     acb->blk = blk;
 654     acb->ret = ret;
 655
 656     bh = aio_bh_new(blk_get_aio_context(blk), error_callback_bh, acb);
 657     acb->bh = bh;
 658     qemu_bh_schedule(bh);
 659
 660     return &acb->common;
 661 }
 662
 663 BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
 664                                  int nb_sectors, BdrvRequestFlags flags,
 665                                  BlockCompletionFunc *cb, void *opaque)
 666 {
 667     int ret = blk_check_request(blk, sector_num, nb_sectors);
 668     if (ret < 0) {
 669         return blk_abort_aio_request(blk, cb, opaque, ret);
 670     }
 671
 672     return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
 673                                  cb, opaque);
 674 }
 675
 676 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
 677 {
 678     int ret = blk_check_byte_request(blk, offset, count);
 679     if (ret < 0) {
 680         return ret;
 681     }
 682
 683     return bdrv_pread(blk->bs, offset, buf, count);
 684 }
 685
 686 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count)
 687 {
 688     int ret = blk_check_byte_request(blk, offset, count);
 689     if (ret < 0) {
 690         return ret;
 691     }
 692
 693     return bdrv_pwrite(blk->bs, offset, buf, count);
 694 }
 695
 696 int64_t blk_getlength(BlockBackend *blk)
 697 {
 698     if (!blk_is_available(blk)) {
 699         return -ENOMEDIUM;
 700     }
 701
 702     return bdrv_getlength(blk->bs);
 703 }
 704
 705 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
 706 {
 707     if (!blk->bs) {
 708         *nb_sectors_ptr = 0;
 709     } else {
 710         bdrv_get_geometry(blk->bs, nb_sectors_ptr);
 711     }
 712 }
 713
 714 int64_t blk_nb_sectors(BlockBackend *blk)
 715 {
 716     if (!blk_is_available(blk)) {
 717         return -ENOMEDIUM;
 718     }
 719
 720     return bdrv_nb_sectors(blk->bs);
 721 }
 722
 723 BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
 724                           QEMUIOVector *iov, int nb_sectors,
 725                           BlockCompletionFunc *cb, void *opaque)
 726 {
 727     int ret = blk_check_request(blk, sector_num, nb_sectors);
 728     if (ret < 0) {
 729         return blk_abort_aio_request(blk, cb, opaque, ret);
 730     }
 731
 732     return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 733 }
 734
 735 BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
 736                            QEMUIOVector *iov, int nb_sectors,
 737                            BlockCompletionFunc *cb, void *opaque)
 738 {
 739     int ret = blk_check_request(blk, sector_num, nb_sectors);
 740     if (ret < 0) {
 741         return blk_abort_aio_request(blk, cb, opaque, ret);
 742     }
 743
 744     return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 745 }
 746
 747 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
 748                           BlockCompletionFunc *cb, void *opaque)
 749 {
 750     if (!blk_is_available(blk)) {
 751         return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
 752     }
 753
 754     return bdrv_aio_flush(blk->bs, cb, opaque);
 755 }
 756
 757 BlockAIOCB *blk_aio_discard(BlockBackend *blk,
 758                             int64_t sector_num, int nb_sectors,
 759                             BlockCompletionFunc *cb, void *opaque)
 760 {
 761     int ret = blk_check_request(blk, sector_num, nb_sectors);
 762     if (ret < 0) {
 763         return blk_abort_aio_request(blk, cb, opaque, ret);
 764     }
 765
 766     return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
 767 }
 768
 769 void blk_aio_cancel(BlockAIOCB *acb)
 770 {
 771     bdrv_aio_cancel(acb);
 772 }
 773
 774 void blk_aio_cancel_async(BlockAIOCB *acb)
 775 {
 776     bdrv_aio_cancel_async(acb);
 777 }
 778
 779 int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
 780 {
 781     int i, ret;
 782
 783     for (i = 0; i < num_reqs; i++) {
 784         ret = blk_check_request(blk, reqs[i].sector, reqs[i].nb_sectors);
 785         if (ret < 0) {
 786             return ret;
 787         }
 788     }
 789
 790     return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
 791 }
 792
 793 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 794 {
 795     if (!blk_is_available(blk)) {
 796         return -ENOMEDIUM;
 797     }
 798
 799     return bdrv_ioctl(blk->bs, req, buf);
 800 }
 801
 802 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
 803                           BlockCompletionFunc *cb, void *opaque)
 804 {
 805     if (!blk_is_available(blk)) {
 806         return blk_abort_aio_request(blk, cb, opaque, -ENOMEDIUM);
 807     }
 808
 809     return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
 810 }
 811
 812 int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
 813 {
 814     int ret = blk_check_request(blk, sector_num, nb_sectors);
 815     if (ret < 0) {
 816         return ret;
 817     }
 818
 819     return bdrv_co_discard(blk->bs, sector_num, nb_sectors);
 820 }
 821
 822 int blk_co_flush(BlockBackend *blk)
 823 {
 824     if (!blk_is_available(blk)) {
 825         return -ENOMEDIUM;
 826     }
 827
 828     return bdrv_co_flush(blk->bs);
 829 }
 830
 831 int blk_flush(BlockBackend *blk)
 832 {
 833     if (!blk_is_available(blk)) {
 834         return -ENOMEDIUM;
 835     }
 836
 837     return bdrv_flush(blk->bs);
 838 }
 839
 840 int blk_flush_all(void)
 841 {
 842     return bdrv_flush_all();
 843 }
 844
 845 void blk_drain(BlockBackend *blk)
 846 {
 847     if (blk->bs) {
 848         bdrv_drain(blk->bs);
 849     }
 850 }
 851
 852 void blk_drain_all(void)
 853 {
 854     bdrv_drain_all();
 855 }
 856
 857 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
 858                       BlockdevOnError on_write_error)
 859 {
 860     blk->on_read_error = on_read_error;
 861     blk->on_write_error = on_write_error;
 862 }
 863
 864 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
 865 {
 866     return is_read ? blk->on_read_error : blk->on_write_error;
 867 }
 868
 869 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
 870                                       int error)
 871 {
 872     BlockdevOnError on_err = blk_get_on_error(blk, is_read);
 873
 874     switch (on_err) {
 875     case BLOCKDEV_ON_ERROR_ENOSPC:
 876         return (error == ENOSPC) ?
 877                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
 878     case BLOCKDEV_ON_ERROR_STOP:
 879         return BLOCK_ERROR_ACTION_STOP;
 880     case BLOCKDEV_ON_ERROR_REPORT:
 881         return BLOCK_ERROR_ACTION_REPORT;
 882     case BLOCKDEV_ON_ERROR_IGNORE:
 883         return BLOCK_ERROR_ACTION_IGNORE;
 884     default:
 885         abort();
 886     }
 887 }
 888
 889 static void send_qmp_error_event(BlockBackend *blk,
 890                                  BlockErrorAction action,
 891                                  bool is_read, int error)
 892 {
 893     IoOperationType optype;
 894
 895     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
 896     qapi_event_send_block_io_error(blk_name(blk), optype, action,
 897                                    blk_iostatus_is_enabled(blk),
 898                                    error == ENOSPC, strerror(error),
 899                                    &error_abort);
 900 }
 901
 902 /* This is done by device models because, while the block layer knows
 903  * about the error, it does not know whether an operation comes from
 904  * the device or the block layer (from a job, for example).
 905  */
 906 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
 907                       bool is_read, int error)
 908 {
 909     assert(error >= 0);
 910
 911     if (action == BLOCK_ERROR_ACTION_STOP) {
 912         /* First set the iostatus, so that "info block" returns an iostatus
 913          * that matches the events raised so far (an additional error iostatus
 914          * is fine, but not a lost one).
 915          */
 916         blk_iostatus_set_err(blk, error);
 917
 918         /* Then raise the request to stop the VM and the event.
 919          * qemu_system_vmstop_request_prepare has two effects.  First,
 920          * it ensures that the STOP event always comes after the
 921          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
 922          * can observe the STOP event and do a "cont" before the STOP
 923          * event is issued, the VM will not stop.  In this case, vm_start()
 924          * also ensures that the STOP/RESUME pair of events is emitted.
 925          */
 926         qemu_system_vmstop_request_prepare();
 927         send_qmp_error_event(blk, action, is_read, error);
 928         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
 929     } else {
 930         send_qmp_error_event(blk, action, is_read, error);
 931     }
 932 }
 933
 934 int blk_is_read_only(BlockBackend *blk)
 935 {
 936     if (blk->bs) {
 937         return bdrv_is_read_only(blk->bs);
 938     } else {
 939         return blk->root_state.read_only;
 940     }
 941 }
 942
 943 int blk_is_sg(BlockBackend *blk)
 944 {
 945     if (!blk->bs) {
 946         return 0;
 947     }
 948
 949     return bdrv_is_sg(blk->bs);
 950 }
 951
 952 int blk_enable_write_cache(BlockBackend *blk)
 953 {
 954     if (blk->bs) {
 955         return bdrv_enable_write_cache(blk->bs);
 956     } else {
 957         return !!(blk->root_state.open_flags & BDRV_O_CACHE_WB);
 958     }
 959 }
 960
 961 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
 962 {
 963     if (blk->bs) {
 964         bdrv_set_enable_write_cache(blk->bs, wce);
 965     } else {
 966         if (wce) {
 967             blk->root_state.open_flags |= BDRV_O_CACHE_WB;
 968         } else {
 969             blk->root_state.open_flags &= ~BDRV_O_CACHE_WB;
 970         }
 971     }
 972 }
 973
 974 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
 975 {
 976     if (!blk->bs) {
 977         error_setg(errp, "Device '%s' has no medium", blk->name);
 978         return;
 979     }
 980
 981     bdrv_invalidate_cache(blk->bs, errp);
 982 }
 983
 984 bool blk_is_inserted(BlockBackend *blk)
 985 {
 986     return blk->bs && bdrv_is_inserted(blk->bs);
 987 }
 988
 989 bool blk_is_available(BlockBackend *blk)
 990 {
 991     return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
 992 }
 993
 994 void blk_lock_medium(BlockBackend *blk, bool locked)
 995 {
 996     if (blk->bs) {
 997         bdrv_lock_medium(blk->bs, locked);
 998     }
 999 }
1000
1001 void blk_eject(BlockBackend *blk, bool eject_flag)
1002 {
1003     if (blk->bs) {
1004         bdrv_eject(blk->bs, eject_flag);
1005     }
1006 }
1007
1008 int blk_get_flags(BlockBackend *blk)
1009 {
1010     if (blk->bs) {
1011         return bdrv_get_flags(blk->bs);
1012     } else {
1013         return blk->root_state.open_flags;
1014     }
1015 }
1016
1017 int blk_get_max_transfer_length(BlockBackend *blk)
1018 {
1019     if (blk->bs) {
1020         return blk->bs->bl.max_transfer_length;
1021     } else {
1022         return 0;
1023     }
1024 }
1025
1026 int blk_get_max_iov(BlockBackend *blk)
1027 {
1028     return blk->bs->bl.max_iov;
1029 }
1030
1031 void blk_set_guest_block_size(BlockBackend *blk, int align)
1032 {
1033     blk->guest_block_size = align;
1034 }
1035
1036 void *blk_blockalign(BlockBackend *blk, size_t size)
1037 {
1038     return qemu_blockalign(blk ? blk->bs : NULL, size);
1039 }
1040
1041 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
1042 {
1043     if (!blk->bs) {
1044         return false;
1045     }
1046
1047     return bdrv_op_is_blocked(blk->bs, op, errp);
1048 }
1049
1050 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
1051 {
1052     if (blk->bs) {
1053         bdrv_op_unblock(blk->bs, op, reason);
1054     }
1055 }
1056
1057 void blk_op_block_all(BlockBackend *blk, Error *reason)
1058 {
1059     if (blk->bs) {
1060         bdrv_op_block_all(blk->bs, reason);
1061     }
1062 }
1063
1064 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
1065 {
1066     if (blk->bs) {
1067         bdrv_op_unblock_all(blk->bs, reason);
1068     }
1069 }
1070
1071 AioContext *blk_get_aio_context(BlockBackend *blk)
1072 {
1073     if (blk->bs) {
1074         return bdrv_get_aio_context(blk->bs);
1075     } else {
1076         return qemu_get_aio_context();
1077     }
1078 }
1079
1080 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
1081 {
1082     BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
1083     return blk_get_aio_context(blk_acb->blk);
1084 }
1085
1086 void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
1087 {
1088     if (blk->bs) {
1089         bdrv_set_aio_context(blk->bs, new_context);
1090     }
1091 }
1092
1093 void blk_add_aio_context_notifier(BlockBackend *blk,
1094         void (*attached_aio_context)(AioContext *new_context, void *opaque),
1095         void (*detach_aio_context)(void *opaque), void *opaque)
1096 {
1097     if (blk->bs) {
1098         bdrv_add_aio_context_notifier(blk->bs, attached_aio_context,
1099                                       detach_aio_context, opaque);
1100     }
1101 }
1102
1103 void blk_remove_aio_context_notifier(BlockBackend *blk,
1104                                      void (*attached_aio_context)(AioContext *,
1105                                                                   void *),
1106                                      void (*detach_aio_context)(void *),
1107                                      void *opaque)
1108 {
1109     if (blk->bs) {
1110         bdrv_remove_aio_context_notifier(blk->bs, attached_aio_context,
1111                                          detach_aio_context, opaque);
1112     }
1113 }
1114
1115 void blk_add_close_notifier(BlockBackend *blk, Notifier *notify)
1116 {
1117     if (blk->bs) {
1118         bdrv_add_close_notifier(blk->bs, notify);
1119     }
1120 }
1121
1122 void blk_io_plug(BlockBackend *blk)
1123 {
1124     if (blk->bs) {
1125         bdrv_io_plug(blk->bs);
1126     }
1127 }
1128
1129 void blk_io_unplug(BlockBackend *blk)
1130 {
1131     if (blk->bs) {
1132         bdrv_io_unplug(blk->bs);
1133     }
1134 }
1135
1136 BlockAcctStats *blk_get_stats(BlockBackend *blk)
1137 {
1138     return &blk->stats;
1139 }
1140
1141 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
1142                   BlockCompletionFunc *cb, void *opaque)
1143 {
1144     return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
1145 }
1146
1147 int coroutine_fn blk_co_write_zeroes(BlockBackend *blk, int64_t sector_num,
1148                                      int nb_sectors, BdrvRequestFlags flags)
1149 {
1150     int ret = blk_check_request(blk, sector_num, nb_sectors);
1151     if (ret < 0) {
1152         return ret;
1153     }
1154
1155     return bdrv_co_write_zeroes(blk->bs, sector_num, nb_sectors, flags);
1156 }
1157
1158 int blk_write_compressed(BlockBackend *blk, int64_t sector_num,
1159                          const uint8_t *buf, int nb_sectors)
1160 {
1161     int ret = blk_check_request(blk, sector_num, nb_sectors);
1162     if (ret < 0) {
1163         return ret;
1164     }
1165
1166     return bdrv_write_compressed(blk->bs, sector_num, buf, nb_sectors);
1167 }
1168
1169 int blk_truncate(BlockBackend *blk, int64_t offset)
1170 {
1171     if (!blk_is_available(blk)) {
1172         return -ENOMEDIUM;
1173     }
1174
1175     return bdrv_truncate(blk->bs, offset);
1176 }
1177
1178 int blk_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
1179 {
1180     int ret = blk_check_request(blk, sector_num, nb_sectors);
1181     if (ret < 0) {
1182         return ret;
1183     }
1184
1185     return bdrv_discard(blk->bs, sector_num, nb_sectors);
1186 }
1187
1188 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
1189                      int64_t pos, int size)
1190 {
1191     if (!blk_is_available(blk)) {
1192         return -ENOMEDIUM;
1193     }
1194
1195     return bdrv_save_vmstate(blk->bs, buf, pos, size);
1196 }
1197
1198 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
1199 {
1200     if (!blk_is_available(blk)) {
1201         return -ENOMEDIUM;
1202     }
1203
1204     return bdrv_load_vmstate(blk->bs, buf, pos, size);
1205 }
1206
1207 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
1208 {
1209     if (!blk_is_available(blk)) {
1210         return -ENOMEDIUM;
1211     }
1212
1213     return bdrv_probe_blocksizes(blk->bs, bsz);
1214 }
1215
1216 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
1217 {
1218     if (!blk_is_available(blk)) {
1219         return -ENOMEDIUM;
1220     }
1221
1222     return bdrv_probe_geometry(blk->bs, geo);
1223 }
1224
1225 /*
1226  * Updates the BlockBackendRootState object with data from the currently
1227  * attached BlockDriverState.
1228  */
1229 void blk_update_root_state(BlockBackend *blk)
1230 {
1231     assert(blk->bs);
1232
1233     blk->root_state.open_flags    = blk->bs->open_flags;
1234     blk->root_state.read_only     = blk->bs->read_only;
1235     blk->root_state.detect_zeroes = blk->bs->detect_zeroes;
1236
1237     if (blk->root_state.throttle_group) {
1238         g_free(blk->root_state.throttle_group);
1239         throttle_group_unref(blk->root_state.throttle_state);
1240     }
1241     if (blk->bs->throttle_state) {
1242         const char *name = throttle_group_get_name(blk->bs);
1243         blk->root_state.throttle_group = g_strdup(name);
1244         blk->root_state.throttle_state = throttle_group_incref(name);
1245     } else {
1246         blk->root_state.throttle_group = NULL;
1247         blk->root_state.throttle_state = NULL;
1248     }
1249 }
1250
1251 /*
1252  * Applies the information in the root state to the given BlockDriverState. This
1253  * does not include the flags which have to be specified for bdrv_open(), use
1254  * blk_get_open_flags_from_root_state() to inquire them.
1255  */
1256 void blk_apply_root_state(BlockBackend *blk, BlockDriverState *bs)
1257 {
1258     bs->detect_zeroes = blk->root_state.detect_zeroes;
1259     if (blk->root_state.throttle_group) {
1260         bdrv_io_limits_enable(bs, blk->root_state.throttle_group);
1261     }
1262 }
1263
1264 /*
1265  * Returns the flags to be used for bdrv_open() of a BlockDriverState which is
1266  * supposed to inherit the root state.
1267  */
1268 int blk_get_open_flags_from_root_state(BlockBackend *blk)
1269 {
1270     int bs_flags;
1271
1272     bs_flags = blk->root_state.read_only ? 0 : BDRV_O_RDWR;
1273     bs_flags |= blk->root_state.open_flags & ~BDRV_O_RDWR;
1274
1275     return bs_flags;
1276 }
1277
1278 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
1279 {
1280     return &blk->root_state;
1281 }