block.c

   1 /*
   2  * QEMU System Emulator block driver
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "config-host.h"
  25 #include "qemu-common.h"
  26 #include "trace.h"
  27 #include "block/block_int.h"
  28 #include "block/blockjob.h"
  29 #include "qemu/module.h"
  30 #include "qapi/qmp/qjson.h"
  31 #include "sysemu/sysemu.h"
  32 #include "qemu/notify.h"
  33 #include "block/coroutine.h"
  34 #include "block/qapi.h"
  35 #include "qmp-commands.h"
  36 #include "qemu/timer.h"
  37 #include "qapi-event.h"
  38
  39 #ifdef CONFIG_BSD
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/queue.h>
  44 #ifndef __DragonFly__
  45 #include <sys/disk.h>
  46 #endif
  47 #endif
  48
  49 #ifdef _WIN32
  50 #include <windows.h>
  51 #endif
  52
  53 struct BdrvDirtyBitmap {
  54     HBitmap *bitmap;
  55     QLIST_ENTRY(BdrvDirtyBitmap) list;
  56 };
  57
  58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
  59
  60 #define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */
  61
  62 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
  63 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
  64         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  65         BlockDriverCompletionFunc *cb, void *opaque);
  66 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
  67         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
  68         BlockDriverCompletionFunc *cb, void *opaque);
  69 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
  70                                          int64_t sector_num, int nb_sectors,
  71                                          QEMUIOVector *iov);
  72 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
  73                                          int64_t sector_num, int nb_sectors,
  74                                          QEMUIOVector *iov);
  75 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
  76     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
  77     BdrvRequestFlags flags);
  78 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
  79     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
  80     BdrvRequestFlags flags);
  81 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
  82                                                int64_t sector_num,
  83                                                QEMUIOVector *qiov,
  84                                                int nb_sectors,
  85                                                BdrvRequestFlags flags,
  86                                                BlockDriverCompletionFunc *cb,
  87                                                void *opaque,
  88                                                bool is_write);
  89 static void coroutine_fn bdrv_co_do_rw(void *opaque);
  90 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
  91     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
  92
  93 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
  94     QTAILQ_HEAD_INITIALIZER(bdrv_states);
  95
  96 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
  97     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
  98
  99 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
 100     QLIST_HEAD_INITIALIZER(bdrv_drivers);
 101
 102 /* If non-zero, use only whitelisted block drivers */
 103 static int use_bdrv_whitelist;
 104
 105 #ifdef _WIN32
 106 static int is_windows_drive_prefix(const char *filename)
 107 {
 108     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
 109              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 110             filename[1] == ':');
 111 }
 112
 113 int is_windows_drive(const char *filename)
 114 {
 115     if (is_windows_drive_prefix(filename) &&
 116         filename[2] == '\0')
 117         return 1;
 118     if (strstart(filename, "\\\\.\\", NULL) ||
 119         strstart(filename, "//./", NULL))
 120         return 1;
 121     return 0;
 122 }
 123 #endif
 124
 125 /* throttling disk I/O limits */
 126 void bdrv_set_io_limits(BlockDriverState *bs,
 127                         ThrottleConfig *cfg)
 128 {
 129     int i;
 130
 131     throttle_config(&bs->throttle_state, cfg);
 132
 133     for (i = 0; i < 2; i++) {
 134         qemu_co_enter_next(&bs->throttled_reqs[i]);
 135     }
 136 }
 137
 138 /* this function drain all the throttled IOs */
 139 static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
 140 {
 141     bool drained = false;
 142     bool enabled = bs->io_limits_enabled;
 143     int i;
 144
 145     bs->io_limits_enabled = false;
 146
 147     for (i = 0; i < 2; i++) {
 148         while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
 149             drained = true;
 150         }
 151     }
 152
 153     bs->io_limits_enabled = enabled;
 154
 155     return drained;
 156 }
 157
 158 void bdrv_io_limits_disable(BlockDriverState *bs)
 159 {
 160     bs->io_limits_enabled = false;
 161
 162     bdrv_start_throttled_reqs(bs);
 163
 164     throttle_destroy(&bs->throttle_state);
 165 }
 166
 167 static void bdrv_throttle_read_timer_cb(void *opaque)
 168 {
 169     BlockDriverState *bs = opaque;
 170     qemu_co_enter_next(&bs->throttled_reqs[0]);
 171 }
 172
 173 static void bdrv_throttle_write_timer_cb(void *opaque)
 174 {
 175     BlockDriverState *bs = opaque;
 176     qemu_co_enter_next(&bs->throttled_reqs[1]);
 177 }
 178
 179 /* should be called before bdrv_set_io_limits if a limit is set */
 180 void bdrv_io_limits_enable(BlockDriverState *bs)
 181 {
 182     assert(!bs->io_limits_enabled);
 183     throttle_init(&bs->throttle_state,
 184                   bdrv_get_aio_context(bs),
 185                   QEMU_CLOCK_VIRTUAL,
 186                   bdrv_throttle_read_timer_cb,
 187                   bdrv_throttle_write_timer_cb,
 188                   bs);
 189     bs->io_limits_enabled = true;
 190 }
 191
 192 /* This function makes an IO wait if needed
 193  *
 194  * @nb_sectors: the number of sectors of the IO
 195  * @is_write:   is the IO a write
 196  */
 197 static void bdrv_io_limits_intercept(BlockDriverState *bs,
 198                                      unsigned int bytes,
 199                                      bool is_write)
 200 {
 201     /* does this io must wait */
 202     bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
 203
 204     /* if must wait or any request of this type throttled queue the IO */
 205     if (must_wait ||
 206         !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
 207         qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
 208     }
 209
 210     /* the IO will be executed, do the accounting */
 211     throttle_account(&bs->throttle_state, is_write, bytes);
 212
 213
 214     /* if the next request must wait -> do nothing */
 215     if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
 216         return;
 217     }
 218
 219     /* else queue next request for execution */
 220     qemu_co_queue_next(&bs->throttled_reqs[is_write]);
 221 }
 222
 223 size_t bdrv_opt_mem_align(BlockDriverState *bs)
 224 {
 225     if (!bs || !bs->drv) {
 226         /* 4k should be on the safe side */
 227         return 4096;
 228     }
 229
 230     return bs->bl.opt_mem_alignment;
 231 }
 232
 233 /* check if the path starts with "<protocol>:" */
 234 static int path_has_protocol(const char *path)
 235 {
 236     const char *p;
 237
 238 #ifdef _WIN32
 239     if (is_windows_drive(path) ||
 240         is_windows_drive_prefix(path)) {
 241         return 0;
 242     }
 243     p = path + strcspn(path, ":/\\");
 244 #else
 245     p = path + strcspn(path, ":/");
 246 #endif
 247
 248     return *p == ':';
 249 }
 250
 251 int path_is_absolute(const char *path)
 252 {
 253 #ifdef _WIN32
 254     /* specific case for names like: "\\.\d:" */
 255     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
 256         return 1;
 257     }
 258     return (*path == '/' || *path == '\\');
 259 #else
 260     return (*path == '/');
 261 #endif
 262 }
 263
 264 /* if filename is absolute, just copy it to dest. Otherwise, build a
 265    path to it by considering it is relative to base_path. URL are
 266    supported. */
 267 void path_combine(char *dest, int dest_size,
 268                   const char *base_path,
 269                   const char *filename)
 270 {
 271     const char *p, *p1;
 272     int len;
 273
 274     if (dest_size <= 0)
 275         return;
 276     if (path_is_absolute(filename)) {
 277         pstrcpy(dest, dest_size, filename);
 278     } else {
 279         p = strchr(base_path, ':');
 280         if (p)
 281             p++;
 282         else
 283             p = base_path;
 284         p1 = strrchr(base_path, '/');
 285 #ifdef _WIN32
 286         {
 287             const char *p2;
 288             p2 = strrchr(base_path, '\\');
 289             if (!p1 || p2 > p1)
 290                 p1 = p2;
 291         }
 292 #endif
 293         if (p1)
 294             p1++;
 295         else
 296             p1 = base_path;
 297         if (p1 > p)
 298             p = p1;
 299         len = p - base_path;
 300         if (len > dest_size - 1)
 301             len = dest_size - 1;
 302         memcpy(dest, base_path, len);
 303         dest[len] = '\0';
 304         pstrcat(dest, dest_size, filename);
 305     }
 306 }
 307
 308 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
 309 {
 310     if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
 311         pstrcpy(dest, sz, bs->backing_file);
 312     } else {
 313         path_combine(dest, sz, bs->filename, bs->backing_file);
 314     }
 315 }
 316
 317 void bdrv_register(BlockDriver *bdrv)
 318 {
 319     /* Block drivers without coroutine functions need emulation */
 320     if (!bdrv->bdrv_co_readv) {
 321         bdrv->bdrv_co_readv = bdrv_co_readv_em;
 322         bdrv->bdrv_co_writev = bdrv_co_writev_em;
 323
 324         /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
 325          * the block driver lacks aio we need to emulate that too.
 326          */
 327         if (!bdrv->bdrv_aio_readv) {
 328             /* add AIO emulation layer */
 329             bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
 330             bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
 331         }
 332     }
 333
 334     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 335 }
 336
 337 /* create a new block device (by default it is empty) */
 338 BlockDriverState *bdrv_new(const char *device_name, Error **errp)
 339 {
 340     BlockDriverState *bs;
 341     int i;
 342
 343     if (bdrv_find(device_name)) {
 344         error_setg(errp, "Device with id '%s' already exists",
 345                    device_name);
 346         return NULL;
 347     }
 348     if (bdrv_find_node(device_name)) {
 349         error_setg(errp, "Device with node-name '%s' already exists",
 350                    device_name);
 351         return NULL;
 352     }
 353
 354     bs = g_malloc0(sizeof(BlockDriverState));
 355     QLIST_INIT(&bs->dirty_bitmaps);
 356     pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
 357     if (device_name[0] != '\0') {
 358         QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
 359     }
 360     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
 361         QLIST_INIT(&bs->op_blockers[i]);
 362     }
 363     bdrv_iostatus_disable(bs);
 364     notifier_list_init(&bs->close_notifiers);
 365     notifier_with_return_list_init(&bs->before_write_notifiers);
 366     qemu_co_queue_init(&bs->throttled_reqs[0]);
 367     qemu_co_queue_init(&bs->throttled_reqs[1]);
 368     bs->refcnt = 1;
 369     bs->aio_context = qemu_get_aio_context();
 370
 371     return bs;
 372 }
 373
 374 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
 375 {
 376     notifier_list_add(&bs->close_notifiers, notify);
 377 }
 378
 379 BlockDriver *bdrv_find_format(const char *format_name)
 380 {
 381     BlockDriver *drv1;
 382     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 383         if (!strcmp(drv1->format_name, format_name)) {
 384             return drv1;
 385         }
 386     }
 387     return NULL;
 388 }
 389
 390 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
 391 {
 392     static const char *whitelist_rw[] = {
 393         CONFIG_BDRV_RW_WHITELIST
 394     };
 395     static const char *whitelist_ro[] = {
 396         CONFIG_BDRV_RO_WHITELIST
 397     };
 398     const char **p;
 399
 400     if (!whitelist_rw[0] && !whitelist_ro[0]) {
 401         return 1;               /* no whitelist, anything goes */
 402     }
 403
 404     for (p = whitelist_rw; *p; p++) {
 405         if (!strcmp(drv->format_name, *p)) {
 406             return 1;
 407         }
 408     }
 409     if (read_only) {
 410         for (p = whitelist_ro; *p; p++) {
 411             if (!strcmp(drv->format_name, *p)) {
 412                 return 1;
 413             }
 414         }
 415     }
 416     return 0;
 417 }
 418
 419 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
 420                                           bool read_only)
 421 {
 422     BlockDriver *drv = bdrv_find_format(format_name);
 423     return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
 424 }
 425
 426 typedef struct CreateCo {
 427     BlockDriver *drv;
 428     char *filename;
 429     QemuOpts *opts;
 430     int ret;
 431     Error *err;
 432 } CreateCo;
 433
 434 static void coroutine_fn bdrv_create_co_entry(void *opaque)
 435 {
 436     Error *local_err = NULL;
 437     int ret;
 438
 439     CreateCo *cco = opaque;
 440     assert(cco->drv);
 441
 442     ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
 443     if (local_err) {
 444         error_propagate(&cco->err, local_err);
 445     }
 446     cco->ret = ret;
 447 }
 448
 449 int bdrv_create(BlockDriver *drv, const char* filename,
 450                 QemuOpts *opts, Error **errp)
 451 {
 452     int ret;
 453
 454     Coroutine *co;
 455     CreateCo cco = {
 456         .drv = drv,
 457         .filename = g_strdup(filename),
 458         .opts = opts,
 459         .ret = NOT_DONE,
 460         .err = NULL,
 461     };
 462
 463     if (!drv->bdrv_create) {
 464         error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
 465         ret = -ENOTSUP;
 466         goto out;
 467     }
 468
 469     if (qemu_in_coroutine()) {
 470         /* Fast-path if already in coroutine context */
 471         bdrv_create_co_entry(&cco);
 472     } else {
 473         co = qemu_coroutine_create(bdrv_create_co_entry);
 474         qemu_coroutine_enter(co, &cco);
 475         while (cco.ret == NOT_DONE) {
 476             aio_poll(qemu_get_aio_context(), true);
 477         }
 478     }
 479
 480     ret = cco.ret;
 481     if (ret < 0) {
 482         if (cco.err) {
 483             error_propagate(errp, cco.err);
 484         } else {
 485             error_setg_errno(errp, -ret, "Could not create image");
 486         }
 487     }
 488
 489 out:
 490     g_free(cco.filename);
 491     return ret;
 492 }
 493
 494 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
 495 {
 496     BlockDriver *drv;
 497     Error *local_err = NULL;
 498     int ret;
 499
 500     drv = bdrv_find_protocol(filename, true);
 501     if (drv == NULL) {
 502         error_setg(errp, "Could not find protocol for file '%s'", filename);
 503         return -ENOENT;
 504     }
 505
 506     ret = bdrv_create(drv, filename, opts, &local_err);
 507     if (local_err) {
 508         error_propagate(errp, local_err);
 509     }
 510     return ret;
 511 }
 512
 513 void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
 514 {
 515     BlockDriver *drv = bs->drv;
 516     Error *local_err = NULL;
 517
 518     memset(&bs->bl, 0, sizeof(bs->bl));
 519
 520     if (!drv) {
 521         return;
 522     }
 523
 524     /* Take some limits from the children as a default */
 525     if (bs->file) {
 526         bdrv_refresh_limits(bs->file, &local_err);
 527         if (local_err) {
 528             error_propagate(errp, local_err);
 529             return;
 530         }
 531         bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
 532         bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
 533     } else {
 534         bs->bl.opt_mem_alignment = 512;
 535     }
 536
 537     if (bs->backing_hd) {
 538         bdrv_refresh_limits(bs->backing_hd, &local_err);
 539         if (local_err) {
 540             error_propagate(errp, local_err);
 541             return;
 542         }
 543         bs->bl.opt_transfer_length =
 544             MAX(bs->bl.opt_transfer_length,
 545                 bs->backing_hd->bl.opt_transfer_length);
 546         bs->bl.opt_mem_alignment =
 547             MAX(bs->bl.opt_mem_alignment,
 548                 bs->backing_hd->bl.opt_mem_alignment);
 549     }
 550
 551     /* Then let the driver override it */
 552     if (drv->bdrv_refresh_limits) {
 553         drv->bdrv_refresh_limits(bs, errp);
 554     }
 555 }
 556
 557 /*
 558  * Create a uniquely-named empty temporary file.
 559  * Return 0 upon success, otherwise a negative errno value.
 560  */
 561 int get_tmp_filename(char *filename, int size)
 562 {
 563 #ifdef _WIN32
 564     char temp_dir[MAX_PATH];
 565     /* GetTempFileName requires that its output buffer (4th param)
 566        have length MAX_PATH or greater.  */
 567     assert(size >= MAX_PATH);
 568     return (GetTempPath(MAX_PATH, temp_dir)
 569             && GetTempFileName(temp_dir, "qem", 0, filename)
 570             ? 0 : -GetLastError());
 571 #else
 572     int fd;
 573     const char *tmpdir;
 574     tmpdir = getenv("TMPDIR");
 575     if (!tmpdir) {
 576         tmpdir = "/var/tmp";
 577     }
 578     if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
 579         return -EOVERFLOW;
 580     }
 581     fd = mkstemp(filename);
 582     if (fd < 0) {
 583         return -errno;
 584     }
 585     if (close(fd) != 0) {
 586         unlink(filename);
 587         return -errno;
 588     }
 589     return 0;
 590 #endif
 591 }
 592
 593 /*
 594  * Detect host devices. By convention, /dev/cdrom[N] is always
 595  * recognized as a host CDROM.
 596  */
 597 static BlockDriver *find_hdev_driver(const char *filename)
 598 {
 599     int score_max = 0, score;
 600     BlockDriver *drv = NULL, *d;
 601
 602     QLIST_FOREACH(d, &bdrv_drivers, list) {
 603         if (d->bdrv_probe_device) {
 604             score = d->bdrv_probe_device(filename);
 605             if (score > score_max) {
 606                 score_max = score;
 607                 drv = d;
 608             }
 609         }
 610     }
 611
 612     return drv;
 613 }
 614
 615 BlockDriver *bdrv_find_protocol(const char *filename,
 616                                 bool allow_protocol_prefix)
 617 {
 618     BlockDriver *drv1;
 619     char protocol[128];
 620     int len;
 621     const char *p;
 622
 623     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 624
 625     /*
 626      * XXX(hch): we really should not let host device detection
 627      * override an explicit protocol specification, but moving this
 628      * later breaks access to device names with colons in them.
 629      * Thanks to the brain-dead persistent naming schemes on udev-
 630      * based Linux systems those actually are quite common.
 631      */
 632     drv1 = find_hdev_driver(filename);
 633     if (drv1) {
 634         return drv1;
 635     }
 636
 637     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
 638         return bdrv_find_format("file");
 639     }
 640
 641     p = strchr(filename, ':');
 642     assert(p != NULL);
 643     len = p - filename;
 644     if (len > sizeof(protocol) - 1)
 645         len = sizeof(protocol) - 1;
 646     memcpy(protocol, filename, len);
 647     protocol[len] = '\0';
 648     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 649         if (drv1->protocol_name &&
 650             !strcmp(drv1->protocol_name, protocol)) {
 651             return drv1;
 652         }
 653     }
 654     return NULL;
 655 }
 656
 657 static int find_image_format(BlockDriverState *bs, const char *filename,
 658                              BlockDriver **pdrv, Error **errp)
 659 {
 660     int score, score_max;
 661     BlockDriver *drv1, *drv;
 662     uint8_t buf[2048];
 663     int ret = 0;
 664
 665     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
 666     if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
 667         drv = bdrv_find_format("raw");
 668         if (!drv) {
 669             error_setg(errp, "Could not find raw image format");
 670             ret = -ENOENT;
 671         }
 672         *pdrv = drv;
 673         return ret;
 674     }
 675
 676     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
 677     if (ret < 0) {
 678         error_setg_errno(errp, -ret, "Could not read image for determining its "
 679                          "format");
 680         *pdrv = NULL;
 681         return ret;
 682     }
 683
 684     score_max = 0;
 685     drv = NULL;
 686     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 687         if (drv1->bdrv_probe) {
 688             score = drv1->bdrv_probe(buf, ret, filename);
 689             if (score > score_max) {
 690                 score_max = score;
 691                 drv = drv1;
 692             }
 693         }
 694     }
 695     if (!drv) {
 696         error_setg(errp, "Could not determine image format: No compatible "
 697                    "driver found");
 698         ret = -ENOENT;
 699     }
 700     *pdrv = drv;
 701     return ret;
 702 }
 703
 704 /**
 705  * Set the current 'total_sectors' value
 706  * Return 0 on success, -errno on error.
 707  */
 708 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 709 {
 710     BlockDriver *drv = bs->drv;
 711
 712     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
 713     if (bs->sg)
 714         return 0;
 715
 716     /* query actual device if possible, otherwise just trust the hint */
 717     if (drv->bdrv_getlength) {
 718         int64_t length = drv->bdrv_getlength(bs);
 719         if (length < 0) {
 720             return length;
 721         }
 722         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
 723     }
 724
 725     bs->total_sectors = hint;
 726     return 0;
 727 }
 728
 729 /**
 730  * Set open flags for a given discard mode
 731  *
 732  * Return 0 on success, -1 if the discard mode was invalid.
 733  */
 734 int bdrv_parse_discard_flags(const char *mode, int *flags)
 735 {
 736     *flags &= ~BDRV_O_UNMAP;
 737
 738     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
 739         /* do nothing */
 740     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
 741         *flags |= BDRV_O_UNMAP;
 742     } else {
 743         return -1;
 744     }
 745
 746     return 0;
 747 }
 748
 749 /**
 750  * Set open flags for a given cache mode
 751  *
 752  * Return 0 on success, -1 if the cache mode was invalid.
 753  */
 754 int bdrv_parse_cache_flags(const char *mode, int *flags)
 755 {
 756     *flags &= ~BDRV_O_CACHE_MASK;
 757
 758     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
 759         *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
 760     } else if (!strcmp(mode, "directsync")) {
 761         *flags |= BDRV_O_NOCACHE;
 762     } else if (!strcmp(mode, "writeback")) {
 763         *flags |= BDRV_O_CACHE_WB;
 764     } else if (!strcmp(mode, "unsafe")) {
 765         *flags |= BDRV_O_CACHE_WB;
 766         *flags |= BDRV_O_NO_FLUSH;
 767     } else if (!strcmp(mode, "writethrough")) {
 768         /* this is the default */
 769     } else {
 770         return -1;
 771     }
 772
 773     return 0;
 774 }
 775
 776 /**
 777  * The copy-on-read flag is actually a reference count so multiple users may
 778  * use the feature without worrying about clobbering its previous state.
 779  * Copy-on-read stays enabled until all users have called to disable it.
 780  */
 781 void bdrv_enable_copy_on_read(BlockDriverState *bs)
 782 {
 783     bs->copy_on_read++;
 784 }
 785
 786 void bdrv_disable_copy_on_read(BlockDriverState *bs)
 787 {
 788     assert(bs->copy_on_read > 0);
 789     bs->copy_on_read--;
 790 }
 791
 792 /*
 793  * Returns the flags that a temporary snapshot should get, based on the
 794  * originally requested flags (the originally requested image will have flags
 795  * like a backing file)
 796  */
 797 static int bdrv_temp_snapshot_flags(int flags)
 798 {
 799     return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
 800 }
 801
 802 /*
 803  * Returns the flags that bs->file should get, based on the given flags for
 804  * the parent BDS
 805  */
 806 static int bdrv_inherited_flags(int flags)
 807 {
 808     /* Enable protocol handling, disable format probing for bs->file */
 809     flags |= BDRV_O_PROTOCOL;
 810
 811     /* Our block drivers take care to send flushes and respect unmap policy,
 812      * so we can enable both unconditionally on lower layers. */
 813     flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
 814
 815     /* Clear flags that only apply to the top layer */
 816     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
 817
 818     return flags;
 819 }
 820
 821 /*
 822  * Returns the flags that bs->backing_hd should get, based on the given flags
 823  * for the parent BDS
 824  */
 825 static int bdrv_backing_flags(int flags)
 826 {
 827     /* backing files always opened read-only */
 828     flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
 829
 830     /* snapshot=on is handled on the top layer */
 831     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
 832
 833     return flags;
 834 }
 835
 836 static int bdrv_open_flags(BlockDriverState *bs, int flags)
 837 {
 838     int open_flags = flags | BDRV_O_CACHE_WB;
 839
 840     /*
 841      * Clear flags that are internal to the block layer before opening the
 842      * image.
 843      */
 844     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
 845
 846     /*
 847      * Snapshots should be writable.
 848      */
 849     if (flags & BDRV_O_TEMPORARY) {
 850         open_flags |= BDRV_O_RDWR;
 851     }
 852
 853     return open_flags;
 854 }
 855
 856 static void bdrv_assign_node_name(BlockDriverState *bs,
 857                                   const char *node_name,
 858                                   Error **errp)
 859 {
 860     if (!node_name) {
 861         return;
 862     }
 863
 864     /* empty string node name is invalid */
 865     if (node_name[0] == '\0') {
 866         error_setg(errp, "Empty node name");
 867         return;
 868     }
 869
 870     /* takes care of avoiding namespaces collisions */
 871     if (bdrv_find(node_name)) {
 872         error_setg(errp, "node-name=%s is conflicting with a device id",
 873                    node_name);
 874         return;
 875     }
 876
 877     /* takes care of avoiding duplicates node names */
 878     if (bdrv_find_node(node_name)) {
 879         error_setg(errp, "Duplicate node name");
 880         return;
 881     }
 882
 883     /* copy node name into the bs and insert it into the graph list */
 884     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
 885     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
 886 }
 887
 888 /*
 889  * Common part for opening disk images and files
 890  *
 891  * Removes all processed options from *options.
 892  */
 893 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
 894     QDict *options, int flags, BlockDriver *drv, Error **errp)
 895 {
 896     int ret, open_flags;
 897     const char *filename;
 898     const char *node_name = NULL;
 899     Error *local_err = NULL;
 900
 901     assert(drv != NULL);
 902     assert(bs->file == NULL);
 903     assert(options != NULL && bs->options != options);
 904
 905     if (file != NULL) {
 906         filename = file->filename;
 907     } else {
 908         filename = qdict_get_try_str(options, "filename");
 909     }
 910
 911     if (drv->bdrv_needs_filename && !filename) {
 912         error_setg(errp, "The '%s' block driver requires a file name",
 913                    drv->format_name);
 914         return -EINVAL;
 915     }
 916
 917     trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
 918
 919     node_name = qdict_get_try_str(options, "node-name");
 920     bdrv_assign_node_name(bs, node_name, &local_err);
 921     if (local_err) {
 922         error_propagate(errp, local_err);
 923         return -EINVAL;
 924     }
 925     qdict_del(options, "node-name");
 926
 927     /* bdrv_open() with directly using a protocol as drv. This layer is already
 928      * opened, so assign it to bs (while file becomes a closed BlockDriverState)
 929      * and return immediately. */
 930     if (file != NULL && drv->bdrv_file_open) {
 931         bdrv_swap(file, bs);
 932         return 0;
 933     }
 934
 935     bs->open_flags = flags;
 936     bs->guest_block_size = 512;
 937     bs->request_alignment = 512;
 938     bs->zero_beyond_eof = true;
 939     open_flags = bdrv_open_flags(bs, flags);
 940     bs->read_only = !(open_flags & BDRV_O_RDWR);
 941     bs->growable = !!(flags & BDRV_O_PROTOCOL);
 942
 943     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
 944         error_setg(errp,
 945                    !bs->read_only && bdrv_is_whitelisted(drv, true)
 946                         ? "Driver '%s' can only be used for read-only devices"
 947                         : "Driver '%s' is not whitelisted",
 948                    drv->format_name);
 949         return -ENOTSUP;
 950     }
 951
 952     assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
 953     if (flags & BDRV_O_COPY_ON_READ) {
 954         if (!bs->read_only) {
 955             bdrv_enable_copy_on_read(bs);
 956         } else {
 957             error_setg(errp, "Can't use copy-on-read on read-only device");
 958             return -EINVAL;
 959         }
 960     }
 961
 962     if (filename != NULL) {
 963         pstrcpy(bs->filename, sizeof(bs->filename), filename);
 964     } else {
 965         bs->filename[0] = '\0';
 966     }
 967
 968     bs->drv = drv;
 969     bs->opaque = g_malloc0(drv->instance_size);
 970
 971     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
 972
 973     /* Open the image, either directly or using a protocol */
 974     if (drv->bdrv_file_open) {
 975         assert(file == NULL);
 976         assert(!drv->bdrv_needs_filename || filename != NULL);
 977         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
 978     } else {
 979         if (file == NULL) {
 980             error_setg(errp, "Can't use '%s' as a block driver for the "
 981                        "protocol level", drv->format_name);
 982             ret = -EINVAL;
 983             goto free_and_fail;
 984         }
 985         bs->file = file;
 986         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
 987     }
 988
 989     if (ret < 0) {
 990         if (local_err) {
 991             error_propagate(errp, local_err);
 992         } else if (bs->filename[0]) {
 993             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
 994         } else {
 995             error_setg_errno(errp, -ret, "Could not open image");
 996         }
 997         goto free_and_fail;
 998     }
 999
