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     g_free(blk);
 180 }
 181
 182 static void drive_info_del(DriveInfo *dinfo)
 183 {
 184     if (!dinfo) {
 185         return;
 186     }
 187     qemu_opts_del(dinfo->opts);
 188     g_free(dinfo->serial);
 189     g_free(dinfo);
 190 }
 191
 192 /*
 193  * Increment @blk's reference count.
 194  * @blk must not be null.
 195  */
 196 void blk_ref(BlockBackend *blk)
 197 {
 198     blk->refcnt++;
 199 }
 200
 201 /*
 202  * Decrement @blk's reference count.
 203  * If this drops it to zero, destroy @blk.
 204  * For convenience, do nothing if @blk is null.
 205  */
 206 void blk_unref(BlockBackend *blk)
 207 {
 208     if (blk) {
 209         assert(blk->refcnt > 0);
 210         if (!--blk->refcnt) {
 211             blk_delete(blk);
 212         }
 213     }
 214 }
 215
 216 /*
 217  * Return the BlockBackend after @blk.
 218  * If @blk is null, return the first one.
 219  * Else, return @blk's next sibling, which may be null.
 220  *
 221  * To iterate over all BlockBackends, do
 222  * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
 223  *     ...
 224  * }
 225  */
 226 BlockBackend *blk_next(BlockBackend *blk)
 227 {
 228     return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends);
 229 }
 230
 231 /*
 232  * Return @blk's name, a non-null string.
 233  * Wart: the name is empty iff @blk has been hidden with
 234  * blk_hide_on_behalf_of_hmp_drive_del().
 235  */
 236 const char *blk_name(BlockBackend *blk)
 237 {
 238     return blk->name;
 239 }
 240
 241 /*
 242  * Return the BlockBackend with name @name if it exists, else null.
 243  * @name must not be null.
 244  */
 245 BlockBackend *blk_by_name(const char *name)
 246 {
 247     BlockBackend *blk;
 248
 249     assert(name);
 250     QTAILQ_FOREACH(blk, &blk_backends, link) {
 251         if (!strcmp(name, blk->name)) {
 252             return blk;
 253         }
 254     }
 255     return NULL;
 256 }
 257
 258 /*
 259  * Return the BlockDriverState attached to @blk if any, else null.
 260  */
 261 BlockDriverState *blk_bs(BlockBackend *blk)
 262 {
 263     return blk->bs;
 264 }
 265
 266 /*
 267  * Changes the BlockDriverState attached to @blk
 268  */
 269 void blk_set_bs(BlockBackend *blk, BlockDriverState *bs)
 270 {
 271     bdrv_ref(bs);
 272
 273     if (blk->bs) {
 274         blk->bs->blk = NULL;
 275         bdrv_unref(blk->bs);
 276     }
 277     assert(bs->blk == NULL);
 278
 279     blk->bs = bs;
 280     bs->blk = blk;
 281 }
 282
 283 /*
 284  * Return @blk's DriveInfo if any, else null.
 285  */
 286 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
 287 {
 288     return blk->legacy_dinfo;
 289 }
 290
 291 /*
 292  * Set @blk's DriveInfo to @dinfo, and return it.
 293  * @blk must not have a DriveInfo set already.
 294  * No other BlockBackend may have the same DriveInfo set.
 295  */
 296 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
 297 {
 298     assert(!blk->legacy_dinfo);
 299     return blk->legacy_dinfo = dinfo;
 300 }
 301
 302 /*
 303  * Return the BlockBackend with DriveInfo @dinfo.
 304  * It must exist.
 305  */
 306 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
 307 {
 308     BlockBackend *blk;
 309
 310     QTAILQ_FOREACH(blk, &blk_backends, link) {
 311         if (blk->legacy_dinfo == dinfo) {
 312             return blk;
 313         }
 314     }
 315     abort();
 316 }
 317
 318 /*
 319  * Hide @blk.
 320  * @blk must not have been hidden already.
 321  * Make attached BlockDriverState, if any, anonymous.
 322  * Once hidden, @blk is invisible to all functions that don't receive
 323  * it as argument.  For example, blk_by_name() won't return it.
 324  * Strictly for use by do_drive_del().
 325  * TODO get rid of it!
 326  */
 327 void blk_hide_on_behalf_of_hmp_drive_del(BlockBackend *blk)
 328 {
 329     QTAILQ_REMOVE(&blk_backends, blk, link);
 330     blk->name[0] = 0;
 331     if (blk->bs) {
 332         bdrv_make_anon(blk->bs);
 333     }
 334 }
 335
 336 /*
 337  * Attach device model @dev to @blk.
 338  * Return 0 on success, -EBUSY when a device model is attached already.
 339  */
 340 int blk_attach_dev(BlockBackend *blk, void *dev)
 341 /* TODO change to DeviceState *dev when all users are qdevified */
 342 {
 343     if (blk->dev) {
 344         return -EBUSY;
 345     }
 346     blk_ref(blk);
 347     blk->dev = dev;
 348     blk_iostatus_reset(blk);
 349     return 0;
 350 }
 351
 352 /*
 353  * Attach device model @dev to @blk.
 354  * @blk must not have a device model attached already.
 355  * TODO qdevified devices don't use this, remove when devices are qdevified
 356  */
 357 void blk_attach_dev_nofail(BlockBackend *blk, void *dev)
 358 {
 359     if (blk_attach_dev(blk, dev) < 0) {
 360         abort();
 361     }
 362 }
 363
 364 /*
 365  * Detach device model @dev from @blk.
 366  * @dev must be currently attached to @blk.
 367  */
 368 void blk_detach_dev(BlockBackend *blk, void *dev)
 369 /* TODO change to DeviceState *dev when all users are qdevified */
 370 {
 371     assert(blk->dev == dev);
 372     blk->dev = NULL;
 373     blk->dev_ops = NULL;
 374     blk->dev_opaque = NULL;
 375     blk->guest_block_size = 512;
 376     blk_unref(blk);
 377 }
 378
 379 /*
 380  * Return the device model attached to @blk if any, else null.
 381  */
 382 void *blk_get_attached_dev(BlockBackend *blk)
 383 /* TODO change to return DeviceState * when all users are qdevified */
 384 {
 385     return blk->dev;
 386 }
 387
 388 /*
 389  * Set @blk's device model callbacks to @ops.
 390  * @opaque is the opaque argument to pass to the callbacks.
 391  * This is for use by device models.
 392  */
 393 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
 394                      void *opaque)
 395 {
 396     blk->dev_ops = ops;
 397     blk->dev_opaque = opaque;
 398 }
 399
 400 /*
 401  * Notify @blk's attached device model of media change.
 402  * If @load is true, notify of media load.
 403  * Else, notify of media eject.
 404  * Also send DEVICE_TRAY_MOVED events as appropriate.
 405  */
 406 void blk_dev_change_media_cb(BlockBackend *blk, bool load)
 407 {
 408     if (blk->dev_ops && blk->dev_ops->change_media_cb) {
 409         bool tray_was_closed = !blk_dev_is_tray_open(blk);
 410
 411         blk->dev_ops->change_media_cb(blk->dev_opaque, load);
 412         if (tray_was_closed) {
 413             /* tray open */
 414             qapi_event_send_device_tray_moved(blk_name(blk),
 415                                               true, &error_abort);
 416         }
 417         if (load) {
 418             /* tray close */
 419             qapi_event_send_device_tray_moved(blk_name(blk),
 420                                               false, &error_abort);
 421         }
 422     }
 423 }
 424
 425 /*
 426  * Does @blk's attached device model have removable media?
 427  * %true if no device model is attached.
 428  */
 429 bool blk_dev_has_removable_media(BlockBackend *blk)
 430 {
 431     return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
 432 }
 433
 434 /*
 435  * Notify @blk's attached device model of a media eject request.
 436  * If @force is true, the medium is about to be yanked out forcefully.
 437  */
 438 void blk_dev_eject_request(BlockBackend *blk, bool force)
 439 {
 440     if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
 441         blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
 442     }
 443 }
 444
 445 /*
 446  * Does @blk's attached device model have a tray, and is it open?
 447  */
 448 bool blk_dev_is_tray_open(BlockBackend *blk)
 449 {
 450     if (blk->dev_ops && blk->dev_ops->is_tray_open) {
 451         return blk->dev_ops->is_tray_open(blk->dev_opaque);
 452     }
 453     return false;
 454 }
 455
 456 /*
 457  * Does @blk's attached device model have the medium locked?
 458  * %false if the device model has no such lock.
 459  */
 460 bool blk_dev_is_medium_locked(BlockBackend *blk)
 461 {
 462     if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
 463         return blk->dev_ops->is_medium_locked(blk->dev_opaque);
 464     }
 465     return false;
 466 }
 467
 468 /*
 469  * Notify @blk's attached device model of a backend size change.
 470  */
 471 void blk_dev_resize_cb(BlockBackend *blk)
 472 {
 473     if (blk->dev_ops && blk->dev_ops->resize_cb) {
 474         blk->dev_ops->resize_cb(blk->dev_opaque);
 475     }
 476 }
 477
 478 void blk_iostatus_enable(BlockBackend *blk)
 479 {
 480     blk->iostatus_enabled = true;
 481     blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
 482 }
 483
 484 /* The I/O status is only enabled if the drive explicitly
 485  * enables it _and_ the VM is configured to stop on errors */
 486 bool blk_iostatus_is_enabled(const BlockBackend *blk)
 487 {
 488     return (blk->iostatus_enabled &&
 489            (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
 490             blk->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
 491             blk->on_read_error == BLOCKDEV_ON_ERROR_STOP));
 492 }
 493
 494 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk)
 495 {
 496     return blk->iostatus;
 497 }
 498
 499 void blk_iostatus_disable(BlockBackend *blk)
 500 {
 501     blk->iostatus_enabled = false;
 502 }
 503
 504 void blk_iostatus_reset(BlockBackend *blk)
 505 {
 506     if (blk_iostatus_is_enabled(blk)) {
 507         blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
 508         if (blk->bs && blk->bs->job) {
 509             block_job_iostatus_reset(blk->bs->job);
 510         }
 511     }
 512 }
 513
 514 void blk_iostatus_set_err(BlockBackend *blk, int error)
 515 {
 516     assert(blk_iostatus_is_enabled(blk));
 517     if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
 518         blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
 519                                           BLOCK_DEVICE_IO_STATUS_FAILED;
 520     }
 521 }
 522
 523 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
 524                                   size_t size)
 525 {
 526     int64_t len;
 527
 528     if (size > INT_MAX) {
 529         return -EIO;
 530     }
 531
 532     if (!blk_is_inserted(blk)) {
 533         return -ENOMEDIUM;
 534     }
 535
 536     len = blk_getlength(blk);
 537     if (len < 0) {
 538         return len;
 539     }
 540
 541     if (offset < 0) {
 542         return -EIO;
 543     }
 544
 545     if (offset > len || len - offset < size) {
 546         return -EIO;
 547     }
 548
 549     return 0;
 550 }
 551
 552 static int blk_check_request(BlockBackend *blk, int64_t sector_num,
 553                              int nb_sectors)
 554 {
 555     if (sector_num < 0 || sector_num > INT64_MAX / BDRV_SECTOR_SIZE) {
 556         return -EIO;
 557     }
 558
 559     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
 560         return -EIO;
 561     }
 562
 563     return blk_check_byte_request(blk, sector_num * BDRV_SECTOR_SIZE,
 564                                   nb_sectors * BDRV_SECTOR_SIZE);
 565 }
 566
 567 int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
 568              int nb_sectors)
 569 {
 570     int ret = blk_check_request(blk, sector_num, nb_sectors);
 571     if (ret < 0) {
 572         return ret;
 573     }
 574
 575     return bdrv_read(blk->bs, sector_num, buf, nb_sectors);
 576 }
 577
 578 int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
 579                          int nb_sectors)
 580 {
 581     int ret = blk_check_request(blk, sector_num, nb_sectors);
 582     if (ret < 0) {
 583         return ret;
 584     }
 585
 586     return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors);
 587 }
 588
 589 int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf,
 590               int nb_sectors)
 591 {
 592     int ret = blk_check_request(blk, sector_num, nb_sectors);
 593     if (ret < 0) {
 594         return ret;
 595     }
 596
 597     return bdrv_write(blk->bs, sector_num, buf, nb_sectors);
 598 }
 599
 600 int blk_write_zeroes(BlockBackend *blk, int64_t sector_num,
 601                      int nb_sectors, BdrvRequestFlags flags)
 602 {
 603     int ret = blk_check_request(blk, sector_num, nb_sectors);
 604     if (ret < 0) {
 605         return ret;
 606     }
 607
 608     return bdrv_write_zeroes(blk->bs, sector_num, nb_sectors, flags);
 609 }
 610
 611 static void error_callback_bh(void *opaque)
 612 {
 613     struct BlockBackendAIOCB *acb = opaque;
 614     qemu_bh_delete(acb->bh);
 615     acb->common.cb(acb->common.opaque, acb->ret);
 616     qemu_aio_unref(acb);
 617 }
 618
 619 static BlockAIOCB *abort_aio_request(BlockBackend *blk, BlockCompletionFunc *cb,
 620                                      void *opaque, int ret)
 621 {
 622     struct BlockBackendAIOCB *acb;
 623     QEMUBH *bh;
 624
 625     acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);
 626     acb->blk = blk;
 627     acb->ret = ret;
 628
 629     bh = aio_bh_new(blk_get_aio_context(blk), error_callback_bh, acb);
 630     acb->bh = bh;
 631     qemu_bh_schedule(bh);
 632
 633     return &acb->common;
 634 }
 635
 636 BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
 637                                  int nb_sectors, BdrvRequestFlags flags,
 638                                  BlockCompletionFunc *cb, void *opaque)
 639 {
 640     int ret = blk_check_request(blk, sector_num, nb_sectors);
 641     if (ret < 0) {
 642         return abort_aio_request(blk, cb, opaque, ret);
 643     }
 644
 645     return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
 646                                  cb, opaque);
 647 }
 648
 649 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
 650 {
 651     int ret = blk_check_byte_request(blk, offset, count);
 652     if (ret < 0) {
 653         return ret;
 654     }
 655
 656     return bdrv_pread(blk->bs, offset, buf, count);
 657 }
 658
 659 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count)
 660 {
 661     int ret = blk_check_byte_request(blk, offset, count);
 662     if (ret < 0) {
 663         return ret;
 664     }
 665
 666     return bdrv_pwrite(blk->bs, offset, buf, count);
 667 }
 668
 669 int64_t blk_getlength(BlockBackend *blk)
 670 {
 671     return bdrv_getlength(blk->bs);
 672 }
 673
 674 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
 675 {
 676     bdrv_get_geometry(blk->bs, nb_sectors_ptr);
 677 }
 678
 679 int64_t blk_nb_sectors(BlockBackend *blk)
 680 {
 681     return bdrv_nb_sectors(blk->bs);
 682 }
 683
 684 BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
 685                           QEMUIOVector *iov, int nb_sectors,
 686                           BlockCompletionFunc *cb, void *opaque)
 687 {
 688     int ret = blk_check_request(blk, sector_num, nb_sectors);
 689     if (ret < 0) {
 690         return abort_aio_request(blk, cb, opaque, ret);
 691     }
 692
 693     return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 694 }
 695
 696 BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
 697                            QEMUIOVector *iov, int nb_sectors,
 698                            BlockCompletionFunc *cb, void *opaque)
 699 {
 700     int ret = blk_check_request(blk, sector_num, nb_sectors);
 701     if (ret < 0) {
 702         return abort_aio_request(blk, cb, opaque, ret);
 703     }
 704
 705     return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 706 }
 707
 708 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
 709                           BlockCompletionFunc *cb, void *opaque)
 710 {
 711     return bdrv_aio_flush(blk->bs, cb, opaque);
 712 }
 713
 714 BlockAIOCB *blk_aio_discard(BlockBackend *blk,
 715                             int64_t sector_num, int nb_sectors,
 716                             BlockCompletionFunc *cb, void *opaque)
 717 {
 718     int ret = blk_check_request(blk, sector_num, nb_sectors);
 719     if (ret < 0) {
 720         return abort_aio_request(blk, cb, opaque, ret);
 721     }
 722
 723     return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
 724 }
 725
 726 void blk_aio_cancel(BlockAIOCB *acb)
 727 {
 728     bdrv_aio_cancel(acb);
 729 }
 730
 731 void blk_aio_cancel_async(BlockAIOCB *acb)
 732 {
 733     bdrv_aio_cancel_async(acb);
 734 }
 735
 736 int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
 737 {
 738     int i, ret;
 739
 740     for (i = 0; i < num_reqs; i++) {
 741         ret = blk_check_request(blk, reqs[i].sector, reqs[i].nb_sectors);
 742         if (ret < 0) {
 743             return ret;
 744         }
 745     }
 746
 747     return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
 748 }
 749
 750 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 751 {
 752     return bdrv_ioctl(blk->bs, req, buf);
 753 }
 754
 755 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
 756                           BlockCompletionFunc *cb, void *opaque)
 757 {
 758     return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
 759 }
 760
 761 int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
 762 {
 763     int ret = blk_check_request(blk, sector_num, nb_sectors);
 764     if (ret < 0) {
 765         return ret;
 766     }
 767
 768     return bdrv_co_discard(blk->bs, sector_num, nb_sectors);
 769 }
 770
 771 int blk_co_flush(BlockBackend *blk)
 772 {
 773     return bdrv_co_flush(blk->bs);
 774 }
 775
 776 int blk_flush(BlockBackend *blk)
 777 {
 778     return bdrv_flush(blk->bs);
 779 }
 780
 781 int blk_flush_all(void)
 782 {
 783     return bdrv_flush_all();
 784 }
 785
 786 void blk_drain(BlockBackend *blk)
 787 {
 788     bdrv_drain(blk->bs);
 789 }
 790
 791 void blk_drain_all(void)
 792 {
 793     bdrv_drain_all();
 794 }
 795
 796 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
 797                       BlockdevOnError on_write_error)
 798 {
 799     blk->on_read_error = on_read_error;
 800     blk->on_write_error = on_write_error;
 801 }
 802
 803 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
 804 {
 805     return is_read ? blk->on_read_error : blk->on_write_error;
 806 }
 807
 808 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
 809                                       int error)
 810 {
 811     BlockdevOnError on_err = blk_get_on_error(blk, is_read);
 812
 813     switch (on_err) {
 814     case BLOCKDEV_ON_ERROR_ENOSPC:
 815         return (error == ENOSPC) ?
 816                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
 817     case BLOCKDEV_ON_ERROR_STOP:
 818         return BLOCK_ERROR_ACTION_STOP;
 819     case BLOCKDEV_ON_ERROR_REPORT:
 820         return BLOCK_ERROR_ACTION_REPORT;
 821     case BLOCKDEV_ON_ERROR_IGNORE:
 822         return BLOCK_ERROR_ACTION_IGNORE;
 823     default:
 824         abort();
 825     }
 826 }
 827
 828 static void send_qmp_error_event(BlockBackend *blk,
 829                                  BlockErrorAction action,
 830                                  bool is_read, int error)
 831 {
 832     IoOperationType optype;
 833
 834     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
 835     qapi_event_send_block_io_error(blk_name(blk), optype, action,
 836                                    blk_iostatus_is_enabled(blk),
 837                                    error == ENOSPC, strerror(error),
 838                                    &error_abort);
 839 }
 840
 841 /* This is done by device models because, while the block layer knows
 842  * about the error, it does not know whether an operation comes from
 843  * the device or the block layer (from a job, for example).
 844  */
 845 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
 846                       bool is_read, int error)
 847 {
 848     assert(error >= 0);
 849
 850     if (action == BLOCK_ERROR_ACTION_STOP) {
 851         /* First set the iostatus, so that "info block" returns an iostatus
 852          * that matches the events raised so far (an additional error iostatus
 853          * is fine, but not a lost one).
 854          */
 855         blk_iostatus_set_err(blk, error);
 856
 857         /* Then raise the request to stop the VM and the event.
 858          * qemu_system_vmstop_request_prepare has two effects.  First,
 859          * it ensures that the STOP event always comes after the
 860          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
 861          * can observe the STOP event and do a "cont" before the STOP
 862          * event is issued, the VM will not stop.  In this case, vm_start()
 863          * also ensures that the STOP/RESUME pair of events is emitted.
 864          */
 865         qemu_system_vmstop_request_prepare();
 866         send_qmp_error_event(blk, action, is_read, error);
 867         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
 868     } else {
 869         send_qmp_error_event(blk, action, is_read, error);
 870     }
 871 }
 872
 873 int blk_is_read_only(BlockBackend *blk)
 874 {
 875     return bdrv_is_read_only(blk->bs);
 876 }
 877
 878 int blk_is_sg(BlockBackend *blk)
 879 {
 880     return bdrv_is_sg(blk->bs);
 881 }
 882
 883 int blk_enable_write_cache(BlockBackend *blk)
 884 {
 885     return bdrv_enable_write_cache(blk->bs);
 886 }
 887
 888 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
 889 {
 890     bdrv_set_enable_write_cache(blk->bs, wce);
 891 }
 892
 893 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
 894 {
 895     bdrv_invalidate_cache(blk->bs, errp);
 896 }
 897
 898 bool blk_is_inserted(BlockBackend *blk)
 899 {
 900     return blk->bs && bdrv_is_inserted(blk->bs);
 901 }
 902
 903 bool blk_is_available(BlockBackend *blk)
 904 {
 905     return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
 906 }
 907
 908 void blk_lock_medium(BlockBackend *blk, bool locked)
 909 {
 910     bdrv_lock_medium(blk->bs, locked);
 911 }
 912
 913 void blk_eject(BlockBackend *blk, bool eject_flag)
 914 {
 915     bdrv_eject(blk->bs, eject_flag);
 916 }
 917
 918 int blk_get_flags(BlockBackend *blk)
 919 {
 920     return bdrv_get_flags(blk->bs);
 921 }
 922
 923 int blk_get_max_transfer_length(BlockBackend *blk)
 924 {
 925     return blk->bs->bl.max_transfer_length;
 926 }
 927
 928 void blk_set_guest_block_size(BlockBackend *blk, int align)
 929 {
 930     blk->guest_block_size = align;
 931 }
 932
 933 void *blk_blockalign(BlockBackend *blk, size_t size)
 934 {
 935     return qemu_blockalign(blk ? blk->bs : NULL, size);
 936 }
 937
 938 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
 939 {
 940     return bdrv_op_is_blocked(blk->bs, op, errp);
 941 }
 942
 943 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
 944 {
 945     bdrv_op_unblock(blk->bs, op, reason);
 946 }
 947
 948 void blk_op_block_all(BlockBackend *blk, Error *reason)
 949 {
 950     bdrv_op_block_all(blk->bs, reason);
 951 }
 952
 953 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
 954 {
 955     bdrv_op_unblock_all(blk->bs, reason);
 956 }
 957
 958 AioContext *blk_get_aio_context(BlockBackend *blk)
 959 {
 960     if (blk->bs) {
 961         return bdrv_get_aio_context(blk->bs);
 962     } else {
 963         return qemu_get_aio_context();
 964     }
 965 }
 966
 967 static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)
 968 {
 969     BlockBackendAIOCB *blk_acb = DO_UPCAST(BlockBackendAIOCB, common, acb);
 970     return blk_get_aio_context(blk_acb->blk);
 971 }
 972
 973 void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
 974 {
 975     bdrv_set_aio_context(blk->bs, new_context);
 976 }
 977
 978 void blk_add_aio_context_notifier(BlockBackend *blk,
 979         void (*attached_aio_context)(AioContext *new_context, void *opaque),
 980         void (*detach_aio_context)(void *opaque), void *opaque)
 981 {
 982     bdrv_add_aio_context_notifier(blk->bs, attached_aio_context,
 983                                   detach_aio_context, opaque);
 984 }
 985
 986 void blk_remove_aio_context_notifier(BlockBackend *blk,
 987                                      void (*attached_aio_context)(AioContext *,
 988                                                                   void *),
 989                                      void (*detach_aio_context)(void *),
 990                                      void *opaque)
 991 {
 992     bdrv_remove_aio_context_notifier(blk->bs, attached_aio_context,
 993                                      detach_aio_context, opaque);
 994 }
 995
 996 void blk_add_close_notifier(BlockBackend *blk, Notifier *notify)
 997 {
 998     bdrv_add_close_notifier(blk->bs, notify);
 999 }