1000     ret = refresh_total_sectors(bs, bs->total_sectors);
1001     if (ret < 0) {
1002         error_setg_errno(errp, -ret, "Could not refresh total sector count");
1003         goto free_and_fail;
1004     }
1005
1006     bdrv_refresh_limits(bs, &local_err);
1007     if (local_err) {
1008         error_propagate(errp, local_err);
1009         ret = -EINVAL;
1010         goto free_and_fail;
1011     }
1012
1013     assert(bdrv_opt_mem_align(bs) != 0);
1014     assert((bs->request_alignment != 0) || bs->sg);
1015     return 0;
1016
1017 free_and_fail:
1018     bs->file = NULL;
1019     g_free(bs->opaque);
1020     bs->opaque = NULL;
1021     bs->drv = NULL;
1022     return ret;
1023 }
1024
1025 static QDict *parse_json_filename(const char *filename, Error **errp)
1026 {
1027     QObject *options_obj;
1028     QDict *options;
1029     int ret;
1030
1031     ret = strstart(filename, "json:", &filename);
1032     assert(ret);
1033
1034     options_obj = qobject_from_json(filename);
1035     if (!options_obj) {
1036         error_setg(errp, "Could not parse the JSON options");
1037         return NULL;
1038     }
1039
1040     if (qobject_type(options_obj) != QTYPE_QDICT) {
1041         qobject_decref(options_obj);
1042         error_setg(errp, "Invalid JSON object given");
1043         return NULL;
1044     }
1045
1046     options = qobject_to_qdict(options_obj);
1047     qdict_flatten(options);
1048
1049     return options;
1050 }
1051
1052 /*
1053  * Fills in default options for opening images and converts the legacy
1054  * filename/flags pair to option QDict entries.
1055  */
1056 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1057                              BlockDriver *drv, Error **errp)
1058 {
1059     const char *filename = *pfilename;
1060     const char *drvname;
1061     bool protocol = flags & BDRV_O_PROTOCOL;
1062     bool parse_filename = false;
1063     Error *local_err = NULL;
1064
1065     /* Parse json: pseudo-protocol */
1066     if (filename && g_str_has_prefix(filename, "json:")) {
1067         QDict *json_options = parse_json_filename(filename, &local_err);
1068         if (local_err) {
1069             error_propagate(errp, local_err);
1070             return -EINVAL;
1071         }
1072
1073         /* Options given in the filename have lower priority than options
1074          * specified directly */
1075         qdict_join(*options, json_options, false);
1076         QDECREF(json_options);
1077         *pfilename = filename = NULL;
1078     }
1079
1080     /* Fetch the file name from the options QDict if necessary */
1081     if (protocol && filename) {
1082         if (!qdict_haskey(*options, "filename")) {
1083             qdict_put(*options, "filename", qstring_from_str(filename));
1084             parse_filename = true;
1085         } else {
1086             error_setg(errp, "Can't specify 'file' and 'filename' options at "
1087                              "the same time");
1088             return -EINVAL;
1089         }
1090     }
1091
1092     /* Find the right block driver */
1093     filename = qdict_get_try_str(*options, "filename");
1094     drvname = qdict_get_try_str(*options, "driver");
1095
1096     if (drv) {
1097         if (drvname) {
1098             error_setg(errp, "Driver specified twice");
1099             return -EINVAL;
1100         }
1101         drvname = drv->format_name;
1102         qdict_put(*options, "driver", qstring_from_str(drvname));
1103     } else {
1104         if (!drvname && protocol) {
1105             if (filename) {
1106                 drv = bdrv_find_protocol(filename, parse_filename);
1107                 if (!drv) {
1108                     error_setg(errp, "Unknown protocol");
1109                     return -EINVAL;
1110                 }
1111
1112                 drvname = drv->format_name;
1113                 qdict_put(*options, "driver", qstring_from_str(drvname));
1114             } else {
1115                 error_setg(errp, "Must specify either driver or file");
1116                 return -EINVAL;
1117             }
1118         } else if (drvname) {
1119             drv = bdrv_find_format(drvname);
1120             if (!drv) {
1121                 error_setg(errp, "Unknown driver '%s'", drvname);
1122                 return -ENOENT;
1123             }
1124         }
1125     }
1126
1127     assert(drv || !protocol);
1128
1129     /* Driver-specific filename parsing */
1130     if (drv && drv->bdrv_parse_filename && parse_filename) {
1131         drv->bdrv_parse_filename(filename, *options, &local_err);
1132         if (local_err) {
1133             error_propagate(errp, local_err);
1134             return -EINVAL;
1135         }
1136
1137         if (!drv->bdrv_needs_filename) {
1138             qdict_del(*options, "filename");
1139         }
1140     }
1141
1142     return 0;
1143 }
1144
1145 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1146 {
1147
1148     if (bs->backing_hd) {
1149         assert(bs->backing_blocker);
1150         bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1151     } else if (backing_hd) {
1152         error_setg(&bs->backing_blocker,
1153                    "device is used as backing hd of '%s'",
1154                    bs->device_name);
1155     }
1156
1157     bs->backing_hd = backing_hd;
1158     if (!backing_hd) {
1159         error_free(bs->backing_blocker);
1160         bs->backing_blocker = NULL;
1161         goto out;
1162     }
1163     bs->open_flags &= ~BDRV_O_NO_BACKING;
1164     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1165     pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1166             backing_hd->drv ? backing_hd->drv->format_name : "");
1167
1168     bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1169     /* Otherwise we won't be able to commit due to check in bdrv_commit */
1170     bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1171                     bs->backing_blocker);
1172 out:
1173     bdrv_refresh_limits(bs, NULL);
1174 }
1175
1176 /*
1177  * Opens the backing file for a BlockDriverState if not yet open
1178  *
1179  * options is a QDict of options to pass to the block drivers, or NULL for an
1180  * empty set of options. The reference to the QDict is transferred to this
1181  * function (even on failure), so if the caller intends to reuse the dictionary,
1182  * it needs to use QINCREF() before calling bdrv_file_open.
1183  */
1184 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1185 {
1186     char *backing_filename = g_malloc0(PATH_MAX);
1187     int ret = 0;
1188     BlockDriver *back_drv = NULL;
1189     BlockDriverState *backing_hd;
1190     Error *local_err = NULL;
1191
1192     if (bs->backing_hd != NULL) {
1193         QDECREF(options);
1194         goto free_exit;
1195     }
1196
1197     /* NULL means an empty set of options */
1198     if (options == NULL) {
1199         options = qdict_new();
1200     }
1201
1202     bs->open_flags &= ~BDRV_O_NO_BACKING;
1203     if (qdict_haskey(options, "file.filename")) {
1204         backing_filename[0] = '\0';
1205     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1206         QDECREF(options);
1207         goto free_exit;
1208     } else {
1209         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
1210     }
1211
1212     if (!bs->drv || !bs->drv->supports_backing) {
1213         ret = -EINVAL;
1214         error_setg(errp, "Driver doesn't support backing files");
1215         QDECREF(options);
1216         goto free_exit;
1217     }
1218
1219     backing_hd = bdrv_new("", errp);
1220
1221     if (bs->backing_format[0] != '\0') {
1222         back_drv = bdrv_find_format(bs->backing_format);
1223     }
1224
1225     assert(bs->backing_hd == NULL);
1226     ret = bdrv_open(&backing_hd,
1227                     *backing_filename ? backing_filename : NULL, NULL, options,
1228                     bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
1229     if (ret < 0) {
1230         bdrv_unref(backing_hd);
1231         backing_hd = NULL;
1232         bs->open_flags |= BDRV_O_NO_BACKING;
1233         error_setg(errp, "Could not open backing file: %s",
1234                    error_get_pretty(local_err));
1235         error_free(local_err);
1236         goto free_exit;
1237     }
1238     bdrv_set_backing_hd(bs, backing_hd);
1239
1240 free_exit:
1241     g_free(backing_filename);
1242     return ret;
1243 }
1244
1245 /*
1246  * Opens a disk image whose options are given as BlockdevRef in another block
1247  * device's options.
1248  *
1249  * If allow_none is true, no image will be opened if filename is false and no
1250  * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1251  *
1252  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1253  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1254  * itself, all options starting with "${bdref_key}." are considered part of the
1255  * BlockdevRef.
1256  *
1257  * The BlockdevRef will be removed from the options QDict.
1258  *
1259  * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1260  */
1261 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1262                     QDict *options, const char *bdref_key, int flags,
1263                     bool allow_none, Error **errp)
1264 {
1265     QDict *image_options;
1266     int ret;
1267     char *bdref_key_dot;
1268     const char *reference;
1269
1270     assert(pbs);
1271     assert(*pbs == NULL);
1272
1273     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1274     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1275     g_free(bdref_key_dot);
1276
1277     reference = qdict_get_try_str(options, bdref_key);
1278     if (!filename && !reference && !qdict_size(image_options)) {
1279         if (allow_none) {
1280             ret = 0;
1281         } else {
1282             error_setg(errp, "A block device must be specified for \"%s\"",
1283                        bdref_key);
1284             ret = -EINVAL;
1285         }
1286         QDECREF(image_options);
1287         goto done;
1288     }
1289
1290     ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
1291
1292 done:
1293     qdict_del(options, bdref_key);
1294     return ret;
1295 }
1296
1297 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1298 {
1299     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1300     char *tmp_filename = g_malloc0(PATH_MAX + 1);
1301     int64_t total_size;
1302     BlockDriver *bdrv_qcow2;
1303     QemuOpts *opts = NULL;
1304     QDict *snapshot_options;
1305     BlockDriverState *bs_snapshot;
1306     Error *local_err;
1307     int ret;
1308
1309     /* if snapshot, we create a temporary backing file and open it
1310        instead of opening 'filename' directly */
1311
1312     /* Get the required size from the image */
1313     total_size = bdrv_getlength(bs);
1314     if (total_size < 0) {
1315         ret = total_size;
1316         error_setg_errno(errp, -total_size, "Could not get image size");
1317         goto out;
1318     }
1319
1320     /* Create the temporary image */
1321     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1322     if (ret < 0) {
1323         error_setg_errno(errp, -ret, "Could not get temporary filename");
1324         goto out;
1325     }
1326
1327     bdrv_qcow2 = bdrv_find_format("qcow2");
1328     opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1329                             &error_abort);
1330     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
1331     ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1332     qemu_opts_del(opts);
1333     if (ret < 0) {
1334         error_setg_errno(errp, -ret, "Could not create temporary overlay "
1335                          "'%s': %s", tmp_filename,
1336                          error_get_pretty(local_err));
1337         error_free(local_err);
1338         goto out;
1339     }
1340
1341     /* Prepare a new options QDict for the temporary file */
1342     snapshot_options = qdict_new();
1343     qdict_put(snapshot_options, "file.driver",
1344               qstring_from_str("file"));
1345     qdict_put(snapshot_options, "file.filename",
1346               qstring_from_str(tmp_filename));
1347
1348     bs_snapshot = bdrv_new("", &error_abort);
1349
1350     ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1351                     flags, bdrv_qcow2, &local_err);
1352     if (ret < 0) {
1353         error_propagate(errp, local_err);
1354         goto out;
1355     }
1356
1357     bdrv_append(bs_snapshot, bs);
1358
1359 out:
1360     g_free(tmp_filename);
1361     return ret;
1362 }
1363
1364 /*
1365  * Opens a disk image (raw, qcow2, vmdk, ...)
1366  *
1367  * options is a QDict of options to pass to the block drivers, or NULL for an
1368  * empty set of options. The reference to the QDict belongs to the block layer
1369  * after the call (even on failure), so if the caller intends to reuse the
1370  * dictionary, it needs to use QINCREF() before calling bdrv_open.
1371  *
1372  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1373  * If it is not NULL, the referenced BDS will be reused.
1374  *
1375  * The reference parameter may be used to specify an existing block device which
1376  * should be opened. If specified, neither options nor a filename may be given,
1377  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1378  */
1379 int bdrv_open(BlockDriverState **pbs, const char *filename,
1380               const char *reference, QDict *options, int flags,
1381               BlockDriver *drv, Error **errp)
1382 {
1383     int ret;
1384     BlockDriverState *file = NULL, *bs;
1385     const char *drvname;
1386     Error *local_err = NULL;
1387     int snapshot_flags = 0;
1388
1389     assert(pbs);
1390
1391     if (reference) {
1392         bool options_non_empty = options ? qdict_size(options) : false;
1393         QDECREF(options);
1394
1395         if (*pbs) {
1396             error_setg(errp, "Cannot reuse an existing BDS when referencing "
1397                        "another block device");
1398             return -EINVAL;
1399         }
1400
1401         if (filename || options_non_empty) {
1402             error_setg(errp, "Cannot reference an existing block device with "
1403                        "additional options or a new filename");
1404             return -EINVAL;
1405         }
1406
1407         bs = bdrv_lookup_bs(reference, reference, errp);
1408         if (!bs) {
1409             return -ENODEV;
1410         }
1411         bdrv_ref(bs);
1412         *pbs = bs;
1413         return 0;
1414     }
1415
1416     if (*pbs) {
1417         bs = *pbs;
1418     } else {
1419         bs = bdrv_new("", &error_abort);
1420     }
1421
1422     /* NULL means an empty set of options */
1423     if (options == NULL) {
1424         options = qdict_new();
1425     }
1426
1427     ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1428     if (local_err) {
1429         goto fail;
1430     }
1431
1432     /* Find the right image format driver */
1433     drv = NULL;
1434     drvname = qdict_get_try_str(options, "driver");
1435     if (drvname) {
1436         drv = bdrv_find_format(drvname);
1437         qdict_del(options, "driver");
1438         if (!drv) {
1439             error_setg(errp, "Unknown driver: '%s'", drvname);
1440             ret = -EINVAL;
1441             goto fail;
1442         }
1443     }
1444
1445     assert(drvname || !(flags & BDRV_O_PROTOCOL));
1446     if (drv && !drv->bdrv_file_open) {
1447         /* If the user explicitly wants a format driver here, we'll need to add
1448          * another layer for the protocol in bs->file */
1449         flags &= ~BDRV_O_PROTOCOL;
1450     }
1451
1452     bs->options = options;
1453     options = qdict_clone_shallow(options);
1454
1455     /* Open image file without format layer */
1456     if ((flags & BDRV_O_PROTOCOL) == 0) {
1457         if (flags & BDRV_O_RDWR) {
1458             flags |= BDRV_O_ALLOW_RDWR;
1459         }
1460         if (flags & BDRV_O_SNAPSHOT) {
1461             snapshot_flags = bdrv_temp_snapshot_flags(flags);
1462             flags = bdrv_backing_flags(flags);
1463         }
1464
1465         assert(file == NULL);
1466         ret = bdrv_open_image(&file, filename, options, "file",
1467                               bdrv_inherited_flags(flags),
1468                               true, &local_err);
1469         if (ret < 0) {
1470             goto fail;
1471         }
1472     }
1473
1474     /* Image format probing */
1475     if (!drv && file) {
1476         ret = find_image_format(file, filename, &drv, &local_err);
1477         if (ret < 0) {
1478             goto fail;
1479         }
1480     } else if (!drv) {
1481         error_setg(errp, "Must specify either driver or file");
1482         ret = -EINVAL;
1483         goto fail;
1484     }
1485
1486     /* Open the image */
1487     ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1488     if (ret < 0) {
1489         goto fail;
1490     }
1491
1492     if (file && (bs->file != file)) {
1493         bdrv_unref(file);
1494         file = NULL;
1495     }
1496
1497     /* If there is a backing file, use it */
1498     if ((flags & BDRV_O_NO_BACKING) == 0) {
1499         QDict *backing_options;
1500
1501         qdict_extract_subqdict(options, &backing_options, "backing.");
1502         ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1503         if (ret < 0) {
1504             goto close_and_fail;
1505         }
1506     }
1507
1508     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1509      * temporary snapshot afterwards. */
1510     if (snapshot_flags) {
1511         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1512         if (local_err) {
1513             goto close_and_fail;
1514         }
1515     }
1516
1517     /* Check if any unknown options were used */
1518     if (options && (qdict_size(options) != 0)) {
1519         const QDictEntry *entry = qdict_first(options);
1520         if (flags & BDRV_O_PROTOCOL) {
1521             error_setg(errp, "Block protocol '%s' doesn't support the option "
1522                        "'%s'", drv->format_name, entry->key);
1523         } else {
1524             error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1525                        "support the option '%s'", drv->format_name,
1526                        bs->device_name, entry->key);
1527         }
1528
1529         ret = -EINVAL;
1530         goto close_and_fail;
1531     }
1532
1533     if (!bdrv_key_required(bs)) {
1534         bdrv_dev_change_media_cb(bs, true);
1535     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1536                && !runstate_check(RUN_STATE_INMIGRATE)
1537                && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1538         error_setg(errp,
1539                    "Guest must be stopped for opening of encrypted image");
1540         ret = -EBUSY;
1541         goto close_and_fail;
1542     }
1543
1544     QDECREF(options);
1545     *pbs = bs;
1546     return 0;
1547
1548 fail:
1549     if (file != NULL) {
1550         bdrv_unref(file);
1551     }
1552     QDECREF(bs->options);
1553     QDECREF(options);
1554     bs->options = NULL;
1555     if (!*pbs) {
1556         /* If *pbs is NULL, a new BDS has been created in this function and
1557            needs to be freed now. Otherwise, it does not need to be closed,
1558            since it has not really been opened yet. */
1559         bdrv_unref(bs);
1560     }
1561     if (local_err) {
1562         error_propagate(errp, local_err);
1563     }
1564     return ret;
1565
1566 close_and_fail:
1567     /* See fail path, but now the BDS has to be always closed */
1568     if (*pbs) {
1569         bdrv_close(bs);
1570     } else {
1571         bdrv_unref(bs);
1572     }
1573     QDECREF(options);
1574     if (local_err) {
1575         error_propagate(errp, local_err);
1576     }
1577     return ret;
1578 }
1579
1580 typedef struct BlockReopenQueueEntry {
1581      bool prepared;
1582      BDRVReopenState state;
1583      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1584 } BlockReopenQueueEntry;
1585
1586 /*
1587  * Adds a BlockDriverState to a simple queue for an atomic, transactional
1588  * reopen of multiple devices.
1589  *
1590  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1591  * already performed, or alternatively may be NULL a new BlockReopenQueue will
1592  * be created and initialized. This newly created BlockReopenQueue should be
1593  * passed back in for subsequent calls that are intended to be of the same
1594  * atomic 'set'.
1595  *
1596  * bs is the BlockDriverState to add to the reopen queue.
1597  *
1598  * flags contains the open flags for the associated bs
1599  *
1600  * returns a pointer to bs_queue, which is either the newly allocated
1601  * bs_queue, or the existing bs_queue being used.
1602  *
1603  */
1604 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1605                                     BlockDriverState *bs, int flags)
1606 {
1607     assert(bs != NULL);
1608
1609     BlockReopenQueueEntry *bs_entry;
1610     if (bs_queue == NULL) {
1611         bs_queue = g_new0(BlockReopenQueue, 1);
1612         QSIMPLEQ_INIT(bs_queue);
1613     }
1614
1615     /* bdrv_open() masks this flag out */
1616     flags &= ~BDRV_O_PROTOCOL;
1617
1618     if (bs->file) {
1619         bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1620     }
1621
1622     bs_entry = g_new0(BlockReopenQueueEntry, 1);
1623     QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1624
1625     bs_entry->state.bs = bs;
1626     bs_entry->state.flags = flags;
1627
1628     return bs_queue;
1629 }
1630
1631 /*
1632  * Reopen multiple BlockDriverStates atomically & transactionally.
1633  *
1634  * The queue passed in (bs_queue) must have been built up previous
1635  * via bdrv_reopen_queue().
1636  *
1637  * Reopens all BDS specified in the queue, with the appropriate
1638  * flags.  All devices are prepared for reopen, and failure of any
1639  * device will cause all device changes to be abandonded, and intermediate
1640  * data cleaned up.
1641  *
1642  * If all devices prepare successfully, then the changes are committed
1643  * to all devices.
1644  *
1645  */
1646 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1647 {
1648     int ret = -1;
1649     BlockReopenQueueEntry *bs_entry, *next;
1650     Error *local_err = NULL;
1651
1652     assert(bs_queue != NULL);
1653
1654     bdrv_drain_all();
1655
1656     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1657         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1658             error_propagate(errp, local_err);
1659             goto cleanup;
1660         }
1661         bs_entry->prepared = true;
1662     }
1663
1664     /* If we reach this point, we have success and just need to apply the
1665      * changes
1666      */
1667     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1668         bdrv_reopen_commit(&bs_entry->state);
1669     }
1670
1671     ret = 0;
1672
1673 cleanup:
1674     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1675         if (ret && bs_entry->prepared) {
1676             bdrv_reopen_abort(&bs_entry->state);
1677         }
1678         g_free(bs_entry);
1679     }
1680     g_free(bs_queue);
1681     return ret;
1682 }
1683
1684
1685 /* Reopen a single BlockDriverState with the specified flags. */
1686 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1687 {
1688     int ret = -1;
1689     Error *local_err = NULL;
1690     BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1691
1692     ret = bdrv_reopen_multiple(queue, &local_err);
1693     if (local_err != NULL) {
1694         error_propagate(errp, local_err);
1695     }
1696     return ret;
1697 }
1698
1699
1700 /*
1701  * Prepares a BlockDriverState for reopen. All changes are staged in the
1702  * 'opaque' field of the BDRVReopenState, which is used and allocated by
1703  * the block driver layer .bdrv_reopen_prepare()
1704  *
1705  * bs is the BlockDriverState to reopen
1706  * flags are the new open flags
1707  * queue is the reopen queue
1708  *
1709  * Returns 0 on success, non-zero on error.  On error errp will be set
1710  * as well.
1711  *
1712  * On failure, bdrv_reopen_abort() will be called to clean up any data.
1713  * It is the responsibility of the caller to then call the abort() or
1714  * commit() for any other BDS that have been left in a prepare() state
1715  *
1716  */
1717 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1718                         Error **errp)
1719 {
1720     int ret = -1;
1721     Error *local_err = NULL;
1722     BlockDriver *drv;
1723
1724     assert(reopen_state != NULL);
1725     assert(reopen_state->bs->drv != NULL);
1726     drv = reopen_state->bs->drv;
1727
1728     /* if we are to stay read-only, do not allow permission change
1729      * to r/w */
1730     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1731         reopen_state->flags & BDRV_O_RDWR) {
1732         error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1733                   reopen_state->bs->device_name);
1734         goto error;
1735     }
1736
1737
1738     ret = bdrv_flush(reopen_state->bs);
1739     if (ret) {
1740         error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1741                   strerror(-ret));
1742         goto error;
1743     }
1744
1745     if (drv->bdrv_reopen_prepare) {
1746         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1747         if (ret) {
1748             if (local_err != NULL) {
1749                 error_propagate(errp, local_err);
1750             } else {
1751                 error_setg(errp, "failed while preparing to reopen image '%s'",
1752                            reopen_state->bs->filename);
1753             }
1754             goto error;
1755         }
1756     } else {
1757         /* It is currently mandatory to have a bdrv_reopen_prepare()
1758          * handler for each supported drv. */
1759         error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1760                   drv->format_name, reopen_state->bs->device_name,
1761                  "reopening of file");
1762         ret = -1;
1763         goto error;
1764     }
1765
1766     ret = 0;
1767
1768 error:
1769     return ret;
1770 }
1771
1772 /*
1773  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1774  * makes them final by swapping the staging BlockDriverState contents into
1775  * the active BlockDriverState contents.
1776  */
1777 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1778 {
1779     BlockDriver *drv;
1780
1781     assert(reopen_state != NULL);
1782     drv = reopen_state->bs->drv;
1783     assert(drv != NULL);
1784
1785     /* If there are any driver level actions to take */
1786     if (drv->bdrv_reopen_commit) {
1787         drv->bdrv_reopen_commit(reopen_state);
1788     }
1789
1790     /* set BDS specific flags now */
1791     reopen_state->bs->open_flags         = reopen_state->flags;
1792     reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1793                                               BDRV_O_CACHE_WB);
1794     reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1795
1796     bdrv_refresh_limits(reopen_state->bs, NULL);
1797 }
1798
1799 /*
1800  * Abort the reopen, and delete and free the staged changes in
1801  * reopen_state
1802  */
1803 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1804 {
1805     BlockDriver *drv;
1806
1807     assert(reopen_state != NULL);
1808     drv = reopen_state->bs->drv;
1809     assert(drv != NULL);
1810
1811     if (drv->bdrv_reopen_abort) {
1812         drv->bdrv_reopen_abort(reopen_state);
1813     }
1814 }
1815
1816
1817 void bdrv_close(BlockDriverState *bs)
1818 {
1819     if (bs->job) {
1820         block_job_cancel_sync(bs->job);
1821     }
1822     bdrv_drain_all(); /* complete I/O */
1823     bdrv_flush(bs);
1824     bdrv_drain_all(); /* in case flush left pending I/O */
1825     notifier_list_notify(&bs->close_notifiers, bs);
1826
1827     if (bs->drv) {
1828         if (bs->backing_hd) {
1829             BlockDriverState *backing_hd = bs->backing_hd;
1830             bdrv_set_backing_hd(bs, NULL);
1831             bdrv_unref(backing_hd);
1832         }
1833         bs->drv->bdrv_close(bs);
1834         g_free(bs->opaque);
1835         bs->opaque = NULL;
1836         bs->drv = NULL;
1837         bs->copy_on_read = 0;
1838         bs->backing_file[0] = '\0';
1839         bs->backing_format[0] = '\0';
1840         bs->total_sectors = 0;
1841         bs->encrypted = 0;
1842         bs->valid_key = 0;
1843         bs->sg = 0;
1844         bs->growable = 0;
1845         bs->zero_beyond_eof = false;
1846         QDECREF(bs->options);
1847         bs->options = NULL;
1848
1849         if (bs->file != NULL) {
1850             bdrv_unref(bs->file);
1851             bs->file = NULL;
1852         }
1853     }
1854
1855     bdrv_dev_change_media_cb(bs, false);
1856
1857     /*throttling disk I/O limits*/
1858     if (bs->io_limits_enabled) {
1859         bdrv_io_limits_disable(bs);
1860     }
1861 }
1862
1863 void bdrv_close_all(void)
1864 {
1865     BlockDriverState *bs;
1866
1867     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1868         AioContext *aio_context = bdrv_get_aio_context(bs);
1869
1870         aio_context_acquire(aio_context);
1871         bdrv_close(bs);
1872         aio_context_release(aio_context);
1873     }
1874 }
1875
1876 /* Check if any requests are in-flight (including throttled requests) */
1877 static bool bdrv_requests_pending(BlockDriverState *bs)
1878 {
1879     if (!QLIST_EMPTY(&bs->tracked_requests)) {
1880         return true;
1881     }
1882     if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1883         return true;
1884     }
1885     if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1886         return true;
1887     }
1888     if (bs->file && bdrv_requests_pending(bs->file)) {
1889         return true;
1890     }
1891     if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1892         return true;
1893     }
1894     return false;
1895 }
1896
1897 /*
1898  * Wait for pending requests to complete across all BlockDriverStates
1899  *
1900  * This function does not flush data to disk, use bdrv_flush_all() for that
1901  * after calling this function.
1902  *
1903  * Note that completion of an asynchronous I/O operation can trigger any
1904  * number of other I/O operations on other devices---for example a coroutine
1905  * can be arbitrarily complex and a constant flow of I/O can come until the
1906  * coroutine is complete.  Because of this, it is not possible to have a
1907  * function to drain a single device's I/O queue.
1908  */
1909 void bdrv_drain_all(void)
1910 {
1911     /* Always run first iteration so any pending completion BHs run */
1912     bool busy = true;
1913     BlockDriverState *bs;
1914
1915     while (busy) {
1916         busy = false;
1917
1918         QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1919             AioContext *aio_context = bdrv_get_aio_context(bs);
1920             bool bs_busy;
1921
1922             aio_context_acquire(aio_context);
1923             bdrv_flush_io_queue(bs);
1924             bdrv_start_throttled_reqs(bs);
1925             bs_busy = bdrv_requests_pending(bs);
1926             bs_busy |= aio_poll(aio_context, bs_busy);
1927             aio_context_release(aio_context);
1928
1929             busy |= bs_busy;
1930         }
1931     }
1932 }
1933
1934 /* make a BlockDriverState anonymous by removing from bdrv_state and
1935  * graph_bdrv_state list.
1936    Also, NULL terminate the device_name to prevent double remove */
1937 void bdrv_make_anon(BlockDriverState *bs)
1938 {
1939     if (bs->device_name[0] != '\0') {
1940         QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1941     }
1942     bs->device_name[0] = '\0';
1943     if (bs->node_name[0] != '\0') {
1944         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1945     }
1946     bs->node_name[0] = '\0';
1947 }
1948
1949 static void bdrv_rebind(BlockDriverState *bs)
1950 {
1951     if (bs->drv && bs->drv->bdrv_rebind) {
1952         bs->drv->bdrv_rebind(bs);
1953     }
1954 }
1955
1956 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1957                                      BlockDriverState *bs_src)
1958 {
1959     /* move some fields that need to stay attached to the device */
1960
1961     /* dev info */
1962     bs_dest->dev_ops            = bs_src->dev_ops;
1963     bs_dest->dev_opaque         = bs_src->dev_opaque;
1964     bs_dest->dev                = bs_src->dev;
1965     bs_dest->guest_block_size   = bs_src->guest_block_size;
1966     bs_dest->copy_on_read       = bs_src->copy_on_read;
1967
1968     bs_dest->enable_write_cache = bs_src->enable_write_cache;
1969
1970     /* i/o throttled req */
1971     memcpy(&bs_dest->throttle_state,
1972            &bs_src->throttle_state,
1973            sizeof(ThrottleState));
1974     bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
1975     bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
1976     bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1977
1978     /* r/w error */
1979     bs_dest->on_read_error      = bs_src->on_read_error;
1980     bs_dest->on_write_error     = bs_src->on_write_error;
1981
1982     /* i/o status */
1983     bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
1984     bs_dest->iostatus           = bs_src->iostatus;
1985
1986     /* dirty bitmap */
1987     bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1988
1989     /* reference count */
1990     bs_dest->refcnt             = bs_src->refcnt;
1991
1992     /* job */
1993     bs_dest->job                = bs_src->job;
1994
1995     /* keep the same entry in bdrv_states */
1996     pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1997             bs_src->device_name);
1998     bs_dest->device_list = bs_src->device_list;
1999     memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2000            sizeof(bs_dest->op_blockers));
2001 }
2002
2003 /*
2004  * Swap bs contents for two image chains while they are live,
2005  * while keeping required fields on the BlockDriverState that is
2006  * actually attached to a device.
2007  *
2008  * This will modify the BlockDriverState fields, and swap contents
2009  * between bs_new and bs_old. Both bs_new and bs_old are modified.
2010  *
2011  * bs_new is required to be anonymous.
2012  *
2013  * This function does not create any image files.
2014  */
2015 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2016 {
2017     BlockDriverState tmp;
2018
2019     /* The code needs to swap the node_name but simply swapping node_list won't
2020      * work so first remove the nodes from the graph list, do the swap then
2021      * insert them back if needed.
2022      */
2023     if (bs_new->node_name[0] != '\0') {
2024         QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2025     }
2026     if (bs_old->node_name[0] != '\0') {
2027         QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2028     }
2029
2030     /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2031     assert(bs_new->device_name[0] == '\0');
2032     assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2033     assert(bs_new->job == NULL);
2034     assert(bs_new->dev == NULL);
2035     assert(bs_new->io_limits_enabled == false);
2036     assert(!throttle_have_timer(&bs_new->throttle_state));
2037
2038     tmp = *bs_new;
2039     *bs_new = *bs_old;
2040     *bs_old = tmp;
2041
2042     /* there are some fields that should not be swapped, move them back */
2043     bdrv_move_feature_fields(&tmp, bs_old);
2044     bdrv_move_feature_fields(bs_old, bs_new);
2045     bdrv_move_feature_fields(bs_new, &tmp);
2046
2047     /* bs_new shouldn't be in bdrv_states even after the swap!  */
2048     assert(bs_new->device_name[0] == '\0');
2049
2050     /* Check a few fields that should remain attached to the device */
2051     assert(bs_new->dev == NULL);
2052     assert(bs_new->job == NULL);
2053     assert(bs_new->io_limits_enabled == false);
2054     assert(!throttle_have_timer(&bs_new->throttle_state));
2055
2056     /* insert the nodes back into the graph node list if needed */
2057     if (bs_new->node_name[0] != '\0') {
2058         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2059     }
2060     if (bs_old->node_name[0] != '\0') {
2061         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2062     }
2063
2064     bdrv_rebind(bs_new);
2065     bdrv_rebind(bs_old);
2066 }
2067
2068 /*
2069  * Add new bs contents at the top of an image chain while the chain is
2070  * live, while keeping required fields on the top layer.
2071  *
2072  * This will modify the BlockDriverState fields, and swap contents
2073  * between bs_new and bs_top. Both bs_new and bs_top are modified.
2074  *
2075  * bs_new is required to be anonymous.
2076  *
2077  * This function does not create any image files.
2078  */
2079 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2080 {
2081     bdrv_swap(bs_new, bs_top);
2082
2083     /* The contents of 'tmp' will become bs_top, as we are
2084      * swapping bs_new and bs_top contents. */
2085     bdrv_set_backing_hd(bs_top, bs_new);
2086 }
2087
2088 static void bdrv_delete(BlockDriverState *bs)
2089 {
2090     assert(!bs->dev);
2091     assert(!bs->job);
2092     assert(bdrv_op_blocker_is_empty(bs));
2093     assert(!bs->refcnt);
2094     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2095
2096     bdrv_close(bs);
2097
2098     /* remove from list, if necessary */
2099     bdrv_make_anon(bs);
2100
2101     g_free(bs);
2102 }
2103
2104 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2105 /* TODO change to DeviceState *dev when all users are qdevified */
2106 {
2107     if (bs->dev) {
2108         return -EBUSY;
2109     }
2110     bs->dev = dev;
2111     bdrv_iostatus_reset(bs);
2112
2113     /* We're expecting I/O from the device so bump up coroutine pool size */
2114     qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION);
2115     return 0;
2116 }
2117
2118 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2119 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2120 {
2121     if (bdrv_attach_dev(bs, dev) < 0) {
2122         abort();
2123     }
2124 }
2125
2126 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2127 /* TODO change to DeviceState *dev when all users are qdevified */
2128 {
2129     assert(bs->dev == dev);
2130     bs->dev = NULL;
2131     bs->dev_ops = NULL;
2132     bs->dev_opaque = NULL;
2133     bs->guest_block_size = 512;
2134     qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION);
2135 }
2136
2137 /* TODO change to return DeviceState * when all users are qdevified */
2138 void *bdrv_get_attached_dev(BlockDriverState *bs)
2139 {
2140     return bs->dev;
2141 }
2142
2143 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2144                       void *opaque)
2145 {
2146     bs->dev_ops = ops;
2147     bs->dev_opaque = opaque;
2148 }
2149
2150 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2151 {
2152     if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2153         bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2154         bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2155         if (tray_was_closed) {
2156             /* tray open */
2157             qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2158                                               true, &error_abort);
2159         }
2160         if (load) {
2161             /* tray close */
2162             qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2163                                               false, &error_abort);
2164         }
2165     }
2166 }
2167
2168 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2169 {
2170     return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2171 }
2172
2173 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2174 {
2175     if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2176         bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2177     }
2178 }
2179
2180 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2181 {
2182     if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2183         return bs->dev_ops->is_tray_open(bs->dev_opaque);
2184     }
2185     return false;
2186 }
2187
2188 static void bdrv_dev_resize_cb(BlockDriverState *bs)
2189 {
2190     if (bs->dev_ops && bs->dev_ops->resize_cb) {
2191         bs->dev_ops->resize_cb(bs->dev_opaque);
2192     }
2193 }
2194
2195 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2196 {
2197     if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2198         return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2199     }
2200     return false;
2201 }
2202
2203 /*
2204  * Run consistency checks on an image
2205  *
2206  * Returns 0 if the check could be completed (it doesn't mean that the image is
2207  * free of errors) or -errno when an internal error occurred. The results of the
2208  * check are stored in res.
2209  */
2210 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2211 {
2212     if (bs->drv == NULL) {
2213         return -ENOMEDIUM;
2214     }
2215     if (bs->drv->bdrv_check == NULL) {
2216         return -ENOTSUP;
2217     }
2218
2219     memset(res, 0, sizeof(*res));
2220     return bs->drv->bdrv_check(bs, res, fix);
2221 }
2222
2223 #define COMMIT_BUF_SECTORS 2048
2224
2225 /* commit COW file into the raw image */
2226 int bdrv_commit(BlockDriverState *bs)
2227 {
2228     BlockDriver *drv = bs->drv;
2229     int64_t sector, total_sectors, length, backing_length;
2230     int n, ro, open_flags;
2231     int ret = 0;
2232     uint8_t *buf = NULL;
2233     char filename[PATH_MAX];
2234
2235     if (!drv)
2236         return -ENOMEDIUM;
2237
2238     if (!bs->backing_hd) {
2239         return -ENOTSUP;
2240     }
2241
2242     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2243         bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2244         return -EBUSY;
2245     }
2246
2247     ro = bs->backing_hd->read_only;
2248     /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2249     pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2250     open_flags =  bs->backing_hd->open_flags;
2251
2252     if (ro) {
2253         if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2254             return -EACCES;
2255         }
2256     }
2257
2258     length = bdrv_getlength(bs);
2259     if (length < 0) {
2260         ret = length;
2261         goto ro_cleanup;
2262     }
2263
2264     backing_length = bdrv_getlength(bs->backing_hd);
2265     if (backing_length < 0) {
2266         ret = backing_length;
2267         goto ro_cleanup;
2268     }
2269
2270     /* If our top snapshot is larger than the backing file image,
2271      * grow the backing file image if possible.  If not possible,
2272      * we must return an error */
2273     if (length > backing_length) {
2274         ret = bdrv_truncate(bs->backing_hd, length);
2275         if (ret < 0) {
2276             goto ro_cleanup;
2277         }
2278     }
2279
2280     total_sectors = length >> BDRV_SECTOR_BITS;
2281
2282     /* qemu_try_blockalign() for bs will choose an alignment that works for
2283      * bs->backing_hd as well, so no need to compare the alignment manually. */
2284     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2285     if (buf == NULL) {
2286         ret = -ENOMEM;
2287         goto ro_cleanup;
2288     }
2289
2290     for (sector = 0; sector < total_sectors; sector += n) {
2291         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2292         if (ret < 0) {
2293             goto ro_cleanup;
2294         }
2295         if (ret) {
2296             ret = bdrv_read(bs, sector, buf, n);
2297             if (ret < 0) {
2298                 goto ro_cleanup;
2299             }
2300
2301             ret = bdrv_write(bs->backing_hd, sector, buf, n);
2302             if (ret < 0) {
2303                 goto ro_cleanup;
2304             }
2305         }
2306     }
2307
2308     if (drv->bdrv_make_empty) {
2309         ret = drv->bdrv_make_empty(bs);
2310         if (ret < 0) {
2311             goto ro_cleanup;
2312         }
2313         bdrv_flush(bs);
2314     }
2315
2316     /*
2317      * Make sure all data we wrote to the backing device is actually
2318      * stable on disk.
2319      */
2320     if (bs->backing_hd) {
2321         bdrv_flush(bs->backing_hd);
2322     }
2323
2324     ret = 0;
2325 ro_cleanup:
2326     qemu_vfree(buf);
2327
2328     if (ro) {
2329         /* ignoring error return here */
2330         bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2331     }
2332
2333     return ret;
2334 }
2335
2336 int bdrv_commit_all(void)
2337 {
2338     BlockDriverState *bs;
2339
2340     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2341         AioContext *aio_context = bdrv_get_aio_context(bs);
2342
2343         aio_context_acquire(aio_context);
2344         if (bs->drv && bs->backing_hd) {
2345             int ret = bdrv_commit(bs);
2346             if (ret < 0) {
2347                 aio_context_release(aio_context);
2348                 return ret;
2349             }
2350         }
2351         aio_context_release(aio_context);
2352     }
2353     return 0;
2354 }
2355
2356 /**
2357  * Remove an active request from the tracked requests list
2358  *
2359  * This function should be called when a tracked request is completing.
2360  */
2361 static void tracked_request_end(BdrvTrackedRequest *req)
2362 {
2363     if (req->serialising) {
2364         req->bs->serialising_in_flight--;
2365     }
2366
2367     QLIST_REMOVE(req, list);
2368     qemu_co_queue_restart_all(&req->wait_queue);
2369 }
2370
2371 /**
2372  * Add an active request to the tracked requests list
2373  */
2374 static void tracked_request_begin(BdrvTrackedRequest *req,
2375                                   BlockDriverState *bs,
2376                                   int64_t offset,
2377                                   unsigned int bytes, bool is_write)
2378 {
2379     *req = (BdrvTrackedRequest){
2380         .bs = bs,
2381         .offset         = offset,
2382         .bytes          = bytes,
2383         .is_write       = is_write,
2384         .co             = qemu_coroutine_self(),
2385         .serialising    = false,
2386         .overlap_offset = offset,
2387         .overlap_bytes  = bytes,
2388     };
2389
2390     qemu_co_queue_init(&req->wait_queue);
2391
2392     QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2393 }
2394
2395 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2396 {
2397     int64_t overlap_offset = req->offset & ~(align - 1);
2398     unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2399                                - overlap_offset;
2400
2401     if (!req->serialising) {
2402         req->bs->serialising_in_flight++;
2403         req->serialising = true;
2404     }
2405
2406     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2407     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2408 }
2409
2410 /**
2411  * Round a region to cluster boundaries
2412  */
2413 void bdrv_round_to_clusters(BlockDriverState *bs,
2414                             int64_t sector_num, int nb_sectors,
2415                             int64_t *cluster_sector_num,
2416                             int *cluster_nb_sectors)
2417 {
2418     BlockDriverInfo bdi;
2419
2420     if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2421         *cluster_sector_num = sector_num;
2422         *cluster_nb_sectors = nb_sectors;
2423     } else {
2424         int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2425         *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2426         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2427                                             nb_sectors, c);
2428     }
2429 }
2430
2431 static int bdrv_get_cluster_size(BlockDriverState *bs)
2432 {
2433     BlockDriverInfo bdi;
2434     int ret;
2435
2436     ret = bdrv_get_info(bs, &bdi);
2437     if (ret < 0 || bdi.cluster_size == 0) {
2438         return bs->request_alignment;
2439     } else {
2440         return bdi.cluster_size;
2441     }
2442 }
2443
2444 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2445                                      int64_t offset, unsigned int bytes)
2446 {
2447     /*        aaaa   bbbb */
2448     if (offset >= req->overlap_offset + req->overlap_bytes) {
2449         return false;
2450     }
2451     /* bbbb   aaaa        */
2452     if (req->overlap_offset >= offset + bytes) {
2453         return false;
2454     }
2455     return true;
2456 }
2457
2458 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2459 {
2460     BlockDriverState *bs = self->bs;
2461     BdrvTrackedRequest *req;
2462     bool retry;
2463     bool waited = false;
2464
2465     if (!bs->serialising_in_flight) {
2466         return false;
2467     }
2468
2469     do {
2470         retry = false;
2471         QLIST_FOREACH(req, &bs->tracked_requests, list) {
2472             if (req == self || (!req->serialising && !self->serialising)) {
2473                 continue;
2474             }
2475             if (tracked_request_overlaps(req, self->overlap_offset,
2476                                          self->overlap_bytes))
2477             {
2478                 /* Hitting this means there was a reentrant request, for
2479                  * example, a block driver issuing nested requests.  This must
2480                  * never happen since it means deadlock.
2481                  */
2482                 assert(qemu_coroutine_self() != req->co);
2483
2484                 /* If the request is already (indirectly) waiting for us, or
2485                  * will wait for us as soon as it wakes up, then just go on
2486                  * (instead of producing a deadlock in the former case). */
2487                 if (!req->waiting_for) {
2488                     self->waiting_for = req;
2489                     qemu_co_queue_wait(&req->wait_queue);
2490                     self->waiting_for = NULL;
2491                     retry = true;
2492                     waited = true;
2493                     break;
2494                 }
2495             }
2496         }
2497     } while (retry);
2498
2499     return waited;
2500 }
2501
2502 /*
2503  * Return values:
2504  * 0        - success
2505  * -EINVAL  - backing format specified, but no file
2506  * -ENOSPC  - can't update the backing file because no space is left in the
2507  *            image file header
2508  * -ENOTSUP - format driver doesn't support changing the backing file
2509  */
2510 int bdrv_change_backing_file(BlockDriverState *bs,
2511     const char *backing_file, const char *backing_fmt)
2512 {
2513     BlockDriver *drv = bs->drv;
2514     int ret;
2515
2516     /* Backing file format doesn't make sense without a backing file */
2517     if (backing_fmt && !backing_file) {
2518         return -EINVAL;
2519     }
2520
2521     if (drv->bdrv_change_backing_file != NULL) {
2522         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2523     } else {
2524         ret = -ENOTSUP;
2525     }
2526
2527     if (ret == 0) {
2528         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2529         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2530     }
2531     return ret;
2532 }
2533
2534 /*
2535  * Finds the image layer in the chain that has 'bs' as its backing file.
2536  *
2537  * active is the current topmost image.
2538  *
2539  * Returns NULL if bs is not found in active's image chain,
2540  * or if active == bs.
2541  *
2542  * Returns the bottommost base image if bs == NULL.
2543  */
2544 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2545                                     BlockDriverState *bs)
2546 {
2547     while (active && bs != active->backing_hd) {
2548         active = active->backing_hd;
2549     }
2550
2551     return active;
2552 }
2553
2554 /* Given a BDS, searches for the base layer. */
2555 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2556 {
2557     return bdrv_find_overlay(bs, NULL);
2558 }
2559
2560 typedef struct BlkIntermediateStates {
2561     BlockDriverState *bs;
2562     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2563 } BlkIntermediateStates;
2564
2565
2566 /*
2567  * Drops images above 'base' up to and including 'top', and sets the image
2568  * above 'top' to have base as its backing file.
2569  *
2570  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2571  * information in 'bs' can be properly updated.
2572  *
2573  * E.g., this will convert the following chain:
2574  * bottom <- base <- intermediate <- top <- active
2575  *
2576  * to
2577  *
2578  * bottom <- base <- active
2579  *
2580  * It is allowed for bottom==base, in which case it converts:
2581  *
2582  * base <- intermediate <- top <- active
2583  *
2584  * to
2585  *
2586  * base <- active
2587  *
2588  * If backing_file_str is non-NULL, it will be used when modifying top's
2589  * overlay image metadata.
2590  *
2591  * Error conditions:
2592  *  if active == top, that is considered an error
2593  *
2594  */
2595 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2596                            BlockDriverState *base, const char *backing_file_str)
2597 {
2598     BlockDriverState *intermediate;
2599     BlockDriverState *base_bs = NULL;
2600     BlockDriverState *new_top_bs = NULL;
2601     BlkIntermediateStates *intermediate_state, *next;
2602     int ret = -EIO;
2603
2604     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2605     QSIMPLEQ_INIT(&states_to_delete);
2606
2607     if (!top->drv || !base->drv) {
2608         goto exit;
2609     }
2610
2611     new_top_bs = bdrv_find_overlay(active, top);
2612
2613     if (new_top_bs == NULL) {
2614         /* we could not find the image above 'top', this is an error */
2615         goto exit;
2616     }
2617
2618     /* special case of new_top_bs->backing_hd already pointing to base - nothing
2619      * to do, no intermediate images */
2620     if (new_top_bs->backing_hd == base) {
2621         ret = 0;
2622         goto exit;
2623     }
2624
2625     intermediate = top;
2626
2627     /* now we will go down through the list, and add each BDS we find
2628      * into our deletion queue, until we hit the 'base'
2629      */
2630     while (intermediate) {
2631         intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2632         intermediate_state->bs = intermediate;
2633         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2634
2635         if (intermediate->backing_hd == base) {
2636             base_bs = intermediate->backing_hd;
2637             break;
2638         }
2639         intermediate = intermediate->backing_hd;
2640     }
2641     if (base_bs == NULL) {
2642         /* something went wrong, we did not end at the base. safely
2643          * unravel everything, and exit with error */
2644         goto exit;
2645     }
2646
2647     /* success - we can delete the intermediate states, and link top->base */
2648     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2649     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2650                                    base_bs->drv ? base_bs->drv->format_name : "");
2651     if (ret) {
2652         goto exit;
2653     }
2654     bdrv_set_backing_hd(new_top_bs, base_bs);
2655
2656     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2657         /* so that bdrv_close() does not recursively close the chain */
2658         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2659         bdrv_unref(intermediate_state->bs);
2660     }
2661     ret = 0;
2662
2663 exit:
2664     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2665         g_free(intermediate_state);
2666     }
2667     return ret;
2668 }
2669
2670
2671 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2672                                    size_t size)
2673 {
2674     int64_t len;
2675
2676     if (size > INT_MAX) {
2677         return -EIO;
2678     }
2679
2680     if (!bdrv_is_inserted(bs))
2681         return -ENOMEDIUM;
2682
2683     if (bs->growable)
2684         return 0;
2685
2686     len = bdrv_getlength(bs);
2687
2688     if (offset < 0)
2689         return -EIO;
2690
2691     if ((offset > len) || (len - offset < size))
2692         return -EIO;
2693
2694     return 0;
2695 }
2696
2697 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2698                               int nb_sectors)
2699 {
2700     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2701         return -EIO;
2702     }
2703
2704     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2705                                    nb_sectors * BDRV_SECTOR_SIZE);
2706 }
2707
2708 typedef struct RwCo {
2709     BlockDriverState *bs;
2710     int64_t offset;
2711     QEMUIOVector *qiov;
2712     bool is_write;
2713     int ret;
2714     BdrvRequestFlags flags;
2715 } RwCo;
2716
2717 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2718 {
2719     RwCo *rwco = opaque;
2720
2721     if (!rwco->is_write) {
2722         rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2723                                       rwco->qiov->size, rwco->qiov,
2724                                       rwco->flags);
2725     } else {
2726         rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2727                                        rwco->qiov->size, rwco->qiov,
2728                                        rwco->flags);
2729     }
2730 }
2731
2732 /*
2733  * Process a vectored synchronous request using coroutines
2734  */
2735 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2736                         QEMUIOVector *qiov, bool is_write,
2737                         BdrvRequestFlags flags)
2738 {
2739     Coroutine *co;
2740     RwCo rwco = {
2741         .bs = bs,
2742         .offset = offset,
2743         .qiov = qiov,
2744         .is_write = is_write,
2745         .ret = NOT_DONE,
2746         .flags = flags,
2747     };
2748
2749     /**
2750      * In sync call context, when the vcpu is blocked, this throttling timer
2751      * will not fire; so the I/O throttling function has to be disabled here
2752      * if it has been enabled.
2753      */
2754     if (bs->io_limits_enabled) {
2755         fprintf(stderr, "Disabling I/O throttling on '%s' due "
2756                         "to synchronous I/O.\n", bdrv_get_device_name(bs));
2757         bdrv_io_limits_disable(bs);
2758     }
2759
2760     if (qemu_in_coroutine()) {
2761         /* Fast-path if already in coroutine context */
2762         bdrv_rw_co_entry(&rwco);
2763     } else {
2764         AioContext *aio_context = bdrv_get_aio_context(bs);
2765
2766         co = qemu_coroutine_create(bdrv_rw_co_entry);
2767         qemu_coroutine_enter(co, &rwco);
2768         while (rwco.ret == NOT_DONE) {
2769             aio_poll(aio_context, true);
2770         }
2771     }
2772     return rwco.ret;
2773 }
2774
2775 /*
2776  * Process a synchronous request using coroutines
2777  */
2778 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2779                       int nb_sectors, bool is_write, BdrvRequestFlags flags)
2780 {
2781     QEMUIOVector qiov;
2782     struct iovec iov = {
2783         .iov_base = (void *)buf,
2784         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2785     };
2786
2787     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2788         return -EINVAL;
2789     }
2790
2791     qemu_iovec_init_external(&qiov, &iov, 1);
2792     return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2793                         &qiov, is_write, flags);
2794 }
2795
2796 /* return < 0 if error. See bdrv_write() for the return codes */
2797 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2798               uint8_t *buf, int nb_sectors)
2799 {
2800     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2801 }
2802
2803 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2804 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2805                           uint8_t *buf, int nb_sectors)
2806 {
2807     bool enabled;
2808     int ret;
2809
2810     enabled = bs->io_limits_enabled;
2811     bs->io_limits_enabled = false;
2812     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2813     bs->io_limits_enabled = enabled;
2814     return ret;
2815 }
2816
2817 /* Return < 0 if error. Important errors are:
2818   -EIO         generic I/O error (may happen for all errors)
2819   -ENOMEDIUM   No media inserted.
2820   -EINVAL      Invalid sector number or nb_sectors
2821   -EACCES      Trying to write a read-only device
2822 */
2823 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2824                const uint8_t *buf, int nb_sectors)
2825 {
2826     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2827 }
2828
2829 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2830                       int nb_sectors, BdrvRequestFlags flags)
2831 {
2832     return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2833                       BDRV_REQ_ZERO_WRITE | flags);
2834 }
2835
2836 /*
2837  * Completely zero out a block device with the help of bdrv_write_zeroes.
2838  * The operation is sped up by checking the block status and only writing
2839  * zeroes to the device if they currently do not return zeroes. Optional
2840  * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2841  *
2842  * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2843  */
2844 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2845 {
2846     int64_t target_sectors, ret, nb_sectors, sector_num = 0;
2847     int n;
2848
2849     target_sectors = bdrv_nb_sectors(bs);
2850     if (target_sectors < 0) {
2851         return target_sectors;
2852     }
2853
2854     for (;;) {
2855         nb_sectors = target_sectors - sector_num;
2856         if (nb_sectors <= 0) {
2857             return 0;
2858         }
2859         if (nb_sectors > INT_MAX) {
2860             nb_sectors = INT_MAX;
2861         }
2862         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2863         if (ret < 0) {
2864             error_report("error getting block status at sector %" PRId64 ": %s",
2865                          sector_num, strerror(-ret));
2866             return ret;
2867         }
2868         if (ret & BDRV_BLOCK_ZERO) {
2869             sector_num += n;
2870             continue;
2871         }
2872         ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2873         if (ret < 0) {
2874             error_report("error writing zeroes at sector %" PRId64 ": %s",
2875                          sector_num, strerror(-ret));
2876             return ret;
2877         }
2878         sector_num += n;
2879     }
2880 }
2881
2882 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2883 {
2884     QEMUIOVector qiov;
2885     struct iovec iov = {
2886         .iov_base = (void *)buf,
2887         .iov_len = bytes,
2888     };
2889     int ret;
2890
2891     if (bytes < 0) {
2892         return -EINVAL;
2893     }
2894
2895     qemu_iovec_init_external(&qiov, &iov, 1);
2896     ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2897     if (ret < 0) {
2898         return ret;
2899     }
2900
2901     return bytes;
2902 }
2903
2904 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2905 {
2906     int ret;
2907
2908     ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2909     if (ret < 0) {
2910         return ret;
2911     }
2912
2913     return qiov->size;
2914 }
2915
2916 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2917                 const void *buf, int bytes)
2918 {
2919     QEMUIOVector qiov;
2920     struct iovec iov = {
2921         .iov_base   = (void *) buf,
2922         .iov_len    = bytes,
2923     };
2924
2925     if (bytes < 0) {
2926         return -EINVAL;
2927     }
2928
2929     qemu_iovec_init_external(&qiov, &iov, 1);
2930     return bdrv_pwritev(bs, offset, &qiov);
2931 }
2932
2933 /*
2934  * Writes to the file and ensures that no writes are reordered across this
2935  * request (acts as a barrier)
2936  *
2937  * Returns 0 on success, -errno in error cases.
2938  */
2939 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2940     const void *buf, int count)
2941 {
2942     int ret;
2943
2944     ret = bdrv_pwrite(bs, offset, buf, count);
2945     if (ret < 0) {
2946         return ret;
2947     }
2948
2949     /* No flush needed for cache modes that already do it */
2950     if (bs->enable_write_cache) {
2951         bdrv_flush(bs);
2952     }
2953
2954     return 0;
2955 }
2956
2957 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2958         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2959 {
2960     /* Perform I/O through a temporary buffer so that users who scribble over
2961      * their read buffer while the operation is in progress do not end up
2962      * modifying the image file.  This is critical for zero-copy guest I/O
2963      * where anything might happen inside guest memory.
2964      */
2965     void *bounce_buffer;
2966
2967     BlockDriver *drv = bs->drv;
2968     struct iovec iov;
2969     QEMUIOVector bounce_qiov;
2970     int64_t cluster_sector_num;
2971     int cluster_nb_sectors;
2972     size_t skip_bytes;
2973     int ret;
2974
2975     /* Cover entire cluster so no additional backing file I/O is required when
2976      * allocating cluster in the image file.
2977      */
2978     bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2979                            &cluster_sector_num, &cluster_nb_sectors);
2980
2981     trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2982                                    cluster_sector_num, cluster_nb_sectors);
2983
2984     iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2985     iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
2986     if (bounce_buffer == NULL) {
2987         ret = -ENOMEM;
2988         goto err;
2989     }
2990
2991     qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2992
2993     ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2994                              &bounce_qiov);
2995     if (ret < 0) {
2996         goto err;
2997     }
2998
2999     if (drv->bdrv_co_write_zeroes &&
3000         buffer_is_zero(bounce_buffer, iov.iov_len)) {
3001         ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
3002                                       cluster_nb_sectors, 0);
3003     } else {
3004         /* This does not change the data on the disk, it is not necessary
3005          * to flush even in cache=writethrough mode.
3006          */
3007         ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
3008                                   &bounce_qiov);
3009     }
3010
3011     if (ret < 0) {
3012         /* It might be okay to ignore write errors for guest requests.  If this
3013          * is a deliberate copy-on-read then we don't want to ignore the error.
3014          * Simply report it in all cases.
3015          */
3016         goto err;
3017     }
3018
3019     skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3020     qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3021                         nb_sectors * BDRV_SECTOR_SIZE);
3022
3023 err:
3024     qemu_vfree(bounce_buffer);
3025     return ret;
3026 }
3027
3028 /*
3029  * Forwards an already correctly aligned request to the BlockDriver. This
3030  * handles copy on read and zeroing after EOF; any other features must be
3031  * implemented by the caller.
3032  */
3033 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3034     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3035     int64_t align, QEMUIOVector *qiov, int flags)
3036 {
3037     BlockDriver *drv = bs->drv;
3038     int ret;
3039
3040     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3041     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3042
3043     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3044     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3045     assert(!qiov || bytes == qiov->size);
3046
3047     /* Handle Copy on Read and associated serialisation */
3048     if (flags & BDRV_REQ_COPY_ON_READ) {
3049         /* If we touch the same cluster it counts as an overlap.  This
3050          * guarantees that allocating writes will be serialized and not race
3051          * with each other for the same cluster.  For example, in copy-on-read
3052          * it ensures that the CoR read and write operations are atomic and
3053          * guest writes cannot interleave between them. */
3054         mark_request_serialising(req, bdrv_get_cluster_size(bs));
3055     }
3056
3057     wait_serialising_requests(req);
3058
3059     if (flags & BDRV_REQ_COPY_ON_READ) {
3060         int pnum;
3061
3062         ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3063         if (ret < 0) {
3064             goto out;
3065         }
3066
3067         if (!ret || pnum != nb_sectors) {
3068             ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3069             goto out;
3070         }
3071     }
3072
3073     /* Forward the request to the BlockDriver */
3074     if (!(bs->zero_beyond_eof && bs->growable)) {
3075         ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3076     } else {
3077         /* Read zeros after EOF of growable BDSes */
3078         int64_t total_sectors, max_nb_sectors;
3079
3080         total_sectors = bdrv_nb_sectors(bs);
3081         if (total_sectors < 0) {
3082             ret = total_sectors;
3083             goto out;
3084         }
3085
3086         max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3087                                   align >> BDRV_SECTOR_BITS);
3088         if (max_nb_sectors > 0) {
3089             QEMUIOVector local_qiov;
3090             size_t local_sectors;
3091
3092             max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
3093             local_sectors = MIN(max_nb_sectors, nb_sectors);
3094
3095             qemu_iovec_init(&local_qiov, qiov->niov);
3096             qemu_iovec_concat(&local_qiov, qiov, 0,
3097                               local_sectors * BDRV_SECTOR_SIZE);
3098
3099             ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
3100                                      &local_qiov);
3101
3102             qemu_iovec_destroy(&local_qiov);
3103         } else {
3104             ret = 0;
3105         }
3106
3107         /* Reading beyond end of file is supposed to produce zeroes */
3108         if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3109             uint64_t offset = MAX(0, total_sectors - sector_num);
3110             uint64_t bytes = (sector_num + nb_sectors - offset) *
3111                               BDRV_SECTOR_SIZE;
3112             qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3113         }
3114     }
3115
3116 out:
3117     return ret;
3118 }
3119
3120 /*
3121  * Handle a read request in coroutine context
3122  */
3123 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3124     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3125     BdrvRequestFlags flags)
3126 {
3127     BlockDriver *drv = bs->drv;
3128     BdrvTrackedRequest req;
3129
3130     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3131     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3132     uint8_t *head_buf = NULL;
3133     uint8_t *tail_buf = NULL;
3134     QEMUIOVector local_qiov;
3135     bool use_local_qiov = false;
3136     int ret;
3137
3138     if (!drv) {
3139         return -ENOMEDIUM;
3140     }
3141     if (bdrv_check_byte_request(bs, offset, bytes)) {
3142         return -EIO;
3143     }
3144
3145     if (bs->copy_on_read) {
3146         flags |= BDRV_REQ_COPY_ON_READ;
3147     }
3148
3149     /* throttling disk I/O */
3150     if (bs->io_limits_enabled) {
3151         bdrv_io_limits_intercept(bs, bytes, false);
3152     }
3153
3154     /* Align read if necessary by padding qiov */
3155     if (offset & (align - 1)) {
3156         head_buf = qemu_blockalign(bs, align);
3157         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3158         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3159         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3160         use_local_qiov = true;
3161
3162         bytes += offset & (align - 1);
3163         offset = offset & ~(align - 1);
3164     }
3165
3166     if ((offset + bytes) & (align - 1)) {
3167         if (!use_local_qiov) {
3168             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3169             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3170             use_local_qiov = true;
3171         }
3172         tail_buf = qemu_blockalign(bs, align);
3173         qemu_iovec_add(&local_qiov, tail_buf,
3174                        align - ((offset + bytes) & (align - 1)));
3175
3176         bytes = ROUND_UP(bytes, align);
3177     }
3178
3179     tracked_request_begin(&req, bs, offset, bytes, false);
3180     ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3181                               use_local_qiov ? &local_qiov : qiov,
3182                               flags);
3183     tracked_request_end(&req);
3184
3185     if (use_local_qiov) {
3186         qemu_iovec_destroy(&local_qiov);
3187         qemu_vfree(head_buf);
3188         qemu_vfree(tail_buf);
3189     }
3190
3191     return ret;
3192 }
3193
3194 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3195     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3196     BdrvRequestFlags flags)
3197 {
3198     if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3199         return -EINVAL;
3200     }
3201
3202     return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3203                              nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3204 }
3205
3206 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3207     int nb_sectors, QEMUIOVector *qiov)
3208 {
3209     trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3210
3211     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3212 }
3213
3214 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3215     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3216 {
3217     trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3218
3219     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3220                             BDRV_REQ_COPY_ON_READ);
3221 }
3222
3223 /* if no limit is specified in the BlockLimits use a default
3224  * of 32768 512-byte sectors (16 MiB) per request.
3225  */
3226 #define MAX_WRITE_ZEROES_DEFAULT 32768
3227
3228 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3229     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3230 {
3231     BlockDriver *drv = bs->drv;
3232     QEMUIOVector qiov;
3233     struct iovec iov = {0};
3234     int ret = 0;
3235
3236     int max_write_zeroes = bs->bl.max_write_zeroes ?
3237                            bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3238
3239     while (nb_sectors > 0 && !ret) {
3240         int num = nb_sectors;
3241
3242         /* Align request.  Block drivers can expect the "bulk" of the request
3243          * to be aligned.
3244          */
3245         if (bs->bl.write_zeroes_alignment
3246             && num > bs->bl.write_zeroes_alignment) {
3247             if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3248                 /* Make a small request up to the first aligned sector.  */
3249                 num = bs->bl.write_zeroes_alignment;
3250                 num -= sector_num % bs->bl.write_zeroes_alignment;
3251             } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3252                 /* Shorten the request to the last aligned sector.  num cannot
3253                  * underflow because num > bs->bl.write_zeroes_alignment.
3254                  */
3255                 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3256             }
3257         }
3258
3259         /* limit request size */
3260         if (num > max_write_zeroes) {
3261             num = max_write_zeroes;
3262         }
3263
3264         ret = -ENOTSUP;
3265         /* First try the efficient write zeroes operation */
3266         if (drv->bdrv_co_write_zeroes) {
3267             ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3268         }
3269
3270         if (ret == -ENOTSUP) {
3271             /* Fall back to bounce buffer if write zeroes is unsupported */
3272             iov.iov_len = num * BDRV_SECTOR_SIZE;
3273             if (iov.iov_base == NULL) {
3274                 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
3275                 if (iov.iov_base == NULL) {
3276                     ret = -ENOMEM;
3277                     goto fail;
3278                 }
3279                 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3280             }
3281             qemu_iovec_init_external(&qiov, &iov, 1);
3282
3283             ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3284
3285             /* Keep bounce buffer around if it is big enough for all
3286              * all future requests.
3287              */
3288             if (num < max_write_zeroes) {
3289                 qemu_vfree(iov.iov_base);
3290                 iov.iov_base = NULL;
3291             }
3292         }
3293
3294         sector_num += num;
3295         nb_sectors -= num;
3296     }
3297
3298 fail:
3299     qemu_vfree(iov.iov_base);
3300     return ret;
3301 }
3302
3303 /*
3304  * Forwards an already correctly aligned write request to the BlockDriver.
3305  */
3306 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3307     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3308     QEMUIOVector *qiov, int flags)
3309 {
3310     BlockDriver *drv = bs->drv;
3311     bool waited;
3312     int ret;
3313
3314     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3315     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3316
3317     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3318     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3319     assert(!qiov || bytes == qiov->size);
3320
3321     waited = wait_serialising_requests(req);
3322     assert(!waited || !req->serialising);
3323     assert(req->overlap_offset <= offset);
3324     assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3325
3326     ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3327
3328     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3329         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3330         qemu_iovec_is_zero(qiov)) {
3331         flags |= BDRV_REQ_ZERO_WRITE;
3332         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3333             flags |= BDRV_REQ_MAY_UNMAP;
3334         }
3335     }
3336
3337     if (ret < 0) {
3338         /* Do nothing, write notifier decided to fail this request */
3339     } else if (flags & BDRV_REQ_ZERO_WRITE) {
3340         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3341         ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3342     } else {
3343         BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3344         ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3345     }
3346     BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3347
3348     if (ret == 0 && !bs->enable_write_cache) {
3349         ret = bdrv_co_flush(bs);
3350     }
3351
3352     bdrv_set_dirty(bs, sector_num, nb_sectors);
3353
3354     if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3355         bs->wr_highest_sector = sector_num + nb_sectors - 1;
3356     }
3357     if (bs->growable && ret >= 0) {
3358         bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3359     }
3360
3361     return ret;
3362 }
3363
3364 /*
3365  * Handle a write request in coroutine context
3366  */
3367 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3368     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3369     BdrvRequestFlags flags)
3370 {
3371     BdrvTrackedRequest req;
3372     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3373     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3374     uint8_t *head_buf = NULL;
3375     uint8_t *tail_buf = NULL;
3376     QEMUIOVector local_qiov;
3377     bool use_local_qiov = false;
3378     int ret;
3379
3380     if (!bs->drv) {
3381         return -ENOMEDIUM;
3382     }
3383     if (bs->read_only) {
3384         return -EACCES;
3385     }
3386     if (bdrv_check_byte_request(bs, offset, bytes)) {
3387         return -EIO;
3388     }
3389
3390     /* throttling disk I/O */
3391     if (bs->io_limits_enabled) {
3392         bdrv_io_limits_intercept(bs, bytes, true);
3393     }
3394
3395     /*
3396      * Align write if necessary by performing a read-modify-write cycle.
3397      * Pad qiov with the read parts and be sure to have a tracked request not
3398      * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3399      */
3400     tracked_request_begin(&req, bs, offset, bytes, true);
3401
3402     if (offset & (align - 1)) {
3403         QEMUIOVector head_qiov;
3404         struct iovec head_iov;
3405
3406         mark_request_serialising(&req, align);
3407         wait_serialising_requests(&req);
3408
3409         head_buf = qemu_blockalign(bs, align);
3410         head_iov = (struct iovec) {
3411             .iov_base   = head_buf,
3412             .iov_len    = align,
3413         };
3414         qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3415
3416         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3417         ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3418                                   align, &head_qiov, 0);
3419         if (ret < 0) {
3420             goto fail;
3421         }
3422         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3423
3424         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3425         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3426         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3427         use_local_qiov = true;
3428
3429         bytes += offset & (align - 1);
3430         offset = offset & ~(align - 1);
3431     }
3432
3433     if ((offset + bytes) & (align - 1)) {
3434         QEMUIOVector tail_qiov;
3435         struct iovec tail_iov;
3436         size_t tail_bytes;
3437         bool waited;
3438
3439         mark_request_serialising(&req, align);
3440         waited = wait_serialising_requests(&req);
3441         assert(!waited || !use_local_qiov);
3442
3443         tail_buf = qemu_blockalign(bs, align);
3444         tail_iov = (struct iovec) {
3445             .iov_base   = tail_buf,
3446             .iov_len    = align,
3447         };
3448         qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3449
3450         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3451         ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3452                                   align, &tail_qiov, 0);
3453         if (ret < 0) {
3454             goto fail;
3455         }
3456         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3457
3458         if (!use_local_qiov) {
3459             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3460             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3461             use_local_qiov = true;
3462         }
3463
3464         tail_bytes = (offset + bytes) & (align - 1);
3465         qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3466
3467         bytes = ROUND_UP(bytes, align);
3468     }
3469
3470     ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3471                                use_local_qiov ? &local_qiov : qiov,
3472                                flags);
3473
3474 fail:
3475     tracked_request_end(&req);
3476
3477     if (use_local_qiov) {
3478         qemu_iovec_destroy(&local_qiov);
3479     }
3480     qemu_vfree(head_buf);
3481     qemu_vfree(tail_buf);
3482
3483     return ret;
3484 }
3485
3486 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3487     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3488     BdrvRequestFlags flags)
3489 {
3490     if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3491         return -EINVAL;
3492     }
3493
3494     return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3495                               nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3496 }
3497
3498 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3499     int nb_sectors, QEMUIOVector *qiov)
3500 {
3501     trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3502
3503     return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3504 }
3505
3506 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3507                                       int64_t sector_num, int nb_sectors,
3508                                       BdrvRequestFlags flags)
3509 {
3510     trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3511
3512     if (!(bs->open_flags & BDRV_O_UNMAP)) {
3513         flags &= ~BDRV_REQ_MAY_UNMAP;
3514     }
3515
3516     return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3517                              BDRV_REQ_ZERO_WRITE | flags);
3518 }
3519
3520 /**
3521  * Truncate file to 'offset' bytes (needed only for file protocols)
3522  */
3523 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3524 {
3525     BlockDriver *drv = bs->drv;
3526     int ret;
3527     if (!drv)
3528         return -ENOMEDIUM;
3529     if (!drv->bdrv_truncate)
3530         return -ENOTSUP;
3531     if (bs->read_only)
3532         return -EACCES;
3533
3534     ret = drv->bdrv_truncate(bs, offset);
3535     if (ret == 0) {
3536         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3537         bdrv_dev_resize_cb(bs);
3538     }
3539     return ret;
3540 }
3541
3542 /**
3543  * Length of a allocated file in bytes. Sparse files are counted by actual
3544  * allocated space. Return < 0 if error or unknown.
3545  */
3546 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3547 {
3548     BlockDriver *drv = bs->drv;
3549     if (!drv) {
3550         return -ENOMEDIUM;
3551     }
3552     if (drv->bdrv_get_allocated_file_size) {
3553         return drv->bdrv_get_allocated_file_size(bs);
3554     }
3555     if (bs->file) {
3556         return bdrv_get_allocated_file_size(bs->file);
3557     }
3558     return -ENOTSUP;
3559 }
3560
3561 /**
3562  * Return number of sectors on success, -errno on error.
3563  */
3564 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3565 {
3566     BlockDriver *drv = bs->drv;
3567
3568     if (!drv)
3569         return -ENOMEDIUM;
3570
3571     if (drv->has_variable_length) {
3572         int ret = refresh_total_sectors(bs, bs->total_sectors);
3573         if (ret < 0) {
3574             return ret;
3575         }
3576     }
3577     return bs->total_sectors;
3578 }
3579
3580 /**
3581  * Return length in bytes on success, -errno on error.
3582  * The length is always a multiple of BDRV_SECTOR_SIZE.
3583  */
3584 int64_t bdrv_getlength(BlockDriverState *bs)
3585 {
3586     int64_t ret = bdrv_nb_sectors(bs);
3587
3588     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3589 }
3590
3591 /* return 0 as number of sectors if no device present or error */
3592 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3593 {
3594     int64_t nb_sectors = bdrv_nb_sectors(bs);
3595
3596     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3597 }
3598
3599 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3600                        BlockdevOnError on_write_error)
3601 {
3602     bs->on_read_error = on_read_error;
3603     bs->on_write_error = on_write_error;
3604 }
3605
3606 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3607 {
3608     return is_read ? bs->on_read_error : bs->on_write_error;
3609 }
3610
3611 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3612 {
3613     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3614
3615     switch (on_err) {
3616     case BLOCKDEV_ON_ERROR_ENOSPC:
3617         return (error == ENOSPC) ?
3618                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3619     case BLOCKDEV_ON_ERROR_STOP:
3620         return BLOCK_ERROR_ACTION_STOP;
3621     case BLOCKDEV_ON_ERROR_REPORT:
3622         return BLOCK_ERROR_ACTION_REPORT;
3623     case BLOCKDEV_ON_ERROR_IGNORE:
3624         return BLOCK_ERROR_ACTION_IGNORE;
3625     default:
3626         abort();
3627     }
3628 }
3629
3630 /* This is done by device models because, while the block layer knows
3631  * about the error, it does not know whether an operation comes from
3632  * the device or the block layer (from a job, for example).
3633  */
3634 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3635                        bool is_read, int error)
3636 {
3637     assert(error >= 0);
3638
3639     if (action == BLOCK_ERROR_ACTION_STOP) {
3640         /* First set the iostatus, so that "info block" returns an iostatus
3641          * that matches the events raised so far (an additional error iostatus
3642          * is fine, but not a lost one).
3643          */
3644         bdrv_iostatus_set_err(bs, error);
3645
3646         /* Then raise the request to stop the VM and the event.
3647          * qemu_system_vmstop_request_prepare has two effects.  First,
3648          * it ensures that the STOP event always comes after the
3649          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
3650          * can observe the STOP event and do a "cont" before the STOP
3651          * event is issued, the VM will not stop.  In this case, vm_start()
3652          * also ensures that the STOP/RESUME pair of events is emitted.
3653          */
3654         qemu_system_vmstop_request_prepare();
3655         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3656                                        is_read ? IO_OPERATION_TYPE_READ :
3657                                        IO_OPERATION_TYPE_WRITE,
3658                                        action, &error_abort);
3659         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3660     } else {
3661         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3662                                        is_read ? IO_OPERATION_TYPE_READ :
3663                                        IO_OPERATION_TYPE_WRITE,
3664                                        action, &error_abort);
3665     }
3666 }
3667
3668 int bdrv_is_read_only(BlockDriverState *bs)
3669 {
3670     return bs->read_only;
3671 }
3672
3673 int bdrv_is_sg(BlockDriverState *bs)
3674 {
3675     return bs->sg;
3676 }
3677
3678 int bdrv_enable_write_cache(BlockDriverState *bs)
3679 {
3680     return bs->enable_write_cache;
3681 }
3682
3683 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3684 {
3685     bs->enable_write_cache = wce;
3686
3687     /* so a reopen() will preserve wce */
3688     if (wce) {
3689         bs->open_flags |= BDRV_O_CACHE_WB;
3690     } else {
3691         bs->open_flags &= ~BDRV_O_CACHE_WB;
3692     }
3693 }
3694
3695 int bdrv_is_encrypted(BlockDriverState *bs)
3696 {
3697     if (bs->backing_hd && bs->backing_hd->encrypted)
3698         return 1;
3699     return bs->encrypted;
3700 }
3701
3702 int bdrv_key_required(BlockDriverState *bs)
3703 {
3704     BlockDriverState *backing_hd = bs->backing_hd;
3705
3706     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3707         return 1;
3708     return (bs->encrypted && !bs->valid_key);
3709 }
3710
3711 int bdrv_set_key(BlockDriverState *bs, const char *key)
3712 {
3713     int ret;
3714     if (bs->backing_hd && bs->backing_hd->encrypted) {
3715         ret = bdrv_set_key(bs->backing_hd, key);
3716         if (ret < 0)
3717             return ret;
3718         if (!bs->encrypted)
3719             return 0;
3720     }
3721     if (!bs->encrypted) {
3722         return -EINVAL;
3723     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3724         return -ENOMEDIUM;
3725     }
3726     ret = bs->drv->bdrv_set_key(bs, key);
3727     if (ret < 0) {
3728         bs->valid_key = 0;
3729     } else if (!bs->valid_key) {
3730         bs->valid_key = 1;
3731         /* call the change callback now, we skipped it on open */
3732         bdrv_dev_change_media_cb(bs, true);
3733     }
3734     return ret;
3735 }
3736
3737 const char *bdrv_get_format_name(BlockDriverState *bs)
3738 {
3739     return bs->drv ? bs->drv->format_name : NULL;
3740 }
3741
3742 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3743                          void *opaque)
3744 {
3745     BlockDriver *drv;
3746     int count = 0;
3747     const char **formats = NULL;
3748
3749     QLIST_FOREACH(drv, &bdrv_drivers, list) {
3750         if (drv->format_name) {
3751             bool found = false;
3752             int i = count;
3753             while (formats && i && !found) {
3754                 found = !strcmp(formats[--i], drv->format_name);
3755             }
3756
3757             if (!found) {
3758                 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3759                 formats[count++] = drv->format_name;
3760                 it(opaque, drv->format_name);
3761             }
3762         }
3763     }
3764     g_free(formats);
3765 }
3766
3767 /* This function is to find block backend bs */
3768 BlockDriverState *bdrv_find(const char *name)
3769 {
3770     BlockDriverState *bs;
3771
3772     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3773         if (!strcmp(name, bs->device_name)) {
3774             return bs;
3775         }
3776     }
3777     return NULL;
3778 }
3779
3780 /* This function is to find a node in the bs graph */
3781 BlockDriverState *bdrv_find_node(const char *node_name)
3782 {
3783     BlockDriverState *bs;
3784
3785     assert(node_name);
3786
3787     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3788         if (!strcmp(node_name, bs->node_name)) {
3789             return bs;
3790         }
3791     }
3792     return NULL;
3793 }
3794
3795 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3796 BlockDeviceInfoList *bdrv_named_nodes_list(void)
3797 {
3798     BlockDeviceInfoList *list, *entry;
3799     BlockDriverState *bs;
3800
3801     list = NULL;
3802     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3803         entry = g_malloc0(sizeof(*entry));
3804         entry->value = bdrv_block_device_info(bs);
3805         entry->next = list;
3806         list = entry;
3807     }
3808
3809     return list;
3810 }
3811
3812 BlockDriverState *bdrv_lookup_bs(const char *device,
3813                                  const char *node_name,
3814                                  Error **errp)
3815 {
3816     BlockDriverState *bs = NULL;
3817
3818     if (device) {
3819         bs = bdrv_find(device);
3820
3821         if (bs) {
3822             return bs;
3823         }
3824     }
3825
3826     if (node_name) {
3827         bs = bdrv_find_node(node_name);
3828
3829         if (bs) {
3830             return bs;
3831         }
3832     }
3833
3834     error_setg(errp, "Cannot find device=%s nor node_name=%s",
3835                      device ? device : "",
3836                      node_name ? node_name : "");
3837     return NULL;
3838 }
3839
3840 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3841  * return false.  If either argument is NULL, return false. */
3842 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3843 {
3844     while (top && top != base) {
3845         top = top->backing_hd;
3846     }
3847
3848     return top != NULL;
3849 }
3850
3851 BlockDriverState *bdrv_next(BlockDriverState *bs)
3852 {
3853     if (!bs) {
3854         return QTAILQ_FIRST(&bdrv_states);
3855     }
3856     return QTAILQ_NEXT(bs, device_list);
3857 }
3858
3859 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
3860 {
3861     BlockDriverState *bs;
3862
3863     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3864         it(opaque, bs);
3865     }
3866 }
3867
3868 const char *bdrv_get_device_name(BlockDriverState *bs)
3869 {
3870     return bs->device_name;
3871 }
3872
3873 int bdrv_get_flags(BlockDriverState *bs)
3874 {
3875     return bs->open_flags;
3876 }
3877
3878 int bdrv_flush_all(void)
3879 {
3880     BlockDriverState *bs;
3881     int result = 0;
3882
3883     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3884         AioContext *aio_context = bdrv_get_aio_context(bs);
3885         int ret;
3886
3887         aio_context_acquire(aio_context);
3888         ret = bdrv_flush(bs);
3889         if (ret < 0 && !result) {
3890             result = ret;
3891         }
3892         aio_context_release(aio_context);
3893     }
3894
3895     return result;
3896 }
3897
3898 int bdrv_has_zero_init_1(BlockDriverState *bs)
3899 {
3900     return 1;
3901 }
3902
3903 int bdrv_has_zero_init(BlockDriverState *bs)
3904 {
3905     assert(bs->drv);
3906
3907     /* If BS is a copy on write image, it is initialized to
3908        the contents of the base image, which may not be zeroes.  */
3909     if (bs->backing_hd) {
3910         return 0;
3911     }
3912     if (bs->drv->bdrv_has_zero_init) {
3913         return bs->drv->bdrv_has_zero_init(bs);
3914     }
3915
3916     /* safe default */
3917     return 0;
3918 }
3919
3920 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3921 {
3922     BlockDriverInfo bdi;
3923
3924     if (bs->backing_hd) {
3925         return false;
3926     }
3927
3928     if (bdrv_get_info(bs, &bdi) == 0) {
3929         return bdi.unallocated_blocks_are_zero;
3930     }
3931
3932     return false;
3933 }
3934
3935 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3936 {
3937     BlockDriverInfo bdi;
3938
3939     if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3940         return false;
3941     }
3942
3943     if (bdrv_get_info(bs, &bdi) == 0) {
3944         return bdi.can_write_zeroes_with_unmap;
3945     }
3946
3947     return false;
3948 }
3949
3950 typedef struct BdrvCoGetBlockStatusData {
3951     BlockDriverState *bs;
3952     BlockDriverState *base;
3953     int64_t sector_num;
3954     int nb_sectors;
3955     int *pnum;
3956     int64_t ret;
3957     bool done;
3958 } BdrvCoGetBlockStatusData;
3959
3960 /*
3961  * Returns true iff the specified sector is present in the disk image. Drivers
3962  * not implementing the functionality are assumed to not support backing files,
3963  * hence all their sectors are reported as allocated.
3964  *
3965  * If 'sector_num' is beyond the end of the disk image the return value is 0
3966  * and 'pnum' is set to 0.
3967  *
3968  * 'pnum' is set to the number of sectors (including and immediately following
3969  * the specified sector) that are known to be in the same
3970  * allocated/unallocated state.
3971  *
3972  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
3973  * beyond the end of the disk image it will be clamped.
3974  */
3975 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3976                                                      int64_t sector_num,
3977                                                      int nb_sectors, int *pnum)
3978 {
3979     int64_t total_sectors;
3980     int64_t n;
3981     int64_t ret, ret2;
3982
3983     total_sectors = bdrv_nb_sectors(bs);
3984     if (total_sectors < 0) {
3985         return total_sectors;
3986     }
3987
3988     if (sector_num >= total_sectors) {
3989         *pnum = 0;
3990         return 0;
3991     }
3992
3993     n = total_sectors - sector_num;
3994     if (n < nb_sectors) {
3995         nb_sectors = n;
3996     }
3997
3998     if (!bs->drv->bdrv_co_get_block_status) {
3999         *pnum = nb_sectors;
4000         ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
4001         if (bs->drv->protocol_name) {
4002             ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
4003         }
4004         return ret;
4005     }
4006
4007     ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
4008     if (ret < 0) {
4009         *pnum = 0;
4010         return ret;
4011     }
4012
4013     if (ret & BDRV_BLOCK_RAW) {
4014         assert(ret & BDRV_BLOCK_OFFSET_VALID);
4015         return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4016                                      *pnum, pnum);
4017     }
4018
4019     if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
4020         ret |= BDRV_BLOCK_ALLOCATED;
4021     }
4022
4023     if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
4024         if (bdrv_unallocated_blocks_are_zero(bs)) {
4025             ret |= BDRV_BLOCK_ZERO;
4026         } else if (bs->backing_hd) {
4027             BlockDriverState *bs2 = bs->backing_hd;
4028             int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
4029             if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
4030                 ret |= BDRV_BLOCK_ZERO;
4031             }
4032         }
4033     }
4034
4035     if (bs->file &&
4036         (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
4037         (ret & BDRV_BLOCK_OFFSET_VALID)) {
4038         ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4039                                         *pnum, pnum);
4040         if (ret2 >= 0) {
4041             /* Ignore errors.  This is just providing extra information, it
4042              * is useful but not necessary.
4043              */
4044             ret |= (ret2 & BDRV_BLOCK_ZERO);
4045         }
4046     }
4047
4048     return ret;
4049 }
4050
4051 /* Coroutine wrapper for bdrv_get_block_status() */
4052 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4053 {
4054     BdrvCoGetBlockStatusData *data = opaque;
4055     BlockDriverState *bs = data->bs;
4056
4057     data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4058                                          data->pnum);
4059     data->done = true;
4060 }
4061
4062 /*
4063  * Synchronous wrapper around bdrv_co_get_block_status().
4064  *
4065  * See bdrv_co_get_block_status() for details.
4066  */
4067 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4068                               int nb_sectors, int *pnum)
4069 {
4070     Coroutine *co;
4071     BdrvCoGetBlockStatusData data = {
4072         .bs = bs,
4073         .sector_num = sector_num,
4074         .nb_sectors = nb_sectors,
4075         .pnum = pnum,
4076         .done = false,
4077     };
4078
4079     if (qemu_in_coroutine()) {
4080         /* Fast-path if already in coroutine context */
4081         bdrv_get_block_status_co_entry(&data);
4082     } else {
4083         AioContext *aio_context = bdrv_get_aio_context(bs);
4084
4085         co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4086         qemu_coroutine_enter(co, &data);
4087         while (!data.done) {
4088             aio_poll(aio_context, true);
4089         }
4090     }
4091     return data.ret;
4092 }
4093
4094 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4095                                    int nb_sectors, int *pnum)
4096 {
4097     int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4098     if (ret < 0) {
4099         return ret;
4100     }
4101     return !!(ret & BDRV_BLOCK_ALLOCATED);
4102 }
4103
4104 /*
4105  * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4106  *
4107  * Return true if the given sector is allocated in any image between
4108  * BASE and TOP (inclusive).  BASE can be NULL to check if the given
4109  * sector is allocated in any image of the chain.  Return false otherwise.
4110  *
4111  * 'pnum' is set to the number of sectors (including and immediately following
4112  *  the specified sector) that are known to be in the same
4113  *  allocated/unallocated state.
4114  *
4115  */
4116 int bdrv_is_allocated_above(BlockDriverState *top,
4117                             BlockDriverState *base,
4118                             int64_t sector_num,
4119                             int nb_sectors, int *pnum)
4120 {
4121     BlockDriverState *intermediate;
4122     int ret, n = nb_sectors;
4123
4124     intermediate = top;
4125     while (intermediate && intermediate != base) {
4126         int pnum_inter;
4127         ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4128                                 &pnum_inter);
4129         if (ret < 0) {
4130             return ret;
4131         } else if (ret) {
4132             *pnum = pnum_inter;
4133             return 1;
4134         }
4135
4136         /*
4137          * [sector_num, nb_sectors] is unallocated on top but intermediate
4138          * might have
4139          *
4140          * [sector_num+x, nr_sectors] allocated.
4141          */
4142         if (n > pnum_inter &&
4143             (intermediate == top ||
4144              sector_num + pnum_inter < intermediate->total_sectors)) {
4145             n = pnum_inter;
4146         }
4147
4148         intermediate = intermediate->backing_hd;
4149     }
4150
4151     *pnum = n;
4152     return 0;
4153 }
4154
4155 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4156 {
4157     if (bs->backing_hd && bs->backing_hd->encrypted)
4158         return bs->backing_file;
4159     else if (bs->encrypted)
4160         return bs->filename;
4161     else
4162         return NULL;
4163 }
4164
4165 void bdrv_get_backing_filename(BlockDriverState *bs,
4166                                char *filename, int filename_size)
4167 {
4168     pstrcpy(filename, filename_size, bs->backing_file);
4169 }
4170
4171 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
4172                           const uint8_t *buf, int nb_sectors)
4173 {
4174     BlockDriver *drv = bs->drv;
4175     if (!drv)
4176         return -ENOMEDIUM;
4177     if (!drv->bdrv_write_compressed)
4178         return -ENOTSUP;
4179     if (bdrv_check_request(bs, sector_num, nb_sectors))
4180         return -EIO;
4181
4182     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4183
4184     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4185 }
4186
4187 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4188 {
4189     BlockDriver *drv = bs->drv;
4190     if (!drv)
4191         return -ENOMEDIUM;
4192     if (!drv->bdrv_get_info)
4193         return -ENOTSUP;
4194     memset(bdi, 0, sizeof(*bdi));
4195     return drv->bdrv_get_info(bs, bdi);
4196 }
4197
4198 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4199 {
4200     BlockDriver *drv = bs->drv;
4201     if (drv && drv->bdrv_get_specific_info) {
4202         return drv->bdrv_get_specific_info(bs);
4203     }
4204     return NULL;
4205 }
4206
4207 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4208                       int64_t pos, int size)
4209 {
4210     QEMUIOVector qiov;
4211     struct iovec iov = {
4212         .iov_base   = (void *) buf,
4213         .iov_len    = size,
4214     };
4215
4216     qemu_iovec_init_external(&qiov, &iov, 1);
4217     return bdrv_writev_vmstate(bs, &qiov, pos);
4218 }
4219
4220 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4221 {
4222     BlockDriver *drv = bs->drv;
4223
4224     if (!drv) {
4225         return -ENOMEDIUM;
4226     } else if (drv->bdrv_save_vmstate) {
4227         return drv->bdrv_save_vmstate(bs, qiov, pos);
4228     } else if (bs->file) {
4229         return bdrv_writev_vmstate(bs->file, qiov, pos);
4230     }
4231
4232     return -ENOTSUP;
4233 }
4234
4235 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4236                       int64_t pos, int size)
4237 {
4238     BlockDriver *drv = bs->drv;
4239     if (!drv)
4240         return -ENOMEDIUM;
4241     if (drv->bdrv_load_vmstate)
4242         return drv->bdrv_load_vmstate(bs, buf, pos, size);
4243     if (bs->file)
4244         return bdrv_load_vmstate(bs->file, buf, pos, size);
4245     return -ENOTSUP;
4246 }
4247
4248 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4249 {
4250     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4251         return;
4252     }
4253
4254     bs->drv->bdrv_debug_event(bs, event);
4255 }
4256
4257 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4258                           const char *tag)
4259 {
4260     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4261         bs = bs->file;
4262     }
4263
4264     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4265         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4266     }
4267
4268     return -ENOTSUP;
4269 }
4270
4271 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4272 {
4273     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4274         bs = bs->file;
4275     }
4276
4277     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4278         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4279     }
4280
4281     return -ENOTSUP;
4282 }
4283
4284 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4285 {
4286     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4287         bs = bs->file;
4288     }
4289
4290     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4291         return bs->drv->bdrv_debug_resume(bs, tag);
4292     }
4293
4294     return -ENOTSUP;
4295 }
4296
4297 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4298 {
4299     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4300         bs = bs->file;
4301     }
4302
4303     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4304         return bs->drv->bdrv_debug_is_suspended(bs, tag);
4305     }
4306
4307     return false;
4308 }
4309
4310 int bdrv_is_snapshot(BlockDriverState *bs)
4311 {
4312     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4313 }
4314
4315 /* backing_file can either be relative, or absolute, or a protocol.  If it is
4316  * relative, it must be relative to the chain.  So, passing in bs->filename
4317  * from a BDS as backing_file should not be done, as that may be relative to
4318  * the CWD rather than the chain. */
4319 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4320         const char *backing_file)
4321 {
4322     char *filename_full = NULL;
4323     char *backing_file_full = NULL;
4324     char *filename_tmp = NULL;
4325     int is_protocol = 0;
4326     BlockDriverState *curr_bs = NULL;
4327     BlockDriverState *retval = NULL;
4328
4329     if (!bs || !bs->drv || !backing_file) {
4330         return NULL;
4331     }
4332
4333     filename_full     = g_malloc(PATH_MAX);
4334     backing_file_full = g_malloc(PATH_MAX);
4335     filename_tmp      = g_malloc(PATH_MAX);
4336
4337     is_protocol = path_has_protocol(backing_file);
4338
4339     for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4340
4341         /* If either of the filename paths is actually a protocol, then
4342          * compare unmodified paths; otherwise make paths relative */
4343         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4344             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4345                 retval = curr_bs->backing_hd;
4346                 break;
4347             }
4348         } else {
4349             /* If not an absolute filename path, make it relative to the current
4350              * image's filename path */
4351             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4352                          backing_file);
4353
4354             /* We are going to compare absolute pathnames */
4355             if (!realpath(filename_tmp, filename_full)) {
4356                 continue;
4357             }
4358
4359             /* We need to make sure the backing filename we are comparing against
4360              * is relative to the current image filename (or absolute) */
4361             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4362                          curr_bs->backing_file);
4363
4364             if (!realpath(filename_tmp, backing_file_full)) {
4365                 continue;
4366             }
4367
4368             if (strcmp(backing_file_full, filename_full) == 0) {
4369                 retval = curr_bs->backing_hd;
4370                 break;
4371             }
4372         }
4373     }
4374
4375     g_free(filename_full);
4376     g_free(backing_file_full);
4377     g_free(filename_tmp);
4378     return retval;
4379 }
4380
4381 int bdrv_get_backing_file_depth(BlockDriverState *bs)
4382 {
4383     if (!bs->drv) {
4384         return 0;
4385     }
4386
4387     if (!bs->backing_hd) {
4388         return 0;
4389     }
4390
4391     return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4392 }
4393
4394 /**************************************************************/
4395 /* async I/Os */
4396
4397 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4398                                  QEMUIOVector *qiov, int nb_sectors,
4399                                  BlockDriverCompletionFunc *cb, void *opaque)
4400 {
4401     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4402
4403     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4404                                  cb, opaque, false);
4405 }
4406
4407 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4408                                   QEMUIOVector *qiov, int nb_sectors,
4409                                   BlockDriverCompletionFunc *cb, void *opaque)
4410 {
4411     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4412
4413     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4414                                  cb, opaque, true);
4415 }
4416
4417 BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4418         int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4419         BlockDriverCompletionFunc *cb, void *opaque)
4420 {
4421     trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4422
4423     return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4424                                  BDRV_REQ_ZERO_WRITE | flags,
4425                                  cb, opaque, true);
4426 }
4427
4428
4429 typedef struct MultiwriteCB {
4430     int error;
4431     int num_requests;
4432     int num_callbacks;
4433     struct {
4434         BlockDriverCompletionFunc *cb;
4435         void *opaque;
4436         QEMUIOVector *free_qiov;
4437     } callbacks[];
4438 } MultiwriteCB;
4439
4440 static void multiwrite_user_cb(MultiwriteCB *mcb)
4441 {
4442     int i;
4443
4444     for (i = 0; i < mcb->num_callbacks; i++) {
4445         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4446         if (mcb->callbacks[i].free_qiov) {
4447             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4448         }
4449         g_free(mcb->callbacks[i].free_qiov);
4450     }
4451 }
4452
4453 static void multiwrite_cb(void *opaque, int ret)
4454 {
4455     MultiwriteCB *mcb = opaque;
4456
4457     trace_multiwrite_cb(mcb, ret);
4458
4459     if (ret < 0 && !mcb->error) {
4460         mcb->error = ret;
4461     }
4462
4463     mcb->num_requests--;
4464     if (mcb->num_requests == 0) {
4465         multiwrite_user_cb(mcb);
4466         g_free(mcb);
4467     }
4468 }
4469
4470 static int multiwrite_req_compare(const void *a, const void *b)
4471 {
4472     const BlockRequest *req1 = a, *req2 = b;
4473
4474     /*
4475      * Note that we can't simply subtract req2->sector from req1->sector
4476      * here as that could overflow the return value.
4477      */
4478     if (req1->sector > req2->sector) {
4479         return 1;
4480     } else if (req1->sector < req2->sector) {
4481         return -1;
4482     } else {
4483         return 0;
4484     }
4485 }
4486
4487 /*
4488  * Takes a bunch of requests and tries to merge them. Returns the number of
4489  * requests that remain after merging.
4490  */
4491 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4492     int num_reqs, MultiwriteCB *mcb)
4493 {
4494     int i, outidx;
4495
4496     // Sort requests by start sector
4497     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4498
4499     // Check if adjacent requests touch the same clusters. If so, combine them,
4500     // filling up gaps with zero sectors.
4501     outidx = 0;
4502     for (i = 1; i < num_reqs; i++) {
4503         int merge = 0;
4504         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4505
4506         // Handle exactly sequential writes and overlapping writes.
4507         if (reqs[i].sector <= oldreq_last) {
4508             merge = 1;
4509         }
4510
4511         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4512             merge = 0;
4513         }
4514
4515         if (merge) {
4516             size_t size;
4517             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
4518             qemu_iovec_init(qiov,
4519                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4520
4521             // Add the first request to the merged one. If the requests are
4522             // overlapping, drop the last sectors of the first request.
4523             size = (reqs[i].sector - reqs[outidx].sector) << 9;
4524             qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
4525
4526             // We should need to add any zeros between the two requests
4527             assert (reqs[i].sector <= oldreq_last);
4528
4529             // Add the second request
4530             qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
4531
4532             reqs[outidx].nb_sectors = qiov->size >> 9;
4533             reqs[outidx].qiov = qiov;
4534
4535             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4536         } else {
4537             outidx++;
4538             reqs[outidx].sector     = reqs[i].sector;
4539             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4540             reqs[outidx].qiov       = reqs[i].qiov;
4541         }
4542     }
4543
4544     return outidx + 1;
4545 }
4546
4547 /*
4548  * Submit multiple AIO write requests at once.
4549  *
4550  * On success, the function returns 0 and all requests in the reqs array have
4551  * been submitted. In error case this function returns -1, and any of the
4552  * requests may or may not be submitted yet. In particular, this means that the
4553  * callback will be called for some of the requests, for others it won't. The
4554  * caller must check the error field of the BlockRequest to wait for the right
4555  * callbacks (if error != 0, no callback will be called).
4556  *
4557  * The implementation may modify the contents of the reqs array, e.g. to merge
4558  * requests. However, the fields opaque and error are left unmodified as they
4559  * are used to signal failure for a single request to the caller.
4560  */
4561 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4562 {
4563     MultiwriteCB *mcb;
4564     int i;
4565
4566     /* don't submit writes if we don't have a medium */
4567     if (bs->drv == NULL) {
4568         for (i = 0; i < num_reqs; i++) {
4569             reqs[i].error = -ENOMEDIUM;
4570         }
4571         return -1;
4572     }
4573
4574     if (num_reqs == 0) {
4575         return 0;
4576     }
4577
4578     // Create MultiwriteCB structure
4579     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
4580     mcb->num_requests = 0;
4581     mcb->num_callbacks = num_reqs;
4582
4583     for (i = 0; i < num_reqs; i++) {
4584         mcb->callbacks[i].cb = reqs[i].cb;
4585         mcb->callbacks[i].opaque = reqs[i].opaque;
4586     }
4587
4588     // Check for mergable requests
4589     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4590
4591     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4592
4593     /* Run the aio requests. */
4594     mcb->num_requests = num_reqs;
4595     for (i = 0; i < num_reqs; i++) {
4596         bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4597                               reqs[i].nb_sectors, reqs[i].flags,
4598                               multiwrite_cb, mcb,
4599                               true);
4600     }
4601
4602     return 0;
4603 }
4604
4605 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
4606 {
4607     acb->aiocb_info->cancel(acb);
4608 }
4609
4610 /**************************************************************/
4611 /* async block device emulation */
4612
4613 typedef struct BlockDriverAIOCBSync {
4614     BlockDriverAIOCB common;
4615     QEMUBH *bh;
4616     int ret;
4617     /* vector translation state */
4618     QEMUIOVector *qiov;
4619     uint8_t *bounce;
4620     int is_write;
4621 } BlockDriverAIOCBSync;
4622
4623 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4624 {
4625     BlockDriverAIOCBSync *acb =
4626         container_of(blockacb, BlockDriverAIOCBSync, common);
4627     qemu_bh_delete(acb->bh);
4628     acb->bh = NULL;
4629     qemu_aio_release(acb);
4630 }
4631
4632 static const AIOCBInfo bdrv_em_aiocb_info = {
4633     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
4634     .cancel             = bdrv_aio_cancel_em,
4635 };
4636
4637 static void bdrv_aio_bh_cb(void *opaque)
4638 {
4639     BlockDriverAIOCBSync *acb = opaque;
4640
4641     if (!acb->is_write && acb->ret >= 0) {
4642         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4643     }
4644     qemu_vfree(acb->bounce);
4645     acb->common.cb(acb->common.opaque, acb->ret);
4646     qemu_bh_delete(acb->bh);
4647     acb->bh = NULL;
4648     qemu_aio_release(acb);
4649 }
4650
4651 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4652                                             int64_t sector_num,
4653                                             QEMUIOVector *qiov,
4654                                             int nb_sectors,
4655                                             BlockDriverCompletionFunc *cb,
4656                                             void *opaque,
4657                                             int is_write)
4658
4659 {
4660     BlockDriverAIOCBSync *acb;
4661
4662     acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4663     acb->is_write = is_write;
4664     acb->qiov = qiov;
4665     acb->bounce = qemu_try_blockalign(bs, qiov->size);
4666     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4667
4668     if (acb->bounce == NULL) {
4669         acb->ret = -ENOMEM;
4670     } else if (is_write) {
4671         qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4672         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4673     } else {
4674         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4675     }
4676
4677     qemu_bh_schedule(acb->bh);
4678
4679     return &acb->common;
4680 }
4681
4682 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4683         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4684         BlockDriverCompletionFunc *cb, void *opaque)
4685 {
4686     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4687 }
4688
4689 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4690         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4691         BlockDriverCompletionFunc *cb, void *opaque)
4692 {
4693     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4694 }
4695
4696
4697 typedef struct BlockDriverAIOCBCoroutine {
4698     BlockDriverAIOCB common;
4699     BlockRequest req;
4700     bool is_write;
4701     bool *done;
4702     QEMUBH* bh;
4703 } BlockDriverAIOCBCoroutine;
4704
4705 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4706 {
4707     AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
4708     BlockDriverAIOCBCoroutine *acb =
4709         container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4710     bool done = false;
4711
4712     acb->done = &done;
4713     while (!done) {
4714         aio_poll(aio_context, true);
4715     }
4716 }
4717
4718 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4719     .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
4720     .cancel             = bdrv_aio_co_cancel_em,
4721 };
4722
4723 static void bdrv_co_em_bh(void *opaque)
4724 {
4725     BlockDriverAIOCBCoroutine *acb = opaque;
4726
4727     acb->common.cb(acb->common.opaque, acb->req.error);
4728
4729     if (acb->done) {
4730         *acb->done = true;
4731     }
4732
4733     qemu_bh_delete(acb->bh);
4734     qemu_aio_release(acb);
4735 }
4736
4737 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4738 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4739 {
4740     BlockDriverAIOCBCoroutine *acb = opaque;
4741     BlockDriverState *bs = acb->common.bs;
4742
4743     if (!acb->is_write) {
4744         acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4745             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4746     } else {
4747         acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4748             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4749     }
4750
4751     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4752     qemu_bh_schedule(acb->bh);
4753 }
4754
4755 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4756                                                int64_t sector_num,
4757                                                QEMUIOVector *qiov,
4758                                                int nb_sectors,
4759                                                BdrvRequestFlags flags,
4760                                                BlockDriverCompletionFunc *cb,
4761                                                void *opaque,
4762                                                bool is_write)
4763 {
4764     Coroutine *co;
4765     BlockDriverAIOCBCoroutine *acb;
4766
4767     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4768     acb->req.sector = sector_num;
4769     acb->req.nb_sectors = nb_sectors;
4770     acb->req.qiov = qiov;
4771     acb->req.flags = flags;
4772     acb->is_write = is_write;
4773     acb->done = NULL;
4774
4775     co = qemu_coroutine_create(bdrv_co_do_rw);
4776     qemu_coroutine_enter(co, acb);
4777
4778     return &acb->common;
4779 }
4780
4781 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4782 {
4783     BlockDriverAIOCBCoroutine *acb = opaque;
4784     BlockDriverState *bs = acb->common.bs;
4785
4786     acb->req.error = bdrv_co_flush(bs);
4787     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4788     qemu_bh_schedule(acb->bh);
4789 }
4790
4791 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4792         BlockDriverCompletionFunc *cb, void *opaque)
4793 {
4794     trace_bdrv_aio_flush(bs, opaque);
4795
4796     Coroutine *co;
4797     BlockDriverAIOCBCoroutine *acb;
4798
4799     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4800     acb->done = NULL;
4801
4802     co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4803     qemu_coroutine_enter(co, acb);
4804
4805     return &acb->common;
4806 }
4807
4808 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4809 {
4810     BlockDriverAIOCBCoroutine *acb = opaque;
4811     BlockDriverState *bs = acb->common.bs;
4812
4813     acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4814     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4815     qemu_bh_schedule(acb->bh);
4816 }
4817
4818 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4819         int64_t sector_num, int nb_sectors,
4820         BlockDriverCompletionFunc *cb, void *opaque)
4821 {
4822     Coroutine *co;
4823     BlockDriverAIOCBCoroutine *acb;
4824
4825     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4826
4827     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4828     acb->req.sector = sector_num;
4829     acb->req.nb_sectors = nb_sectors;
4830     acb->done = NULL;
4831     co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4832     qemu_coroutine_enter(co, acb);
4833
4834     return &acb->common;
4835 }
4836
4837 void bdrv_init(void)
4838 {
4839     module_call_init(MODULE_INIT_BLOCK);
4840 }
4841
4842 void bdrv_init_with_whitelist(void)
4843 {
4844     use_bdrv_whitelist = 1;
4845     bdrv_init();
4846 }
4847
4848 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4849                    BlockDriverCompletionFunc *cb, void *opaque)
4850 {
4851     BlockDriverAIOCB *acb;
4852
4853     acb = g_slice_alloc(aiocb_info->aiocb_size);
4854     acb->aiocb_info = aiocb_info;
4855     acb->bs = bs;
4856     acb->cb = cb;
4857     acb->opaque = opaque;
4858     return acb;
4859 }
4860
4861 void qemu_aio_release(void *p)
4862 {
4863     BlockDriverAIOCB *acb = p;
4864     g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4865 }
4866
4867 /**************************************************************/
4868 /* Coroutine block device emulation */
4869
4870 typedef struct CoroutineIOCompletion {
4871     Coroutine *coroutine;
4872     int ret;
4873 } CoroutineIOCompletion;
4874
4875 static void bdrv_co_io_em_complete(void *opaque, int ret)
4876 {
4877     CoroutineIOCompletion *co = opaque;
4878
4879     co->ret = ret;
4880     qemu_coroutine_enter(co->coroutine, NULL);
4881 }
4882
4883 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4884                                       int nb_sectors, QEMUIOVector *iov,
4885                                       bool is_write)
4886 {
4887     CoroutineIOCompletion co = {
4888         .coroutine = qemu_coroutine_self(),
4889     };
4890     BlockDriverAIOCB *acb;
4891
4892     if (is_write) {
4893         acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4894                                        bdrv_co_io_em_complete, &co);
4895     } else {
4896         acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4897                                       bdrv_co_io_em_complete, &co);
4898     }
4899
4900     trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4901     if (!acb) {
4902         return -EIO;
4903     }
4904     qemu_coroutine_yield();
4905
4906     return co.ret;
4907 }
4908
4909 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4910                                          int64_t sector_num, int nb_sectors,
4911                                          QEMUIOVector *iov)
4912 {
4913     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4914 }
4915
4916 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4917                                          int64_t sector_num, int nb_sectors,
4918                                          QEMUIOVector *iov)
4919 {
4920     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4921 }
4922
4923 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4924 {
4925     RwCo *rwco = opaque;
4926
4927     rwco->ret = bdrv_co_flush(rwco->bs);
4928 }
4929
4930 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4931 {
4932     int ret;
4933
4934     if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4935         return 0;
4936     }
4937
4938     /* Write back cached data to the OS even with cache=unsafe */
4939     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
4940     if (bs->drv->bdrv_co_flush_to_os) {
4941         ret = bs->drv->bdrv_co_flush_to_os(bs);
4942         if (ret < 0) {
4943             return ret;
4944         }
4945     }
4946
4947     /* But don't actually force it to the disk with cache=unsafe */
4948     if (bs->open_flags & BDRV_O_NO_FLUSH) {
4949         goto flush_parent;
4950     }
4951
4952     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
4953     if (bs->drv->bdrv_co_flush_to_disk) {
4954         ret = bs->drv->bdrv_co_flush_to_disk(bs);
4955     } else if (bs->drv->bdrv_aio_flush) {
4956         BlockDriverAIOCB *acb;
4957         CoroutineIOCompletion co = {
4958             .coroutine = qemu_coroutine_self(),
4959         };
4960
4961         acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4962         if (acb == NULL) {
4963             ret = -EIO;
4964         } else {
4965             qemu_coroutine_yield();
4966             ret = co.ret;
4967         }
4968     } else {
4969         /*
4970          * Some block drivers always operate in either writethrough or unsafe
4971          * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4972          * know how the server works (because the behaviour is hardcoded or
4973          * depends on server-side configuration), so we can't ensure that
4974          * everything is safe on disk. Returning an error doesn't work because
4975          * that would break guests even if the server operates in writethrough
4976          * mode.
4977          *
4978          * Let's hope the user knows what he's doing.
4979          */
4980         ret = 0;
4981     }
4982     if (ret < 0) {
4983         return ret;
4984     }
4985
4986     /* Now flush the underlying protocol.  It will also have BDRV_O_NO_FLUSH
4987      * in the case of cache=unsafe, so there are no useless flushes.
4988      */
4989 flush_parent:
4990     return bdrv_co_flush(bs->file);
4991 }
4992
4993 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4994 {
4995     Error *local_err = NULL;
4996     int ret;
4997
4998     if (!bs->drv)  {
4999         return;
5000     }
5001
5002     if (bs->drv->bdrv_invalidate_cache) {
5003         bs->drv->bdrv_invalidate_cache(bs, &local_err);
5004     } else if (bs->file) {
5005         bdrv_invalidate_cache(bs->file, &local_err);
5006     }
5007     if (local_err) {
5008         error_propagate(errp, local_err);
5009         return;
5010     }
5011
5012     ret = refresh_total_sectors(bs, bs->total_sectors);
5013     if (ret < 0) {
5014         error_setg_errno(errp, -ret, "Could not refresh total sector count");
5015         return;
5016     }
5017 }
5018
5019 void bdrv_invalidate_cache_all(Error **errp)
5020 {
5021     BlockDriverState *bs;
5022     Error *local_err = NULL;
5023
5024     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5025         AioContext *aio_context = bdrv_get_aio_context(bs);
5026
5027         aio_context_acquire(aio_context);
5028         bdrv_invalidate_cache(bs, &local_err);
5029         aio_context_release(aio_context);
5030         if (local_err) {
5031             error_propagate(errp, local_err);
5032             return;
5033         }
5034     }
5035 }
5036
5037 void bdrv_clear_incoming_migration_all(void)
5038 {
5039     BlockDriverState *bs;
5040
5041     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5042         AioContext *aio_context = bdrv_get_aio_context(bs);
5043
5044         aio_context_acquire(aio_context);
5045         bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
5046         aio_context_release(aio_context);
5047     }
5048 }
5049
5050 int bdrv_flush(BlockDriverState *bs)
5051 {
5052     Coroutine *co;
5053     RwCo rwco = {
5054         .bs = bs,
5055         .ret = NOT_DONE,
5056     };
5057
5058     if (qemu_in_coroutine()) {
5059         /* Fast-path if already in coroutine context */
5060         bdrv_flush_co_entry(&rwco);
5061     } else {
5062         AioContext *aio_context = bdrv_get_aio_context(bs);
5063
5064         co = qemu_coroutine_create(bdrv_flush_co_entry);
5065         qemu_coroutine_enter(co, &rwco);
5066         while (rwco.ret == NOT_DONE) {
5067             aio_poll(aio_context, true);
5068         }
5069     }
5070
5071     return rwco.ret;
5072 }
5073
5074 typedef struct DiscardCo {
5075     BlockDriverState *bs;
5076     int64_t sector_num;
5077     int nb_sectors;
5078     int ret;
5079 } DiscardCo;
5080 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5081 {
5082     DiscardCo *rwco = opaque;
5083
5084     rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5085 }
5086
5087 /* if no limit is specified in the BlockLimits use a default
5088  * of 32768 512-byte sectors (16 MiB) per request.
5089  */
5090 #define MAX_DISCARD_DEFAULT 32768
5091
5092 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5093                                  int nb_sectors)
5094 {
5095     int max_discard;
5096
5097     if (!bs->drv) {
5098         return -ENOMEDIUM;
5099     } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5100         return -EIO;
5101     } else if (bs->read_only) {
5102         return -EROFS;
5103     }
5104
5105     bdrv_reset_dirty(bs, sector_num, nb_sectors);
5106
5107     /* Do nothing if disabled.  */
5108     if (!(bs->open_flags & BDRV_O_UNMAP)) {
5109         return 0;
5110     }
5111
5112     if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
5113         return 0;
5114     }
5115
5116     max_discard = bs->bl.max_discard ?  bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5117     while (nb_sectors > 0) {
5118         int ret;
5119         int num = nb_sectors;
5120
5121         /* align request */
5122         if (bs->bl.discard_alignment &&
5123             num >= bs->bl.discard_alignment &&
5124             sector_num % bs->bl.discard_alignment) {
5125             if (num > bs->bl.discard_alignment) {
5126                 num = bs->bl.discard_alignment;
5127             }
5128             num -= sector_num % bs->bl.discard_alignment;
5129         }
5130
5131         /* limit request size */
5132         if (num > max_discard) {
5133             num = max_discard;
5134         }
5135
5136         if (bs->drv->bdrv_co_discard) {
5137             ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5138         } else {
5139             BlockDriverAIOCB *acb;
5140             CoroutineIOCompletion co = {
5141                 .coroutine = qemu_coroutine_self(),
5142             };
5143
5144             acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5145                                             bdrv_co_io_em_complete, &co);
5146             if (acb == NULL) {
5147                 return -EIO;
5148             } else {
5149                 qemu_coroutine_yield();
5150                 ret = co.ret;
5151             }
5152         }
5153         if (ret && ret != -ENOTSUP) {
5154             return ret;
5155         }
5156
5157         sector_num += num;
5158         nb_sectors -= num;
5159     }
5160     return 0;
5161 }
5162
5163 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5164 {
5165     Coroutine *co;
5166     DiscardCo rwco = {
5167         .bs = bs,
5168         .sector_num = sector_num,
5169         .nb_sectors = nb_sectors,
5170         .ret = NOT_DONE,
5171     };
5172
5173     if (qemu_in_coroutine()) {
5174         /* Fast-path if already in coroutine context */
5175         bdrv_discard_co_entry(&rwco);
5176     } else {
5177         AioContext *aio_context = bdrv_get_aio_context(bs);
5178
5179         co = qemu_coroutine_create(bdrv_discard_co_entry);
5180         qemu_coroutine_enter(co, &rwco);
5181         while (rwco.ret == NOT_DONE) {
5182             aio_poll(aio_context, true);
5183         }
5184     }
5185
5186     return rwco.ret;
5187 }
5188
5189 /**************************************************************/
5190 /* removable device support */
5191
5192 /**
5193  * Return TRUE if the media is present
5194  */
5195 int bdrv_is_inserted(BlockDriverState *bs)
5196 {
5197     BlockDriver *drv = bs->drv;
5198
5199     if (!drv)
5200         return 0;
5201     if (!drv->bdrv_is_inserted)
5202         return 1;
5203     return drv->bdrv_is_inserted(bs);
5204 }
5205
5206 /**
5207  * Return whether the media changed since the last call to this
5208  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
5209  */
5210 int bdrv_media_changed(BlockDriverState *bs)
5211 {
5212     BlockDriver *drv = bs->drv;
5213
5214     if (drv && drv->bdrv_media_changed) {
5215         return drv->bdrv_media_changed(bs);
5216     }
5217     return -ENOTSUP;
5218 }
5219
5220 /**
5221  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5222  */
5223 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5224 {
5225     BlockDriver *drv = bs->drv;
5226
5227     if (drv && drv->bdrv_eject) {
5228         drv->bdrv_eject(bs, eject_flag);
5229     }
5230
5231     if (bs->device_name[0] != '\0') {
5232         qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
5233                                           eject_flag, &error_abort);
5234     }
5235 }
5236
5237 /**
5238  * Lock or unlock the media (if it is locked, the user won't be able
5239  * to eject it manually).
5240  */
5241 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5242 {
5243     BlockDriver *drv = bs->drv;
5244
5245     trace_bdrv_lock_medium(bs, locked);
5246
5247     if (drv && drv->bdrv_lock_medium) {
5248         drv->bdrv_lock_medium(bs, locked);
5249     }
5250 }
5251
5252 /* needed for generic scsi interface */
5253
5254 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5255 {
5256     BlockDriver *drv = bs->drv;
5257
5258     if (drv && drv->bdrv_ioctl)
5259         return drv->bdrv_ioctl(bs, req, buf);
5260     return -ENOTSUP;
5261 }
5262
5263 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5264         unsigned long int req, void *buf,
5265         BlockDriverCompletionFunc *cb, void *opaque)
5266 {
5267     BlockDriver *drv = bs->drv;
5268
5269     if (drv && drv->bdrv_aio_ioctl)
5270         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5271     return NULL;
5272 }
5273
5274 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5275 {
5276     bs->guest_block_size = align;
5277 }
5278
5279 void *qemu_blockalign(BlockDriverState *bs, size_t size)
5280 {
5281     return qemu_memalign(bdrv_opt_mem_align(bs), size);
5282 }
5283
5284 void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
5285 {
5286     size_t align = bdrv_opt_mem_align(bs);
5287
5288     /* Ensure that NULL is never returned on success */
5289     assert(align > 0);
5290     if (size == 0) {
5291         size = align;
5292     }
5293
5294     return qemu_try_memalign(align, size);
5295 }
5296
5297 /*
5298  * Check if all memory in this vector is sector aligned.
5299  */
5300 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5301 {
5302     int i;
5303     size_t alignment = bdrv_opt_mem_align(bs);
5304
5305     for (i = 0; i < qiov->niov; i++) {
5306         if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5307             return false;
5308         }
5309         if (qiov->iov[i].iov_len % alignment) {
5310             return false;
5311         }
5312     }
5313
5314     return true;
5315 }
5316
5317 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5318                                           Error **errp)
5319 {
5320     int64_t bitmap_size;
5321     BdrvDirtyBitmap *bitmap;
5322
5323     assert((granularity & (granularity - 1)) == 0);
5324
5325     granularity >>= BDRV_SECTOR_BITS;
5326     assert(granularity);
5327     bitmap_size = bdrv_nb_sectors(bs);
5328     if (bitmap_size < 0) {
5329         error_setg_errno(errp, -bitmap_size, "could not get length of device");
5330         errno = -bitmap_size;
5331         return NULL;
5332     }
5333     bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5334     bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5335     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5336     return bitmap;
5337 }
5338
5339 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5340 {
5341     BdrvDirtyBitmap *bm, *next;
5342     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5343         if (bm == bitmap) {
5344             QLIST_REMOVE(bitmap, list);
5345             hbitmap_free(bitmap->bitmap);
5346             g_free(bitmap);
5347             return;
5348         }
5349     }
5350 }
5351
5352 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5353 {
5354     BdrvDirtyBitmap *bm;
5355     BlockDirtyInfoList *list = NULL;
5356     BlockDirtyInfoList **plist = &list;
5357
5358     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5359         BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5360         BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5361         info->count = bdrv_get_dirty_count(bs, bm);
5362         info->granularity =
5363             ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5364         entry->value = info;
5365         *plist = entry;
5366         plist = &entry->next;
5367     }
5368
5369     return list;
5370 }
5371
5372 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5373 {
5374     if (bitmap) {
5375         return hbitmap_get(bitmap->bitmap, sector);
5376     } else {
5377         return 0;
5378     }
5379 }
5380
5381 void bdrv_dirty_iter_init(BlockDriverState *bs,
5382                           BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5383 {
5384     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5385 }
5386
5387 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5388                     int nr_sectors)
5389 {
5390     BdrvDirtyBitmap *bitmap;
5391     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5392         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5393     }
5394 }
5395
5396 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5397 {
5398     BdrvDirtyBitmap *bitmap;
5399     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5400         hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5401     }
5402 }
5403
5404 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5405 {
5406     return hbitmap_count(bitmap->bitmap);
5407 }
5408
5409 /* Get a reference to bs */
5410 void bdrv_ref(BlockDriverState *bs)
5411 {
5412     bs->refcnt++;
5413 }
5414
5415 /* Release a previously grabbed reference to bs.
5416  * If after releasing, reference count is zero, the BlockDriverState is
5417  * deleted. */
5418 void bdrv_unref(BlockDriverState *bs)
5419 {
5420     if (!bs) {
5421         return;
5422     }
5423     assert(bs->refcnt > 0);
5424     if (--bs->refcnt == 0) {
5425         bdrv_delete(bs);
5426     }
5427 }
5428
5429 struct BdrvOpBlocker {
5430     Error *reason;
5431     QLIST_ENTRY(BdrvOpBlocker) list;
5432 };
5433
5434 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5435 {
5436     BdrvOpBlocker *blocker;
5437     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5438     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5439         blocker = QLIST_FIRST(&bs->op_blockers[op]);
5440         if (errp) {
5441             error_setg(errp, "Device '%s' is busy: %s",
5442                        bs->device_name, error_get_pretty(blocker->reason));
5443         }
5444         return true;
5445     }
5446     return false;
5447 }
5448
5449 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5450 {
5451     BdrvOpBlocker *blocker;
5452     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5453
5454     blocker = g_malloc0(sizeof(BdrvOpBlocker));
5455     blocker->reason = reason;
5456     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5457 }
5458
5459 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5460 {
5461     BdrvOpBlocker *blocker, *next;
5462     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5463     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5464         if (blocker->reason == reason) {
5465             QLIST_REMOVE(blocker, list);
5466             g_free(blocker);
5467         }
5468     }
5469 }
5470
5471 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5472 {
5473     int i;
5474     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5475         bdrv_op_block(bs, i, reason);
5476     }
5477 }
5478
5479 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5480 {
5481     int i;
5482     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5483         bdrv_op_unblock(bs, i, reason);
5484     }
5485 }
5486
5487 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5488 {
5489     int i;
5490
5491     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5492         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5493             return false;
5494         }
5495     }
5496     return true;
5497 }
5498
5499 void bdrv_iostatus_enable(BlockDriverState *bs)
5500 {
5501     bs->iostatus_enabled = true;
5502     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5503 }
5504
5505 /* The I/O status is only enabled if the drive explicitly
5506  * enables it _and_ the VM is configured to stop on errors */
5507 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5508 {
5509     return (bs->iostatus_enabled &&
5510            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5511             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
5512             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5513 }
5514
5515 void bdrv_iostatus_disable(BlockDriverState *bs)
5516 {
5517     bs->iostatus_enabled = false;
5518 }
5519
5520 void bdrv_iostatus_reset(BlockDriverState *bs)
5521 {
5522     if (bdrv_iostatus_is_enabled(bs)) {
5523         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5524         if (bs->job) {
5525             block_job_iostatus_reset(bs->job);
5526         }
5527     }
5528 }
5529
5530 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5531 {
5532     assert(bdrv_iostatus_is_enabled(bs));
5533     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5534         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5535                                          BLOCK_DEVICE_IO_STATUS_FAILED;
5536     }
5537 }
5538
5539 void
5540 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5541         enum BlockAcctType type)
5542 {
5543     assert(type < BDRV_MAX_IOTYPE);
5544
5545     cookie->bytes = bytes;
5546     cookie->start_time_ns = get_clock();
5547     cookie->type = type;
5548 }
5549
5550 void
5551 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5552 {
5553     assert(cookie->type < BDRV_MAX_IOTYPE);
5554
5555     bs->nr_bytes[cookie->type] += cookie->bytes;
5556     bs->nr_ops[cookie->type]++;
5557     bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5558 }
5559
5560 void bdrv_img_create(const char *filename, const char *fmt,
5561                      const char *base_filename, const char *base_fmt,
5562                      char *options, uint64_t img_size, int flags,
5563                      Error **errp, bool quiet)
5564 {
5565     QemuOptsList *create_opts = NULL;
5566     QemuOpts *opts = NULL;
5567     const char *backing_fmt, *backing_file;
5568     int64_t size;
5569     BlockDriver *drv, *proto_drv;
5570     BlockDriver *backing_drv = NULL;
5571     Error *local_err = NULL;
5572     int ret = 0;
5573
5574     /* Find driver and parse its options */
5575     drv = bdrv_find_format(fmt);
5576     if (!drv) {
5577         error_setg(errp, "Unknown file format '%s'", fmt);
5578         return;
5579     }
5580
5581     proto_drv = bdrv_find_protocol(filename, true);
5582     if (!proto_drv) {
5583         error_setg(errp, "Unknown protocol '%s'", filename);
5584         return;
5585     }
5586
5587     create_opts = qemu_opts_append(create_opts, drv->create_opts);
5588     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5589
5590     /* Create parameter list with default values */
5591     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5592     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
5593
5594     /* Parse -o options */
5595     if (options) {
5596         if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5597             error_setg(errp, "Invalid options for file format '%s'", fmt);
5598             goto out;
5599         }
5600     }
5601
5602     if (base_filename) {
5603         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5604             error_setg(errp, "Backing file not supported for file format '%s'",
5605                        fmt);
5606             goto out;
5607         }
5608     }
5609
5610     if (base_fmt) {
5611         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5612             error_setg(errp, "Backing file format not supported for file "
5613                              "format '%s'", fmt);
5614             goto out;
5615         }
5616     }
5617
5618     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5619     if (backing_file) {
5620         if (!strcmp(filename, backing_file)) {
5621             error_setg(errp, "Error: Trying to create an image with the "
5622                              "same filename as the backing file");
5623             goto out;
5624         }
5625     }
5626
5627     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5628     if (backing_fmt) {
5629         backing_drv = bdrv_find_format(backing_fmt);
5630         if (!backing_drv) {
5631             error_setg(errp, "Unknown backing file format '%s'",
5632                        backing_fmt);
5633             goto out;
5634         }
5635     }
5636
5637     // The size for the image must always be specified, with one exception:
5638     // If we are using a backing file, we can obtain the size from there
5639     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5640     if (size == -1) {
5641         if (backing_file) {
5642             BlockDriverState *bs;
5643             int64_t size;
5644             int back_flags;
5645
5646             /* backing files always opened read-only */
5647             back_flags =
5648                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5649
5650             bs = NULL;
5651             ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5652                             backing_drv, &local_err);
5653             if (ret < 0) {
5654                 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5655                                  backing_file,
5656                                  error_get_pretty(local_err));
5657                 error_free(local_err);
5658                 local_err = NULL;
5659                 goto out;
5660             }
5661             size = bdrv_getlength(bs);
5662             if (size < 0) {
5663                 error_setg_errno(errp, -size, "Could not get size of '%s'",
5664                                  backing_file);
5665                 bdrv_unref(bs);
5666                 goto out;
5667             }
5668
5669             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5670
5671             bdrv_unref(bs);
5672         } else {
5673             error_setg(errp, "Image creation needs a size parameter");
5674             goto out;
5675         }
5676     }
5677
5678     if (!quiet) {
5679         printf("Formatting '%s', fmt=%s ", filename, fmt);
5680         qemu_opts_print(opts);
5681         puts("");
5682     }
5683
5684     ret = bdrv_create(drv, filename, opts, &local_err);
5685
5686     if (ret == -EFBIG) {
5687         /* This is generally a better message than whatever the driver would
5688          * deliver (especially because of the cluster_size_hint), since that
5689          * is most probably not much different from "image too large". */
5690         const char *cluster_size_hint = "";
5691         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5692             cluster_size_hint = " (try using a larger cluster size)";
5693         }
5694         error_setg(errp, "The image size is too large for file format '%s'"
5695                    "%s", fmt, cluster_size_hint);
5696         error_free(local_err);
5697         local_err = NULL;
5698     }
5699
5700 out:
5701     qemu_opts_del(opts);
5702     qemu_opts_free(create_opts);
5703     if (local_err) {
5704         error_propagate(errp, local_err);
5705     }
5706 }
5707
5708 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5709 {
5710     return bs->aio_context;
5711 }
5712
5713 void bdrv_detach_aio_context(BlockDriverState *bs)
5714 {
5715     if (!bs->drv) {
5716         return;
5717     }
5718
5719     if (bs->io_limits_enabled) {
5720         throttle_detach_aio_context(&bs->throttle_state);
5721     }
5722     if (bs->drv->bdrv_detach_aio_context) {
5723         bs->drv->bdrv_detach_aio_context(bs);
5724     }
5725     if (bs->file) {
5726         bdrv_detach_aio_context(bs->file);
5727     }
5728     if (bs->backing_hd) {
5729         bdrv_detach_aio_context(bs->backing_hd);
5730     }
5731
5732     bs->aio_context = NULL;
5733 }
5734
5735 void bdrv_attach_aio_context(BlockDriverState *bs,
5736                              AioContext *new_context)
5737 {
5738     if (!bs->drv) {
5739         return;
5740     }
5741
5742     bs->aio_context = new_context;
5743
5744     if (bs->backing_hd) {
5745         bdrv_attach_aio_context(bs->backing_hd, new_context);
5746     }
5747     if (bs->file) {
5748         bdrv_attach_aio_context(bs->file, new_context);
5749     }
5750     if (bs->drv->bdrv_attach_aio_context) {
5751         bs->drv->bdrv_attach_aio_context(bs, new_context);
5752     }
5753     if (bs->io_limits_enabled) {
5754         throttle_attach_aio_context(&bs->throttle_state, new_context);
5755     }
5756 }
5757
5758 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5759 {
5760     bdrv_drain_all(); /* ensure there are no in-flight requests */
5761
5762     bdrv_detach_aio_context(bs);
5763
5764     /* This function executes in the old AioContext so acquire the new one in
5765      * case it runs in a different thread.
5766      */
5767     aio_context_acquire(new_context);
5768     bdrv_attach_aio_context(bs, new_context);
5769     aio_context_release(new_context);
5770 }
5771
5772 void bdrv_add_before_write_notifier(BlockDriverState *bs,
5773                                     NotifierWithReturn *notifier)
5774 {
5775     notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5776 }
5777
5778 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
5779 {
5780     if (!bs->drv->bdrv_amend_options) {
5781         return -ENOTSUP;
5782     }
5783     return bs->drv->bdrv_amend_options(bs, opts);
5784 }
5785
5786 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5787  * of block filter and by bdrv_is_first_non_filter.
5788  * It is used to test if the given bs is the candidate or recurse more in the
5789  * node graph.
5790  */
5791 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5792                                       BlockDriverState *candidate)
5793 {
5794     /* return false if basic checks fails */
5795     if (!bs || !bs->drv) {
5796         return false;
5797     }
5798
5799     /* the code reached a non block filter driver -> check if the bs is
5800      * the same as the candidate. It's the recursion termination condition.
5801      */
5802     if (!bs->drv->is_filter) {
5803         return bs == candidate;
5804     }
5805     /* Down this path the driver is a block filter driver */
5806
5807     /* If the block filter recursion method is defined use it to recurse down
5808      * the node graph.
5809      */
5810     if (bs->drv->bdrv_recurse_is_first_non_filter) {
5811         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5812     }
5813
5814     /* the driver is a block filter but don't allow to recurse -> return false
5815      */
5816     return false;
5817 }
5818
5819 /* This function checks if the candidate is the first non filter bs down it's
5820  * bs chain. Since we don't have pointers to parents it explore all bs chains
5821  * from the top. Some filters can choose not to pass down the recursion.
5822  */
5823 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5824 {
5825     BlockDriverState *bs;
5826
5827     /* walk down the bs forest recursively */
5828     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5829         bool perm;
5830
5831         /* try to recurse in this top level bs */
5832         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5833
5834         /* candidate is the first non filter */
5835         if (perm) {
5836             return true;
5837         }
5838     }
5839
5840     return false;
5841 }
5842
5843 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5844 {
5845     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5846     if (!to_replace_bs) {
5847         error_setg(errp, "Node name '%s' not found", node_name);
5848         return NULL;
5849     }
5850
5851     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5852         return NULL;
5853     }
5854
5855     /* We don't want arbitrary node of the BDS chain to be replaced only the top
5856      * most non filter in order to prevent data corruption.
5857      * Another benefit is that this tests exclude backing files which are
5858      * blocked by the backing blockers.
5859      */
5860     if (!bdrv_is_first_non_filter(to_replace_bs)) {
5861         error_setg(errp, "Only top most non filter can be replaced");
5862         return NULL;
5863     }
5864
5865     return to_replace_bs;
5866 }
5867
5868 void bdrv_io_plug(BlockDriverState *bs)
5869 {
5870     BlockDriver *drv = bs->drv;
5871     if (drv && drv->bdrv_io_plug) {
5872         drv->bdrv_io_plug(bs);
5873     } else if (bs->file) {
5874         bdrv_io_plug(bs->file);
5875     }
5876 }
5877
5878 void bdrv_io_unplug(BlockDriverState *bs)
5879 {
5880     BlockDriver *drv = bs->drv;
5881     if (drv && drv->bdrv_io_unplug) {
5882         drv->bdrv_io_unplug(bs);
5883     } else if (bs->file) {
5884         bdrv_io_unplug(bs->file);
5885     }
5886 }
5887
5888 void bdrv_flush_io_queue(BlockDriverState *bs)
5889 {
5890     BlockDriver *drv = bs->drv;
5891     if (drv && drv->bdrv_flush_io_queue) {
5892         drv->bdrv_flush_io_queue(bs);
5893     } else if (bs->file) {
5894         bdrv_flush_io_queue(bs->file);
5895     }
5896 }