1000
1001 void blk_io_plug(BlockBackend *blk)
1002 {
1003     bdrv_io_plug(blk->bs);
1004 }
1005
1006 void blk_io_unplug(BlockBackend *blk)
1007 {
1008     bdrv_io_unplug(blk->bs);
1009 }
1010
1011 BlockAcctStats *blk_get_stats(BlockBackend *blk)
1012 {
1013     return &blk->stats;
1014 }
1015
1016 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
1017                   BlockCompletionFunc *cb, void *opaque)
1018 {
1019     return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
1020 }
1021
1022 int coroutine_fn blk_co_write_zeroes(BlockBackend *blk, int64_t sector_num,
1023                                      int nb_sectors, BdrvRequestFlags flags)
1024 {
1025     int ret = blk_check_request(blk, sector_num, nb_sectors);
1026     if (ret < 0) {
1027         return ret;
1028     }
1029
1030     return bdrv_co_write_zeroes(blk->bs, sector_num, nb_sectors, flags);
1031 }
1032
1033 int blk_write_compressed(BlockBackend *blk, int64_t sector_num,
1034                          const uint8_t *buf, int nb_sectors)
1035 {
1036     int ret = blk_check_request(blk, sector_num, nb_sectors);
1037     if (ret < 0) {
1038         return ret;
1039     }
1040
1041     return bdrv_write_compressed(blk->bs, sector_num, buf, nb_sectors);
1042 }
1043
1044 int blk_truncate(BlockBackend *blk, int64_t offset)
1045 {
1046     return bdrv_truncate(blk->bs, offset);
1047 }
1048
1049 int blk_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
1050 {
1051     int ret = blk_check_request(blk, sector_num, nb_sectors);
1052     if (ret < 0) {
1053         return ret;
1054     }
1055
1056     return bdrv_discard(blk->bs, sector_num, nb_sectors);
1057 }
1058
1059 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
1060                      int64_t pos, int size)
1061 {
1062     return bdrv_save_vmstate(blk->bs, buf, pos, size);
1063 }
1064
1065 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size)
1066 {
1067     return bdrv_load_vmstate(blk->bs, buf, pos, size);
1068 }
1069
1070 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz)
1071 {
1072     return bdrv_probe_blocksizes(blk->bs, bsz);
1073 }
1074
1075 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo)
1076 {
1077     return bdrv_probe_geometry(blk->bs, geo);
1078 }
1079
1080 /*
1081  * Updates the BlockBackendRootState object with data from the currently
1082  * attached BlockDriverState.
1083  */
1084 void blk_update_root_state(BlockBackend *blk)
1085 {
1086     assert(blk->bs);
1087
1088     blk->root_state.open_flags    = blk->bs->open_flags;
1089     blk->root_state.read_only     = blk->bs->read_only;
1090     blk->root_state.detect_zeroes = blk->bs->detect_zeroes;
1091
1092     if (blk->root_state.throttle_group) {
1093         g_free(blk->root_state.throttle_group);
1094         throttle_group_unref(blk->root_state.throttle_state);
1095     }
1096     if (blk->bs->throttle_state) {
1097         const char *name = throttle_group_get_name(blk->bs);
1098         blk->root_state.throttle_group = g_strdup(name);
1099         blk->root_state.throttle_state = throttle_group_incref(name);
1100     } else {
1101         blk->root_state.throttle_group = NULL;
1102         blk->root_state.throttle_state = NULL;
1103     }
1104 }
1105
1106 BlockBackendRootState *blk_get_root_state(BlockBackend *blk)
1107 {
1108     return &blk->root_state;
1109 }