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->bdrv_check == NULL) {
2213         return -ENOTSUP;
2214     }
2215
2216     memset(res, 0, sizeof(*res));
2217     return bs->drv->bdrv_check(bs, res, fix);
2218 }
2219
2220 #define COMMIT_BUF_SECTORS 2048
2221
2222 /* commit COW file into the raw image */
2223 int bdrv_commit(BlockDriverState *bs)
2224 {
2225     BlockDriver *drv = bs->drv;
2226     int64_t sector, total_sectors, length, backing_length;
2227     int n, ro, open_flags;
2228     int ret = 0;
2229     uint8_t *buf = NULL;
2230     char filename[PATH_MAX];
2231
2232     if (!drv)
2233         return -ENOMEDIUM;
2234
2235     if (!bs->backing_hd) {
2236         return -ENOTSUP;
2237     }
2238
2239     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2240         bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2241         return -EBUSY;
2242     }
2243
2244     ro = bs->backing_hd->read_only;
2245     /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2246     pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2247     open_flags =  bs->backing_hd->open_flags;
2248
2249     if (ro) {
2250         if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2251             return -EACCES;
2252         }
2253     }
2254
2255     length = bdrv_getlength(bs);
2256     if (length < 0) {
2257         ret = length;
2258         goto ro_cleanup;
2259     }
2260
2261     backing_length = bdrv_getlength(bs->backing_hd);
2262     if (backing_length < 0) {
2263         ret = backing_length;
2264         goto ro_cleanup;
2265     }
2266
2267     /* If our top snapshot is larger than the backing file image,
2268      * grow the backing file image if possible.  If not possible,
2269      * we must return an error */
2270     if (length > backing_length) {
2271         ret = bdrv_truncate(bs->backing_hd, length);
2272         if (ret < 0) {
2273             goto ro_cleanup;
2274         }
2275     }
2276
2277     total_sectors = length >> BDRV_SECTOR_BITS;
2278
2279     /* qemu_try_blockalign() for bs will choose an alignment that works for
2280      * bs->backing_hd as well, so no need to compare the alignment manually. */
2281     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2282     if (buf == NULL) {
2283         ret = -ENOMEM;
2284         goto ro_cleanup;
2285     }
2286
2287     for (sector = 0; sector < total_sectors; sector += n) {
2288         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2289         if (ret < 0) {
2290             goto ro_cleanup;
2291         }
2292         if (ret) {
2293             ret = bdrv_read(bs, sector, buf, n);
2294             if (ret < 0) {
2295                 goto ro_cleanup;
2296             }
2297
2298             ret = bdrv_write(bs->backing_hd, sector, buf, n);
2299             if (ret < 0) {
2300                 goto ro_cleanup;
2301             }
2302         }
2303     }
2304
2305     if (drv->bdrv_make_empty) {
2306         ret = drv->bdrv_make_empty(bs);
2307         if (ret < 0) {
2308             goto ro_cleanup;
2309         }
2310         bdrv_flush(bs);
2311     }
2312
2313     /*
2314      * Make sure all data we wrote to the backing device is actually
2315      * stable on disk.
2316      */
2317     if (bs->backing_hd) {
2318         bdrv_flush(bs->backing_hd);
2319     }
2320
2321     ret = 0;
2322 ro_cleanup:
2323     qemu_vfree(buf);
2324
2325     if (ro) {
2326         /* ignoring error return here */
2327         bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2328     }
2329
2330     return ret;
2331 }
2332
2333 int bdrv_commit_all(void)
2334 {
2335     BlockDriverState *bs;
2336
2337     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2338         AioContext *aio_context = bdrv_get_aio_context(bs);
2339
2340         aio_context_acquire(aio_context);
2341         if (bs->drv && bs->backing_hd) {
2342             int ret = bdrv_commit(bs);
2343             if (ret < 0) {
2344                 aio_context_release(aio_context);
2345                 return ret;
2346             }
2347         }
2348         aio_context_release(aio_context);
2349     }
2350     return 0;
2351 }
2352
2353 /**
2354  * Remove an active request from the tracked requests list
2355  *
2356  * This function should be called when a tracked request is completing.
2357  */
2358 static void tracked_request_end(BdrvTrackedRequest *req)
2359 {
2360     if (req->serialising) {
2361         req->bs->serialising_in_flight--;
2362     }
2363
2364     QLIST_REMOVE(req, list);
2365     qemu_co_queue_restart_all(&req->wait_queue);
2366 }
2367
2368 /**
2369  * Add an active request to the tracked requests list
2370  */
2371 static void tracked_request_begin(BdrvTrackedRequest *req,
2372                                   BlockDriverState *bs,
2373                                   int64_t offset,
2374                                   unsigned int bytes, bool is_write)
2375 {
2376     *req = (BdrvTrackedRequest){
2377         .bs = bs,
2378         .offset         = offset,
2379         .bytes          = bytes,
2380         .is_write       = is_write,
2381         .co             = qemu_coroutine_self(),
2382         .serialising    = false,
2383         .overlap_offset = offset,
2384         .overlap_bytes  = bytes,
2385     };
2386
2387     qemu_co_queue_init(&req->wait_queue);
2388
2389     QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2390 }
2391
2392 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2393 {
2394     int64_t overlap_offset = req->offset & ~(align - 1);
2395     unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2396                                - overlap_offset;
2397
2398     if (!req->serialising) {
2399         req->bs->serialising_in_flight++;
2400         req->serialising = true;
2401     }
2402
2403     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2404     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2405 }
2406
2407 /**
2408  * Round a region to cluster boundaries
2409  */
2410 void bdrv_round_to_clusters(BlockDriverState *bs,
2411                             int64_t sector_num, int nb_sectors,
2412                             int64_t *cluster_sector_num,
2413                             int *cluster_nb_sectors)
2414 {
2415     BlockDriverInfo bdi;
2416
2417     if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2418         *cluster_sector_num = sector_num;
2419         *cluster_nb_sectors = nb_sectors;
2420     } else {
2421         int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2422         *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2423         *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2424                                             nb_sectors, c);
2425     }
2426 }
2427
2428 static int bdrv_get_cluster_size(BlockDriverState *bs)
2429 {
2430     BlockDriverInfo bdi;
2431     int ret;
2432
2433     ret = bdrv_get_info(bs, &bdi);
2434     if (ret < 0 || bdi.cluster_size == 0) {
2435         return bs->request_alignment;
2436     } else {
2437         return bdi.cluster_size;
2438     }
2439 }
2440
2441 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2442                                      int64_t offset, unsigned int bytes)
2443 {
2444     /*        aaaa   bbbb */
2445     if (offset >= req->overlap_offset + req->overlap_bytes) {
2446         return false;
2447     }
2448     /* bbbb   aaaa        */
2449     if (req->overlap_offset >= offset + bytes) {
2450         return false;
2451     }
2452     return true;
2453 }
2454
2455 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2456 {
2457     BlockDriverState *bs = self->bs;
2458     BdrvTrackedRequest *req;
2459     bool retry;
2460     bool waited = false;
2461
2462     if (!bs->serialising_in_flight) {
2463         return false;
2464     }
2465
2466     do {
2467         retry = false;
2468         QLIST_FOREACH(req, &bs->tracked_requests, list) {
2469             if (req == self || (!req->serialising && !self->serialising)) {
2470                 continue;
2471             }
2472             if (tracked_request_overlaps(req, self->overlap_offset,
2473                                          self->overlap_bytes))
2474             {
2475                 /* Hitting this means there was a reentrant request, for
2476                  * example, a block driver issuing nested requests.  This must
2477                  * never happen since it means deadlock.
2478                  */
2479                 assert(qemu_coroutine_self() != req->co);
2480
2481                 /* If the request is already (indirectly) waiting for us, or
2482                  * will wait for us as soon as it wakes up, then just go on
2483                  * (instead of producing a deadlock in the former case). */
2484                 if (!req->waiting_for) {
2485                     self->waiting_for = req;
2486                     qemu_co_queue_wait(&req->wait_queue);
2487                     self->waiting_for = NULL;
2488                     retry = true;
2489                     waited = true;
2490                     break;
2491                 }
2492             }
2493         }
2494     } while (retry);
2495
2496     return waited;
2497 }
2498
2499 /*
2500  * Return values:
2501  * 0        - success
2502  * -EINVAL  - backing format specified, but no file
2503  * -ENOSPC  - can't update the backing file because no space is left in the
2504  *            image file header
2505  * -ENOTSUP - format driver doesn't support changing the backing file
2506  */
2507 int bdrv_change_backing_file(BlockDriverState *bs,
2508     const char *backing_file, const char *backing_fmt)
2509 {
2510     BlockDriver *drv = bs->drv;
2511     int ret;
2512
2513     /* Backing file format doesn't make sense without a backing file */
2514     if (backing_fmt && !backing_file) {
2515         return -EINVAL;
2516     }
2517
2518     if (drv->bdrv_change_backing_file != NULL) {
2519         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2520     } else {
2521         ret = -ENOTSUP;
2522     }
2523
2524     if (ret == 0) {
2525         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2526         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2527     }
2528     return ret;
2529 }
2530
2531 /*
2532  * Finds the image layer in the chain that has 'bs' as its backing file.
2533  *
2534  * active is the current topmost image.
2535  *
2536  * Returns NULL if bs is not found in active's image chain,
2537  * or if active == bs.
2538  *
2539  * Returns the bottommost base image if bs == NULL.
2540  */
2541 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2542                                     BlockDriverState *bs)
2543 {
2544     while (active && bs != active->backing_hd) {
2545         active = active->backing_hd;
2546     }
2547
2548     return active;
2549 }
2550
2551 /* Given a BDS, searches for the base layer. */
2552 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2553 {
2554     return bdrv_find_overlay(bs, NULL);
2555 }
2556
2557 typedef struct BlkIntermediateStates {
2558     BlockDriverState *bs;
2559     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2560 } BlkIntermediateStates;
2561
2562
2563 /*
2564  * Drops images above 'base' up to and including 'top', and sets the image
2565  * above 'top' to have base as its backing file.
2566  *
2567  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2568  * information in 'bs' can be properly updated.
2569  *
2570  * E.g., this will convert the following chain:
2571  * bottom <- base <- intermediate <- top <- active
2572  *
2573  * to
2574  *
2575  * bottom <- base <- active
2576  *
2577  * It is allowed for bottom==base, in which case it converts:
2578  *
2579  * base <- intermediate <- top <- active
2580  *
2581  * to
2582  *
2583  * base <- active
2584  *
2585  * If backing_file_str is non-NULL, it will be used when modifying top's
2586  * overlay image metadata.
2587  *
2588  * Error conditions:
2589  *  if active == top, that is considered an error
2590  *
2591  */
2592 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2593                            BlockDriverState *base, const char *backing_file_str)
2594 {
2595     BlockDriverState *intermediate;
2596     BlockDriverState *base_bs = NULL;
2597     BlockDriverState *new_top_bs = NULL;
2598     BlkIntermediateStates *intermediate_state, *next;
2599     int ret = -EIO;
2600
2601     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2602     QSIMPLEQ_INIT(&states_to_delete);
2603
2604     if (!top->drv || !base->drv) {
2605         goto exit;
2606     }
2607
2608     new_top_bs = bdrv_find_overlay(active, top);
2609
2610     if (new_top_bs == NULL) {
2611         /* we could not find the image above 'top', this is an error */
2612         goto exit;
2613     }
2614
2615     /* special case of new_top_bs->backing_hd already pointing to base - nothing
2616      * to do, no intermediate images */
2617     if (new_top_bs->backing_hd == base) {
2618         ret = 0;
2619         goto exit;
2620     }
2621
2622     intermediate = top;
2623
2624     /* now we will go down through the list, and add each BDS we find
2625      * into our deletion queue, until we hit the 'base'
2626      */
2627     while (intermediate) {
2628         intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2629         intermediate_state->bs = intermediate;
2630         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2631
2632         if (intermediate->backing_hd == base) {
2633             base_bs = intermediate->backing_hd;
2634             break;
2635         }
2636         intermediate = intermediate->backing_hd;
2637     }
2638     if (base_bs == NULL) {
2639         /* something went wrong, we did not end at the base. safely
2640          * unravel everything, and exit with error */
2641         goto exit;
2642     }
2643
2644     /* success - we can delete the intermediate states, and link top->base */
2645     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2646     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2647                                    base_bs->drv ? base_bs->drv->format_name : "");
2648     if (ret) {
2649         goto exit;
2650     }
2651     bdrv_set_backing_hd(new_top_bs, base_bs);
2652
2653     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2654         /* so that bdrv_close() does not recursively close the chain */
2655         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2656         bdrv_unref(intermediate_state->bs);
2657     }
2658     ret = 0;
2659
2660 exit:
2661     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2662         g_free(intermediate_state);
2663     }
2664     return ret;
2665 }
2666
2667
2668 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2669                                    size_t size)
2670 {
2671     int64_t len;
2672
2673     if (size > INT_MAX) {
2674         return -EIO;
2675     }
2676
2677     if (!bdrv_is_inserted(bs))
2678         return -ENOMEDIUM;
2679
2680     if (bs->growable)
2681         return 0;
2682
2683     len = bdrv_getlength(bs);
2684
2685     if (offset < 0)
2686         return -EIO;
2687
2688     if ((offset > len) || (len - offset < size))
2689         return -EIO;
2690
2691     return 0;
2692 }
2693
2694 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2695                               int nb_sectors)
2696 {
2697     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2698         return -EIO;
2699     }
2700
2701     return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2702                                    nb_sectors * BDRV_SECTOR_SIZE);
2703 }
2704
2705 typedef struct RwCo {
2706     BlockDriverState *bs;
2707     int64_t offset;
2708     QEMUIOVector *qiov;
2709     bool is_write;
2710     int ret;
2711     BdrvRequestFlags flags;
2712 } RwCo;
2713
2714 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2715 {
2716     RwCo *rwco = opaque;
2717
2718     if (!rwco->is_write) {
2719         rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2720                                       rwco->qiov->size, rwco->qiov,
2721                                       rwco->flags);
2722     } else {
2723         rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2724                                        rwco->qiov->size, rwco->qiov,
2725                                        rwco->flags);
2726     }
2727 }
2728
2729 /*
2730  * Process a vectored synchronous request using coroutines
2731  */
2732 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2733                         QEMUIOVector *qiov, bool is_write,
2734                         BdrvRequestFlags flags)
2735 {
2736     Coroutine *co;
2737     RwCo rwco = {
2738         .bs = bs,
2739         .offset = offset,
2740         .qiov = qiov,
2741         .is_write = is_write,
2742         .ret = NOT_DONE,
2743         .flags = flags,
2744     };
2745
2746     /**
2747      * In sync call context, when the vcpu is blocked, this throttling timer
2748      * will not fire; so the I/O throttling function has to be disabled here
2749      * if it has been enabled.
2750      */
2751     if (bs->io_limits_enabled) {
2752         fprintf(stderr, "Disabling I/O throttling on '%s' due "
2753                         "to synchronous I/O.\n", bdrv_get_device_name(bs));
2754         bdrv_io_limits_disable(bs);
2755     }
2756
2757     if (qemu_in_coroutine()) {
2758         /* Fast-path if already in coroutine context */
2759         bdrv_rw_co_entry(&rwco);
2760     } else {
2761         AioContext *aio_context = bdrv_get_aio_context(bs);
2762
2763         co = qemu_coroutine_create(bdrv_rw_co_entry);
2764         qemu_coroutine_enter(co, &rwco);
2765         while (rwco.ret == NOT_DONE) {
2766             aio_poll(aio_context, true);
2767         }
2768     }
2769     return rwco.ret;
2770 }
2771
2772 /*
2773  * Process a synchronous request using coroutines
2774  */
2775 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2776                       int nb_sectors, bool is_write, BdrvRequestFlags flags)
2777 {
2778     QEMUIOVector qiov;
2779     struct iovec iov = {
2780         .iov_base = (void *)buf,
2781         .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2782     };
2783
2784     if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2785         return -EINVAL;
2786     }
2787
2788     qemu_iovec_init_external(&qiov, &iov, 1);
2789     return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2790                         &qiov, is_write, flags);
2791 }
2792
2793 /* return < 0 if error. See bdrv_write() for the return codes */
2794 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2795               uint8_t *buf, int nb_sectors)
2796 {
2797     return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2798 }
2799
2800 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2801 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2802                           uint8_t *buf, int nb_sectors)
2803 {
2804     bool enabled;
2805     int ret;
2806
2807     enabled = bs->io_limits_enabled;
2808     bs->io_limits_enabled = false;
2809     ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2810     bs->io_limits_enabled = enabled;
2811     return ret;
2812 }
2813
2814 /* Return < 0 if error. Important errors are:
2815   -EIO         generic I/O error (may happen for all errors)
2816   -ENOMEDIUM   No media inserted.
2817   -EINVAL      Invalid sector number or nb_sectors
2818   -EACCES      Trying to write a read-only device
2819 */
2820 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2821                const uint8_t *buf, int nb_sectors)
2822 {
2823     return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2824 }
2825
2826 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2827                       int nb_sectors, BdrvRequestFlags flags)
2828 {
2829     return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2830                       BDRV_REQ_ZERO_WRITE | flags);
2831 }
2832
2833 /*
2834  * Completely zero out a block device with the help of bdrv_write_zeroes.
2835  * The operation is sped up by checking the block status and only writing
2836  * zeroes to the device if they currently do not return zeroes. Optional
2837  * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2838  *
2839  * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2840  */
2841 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2842 {
2843     int64_t target_sectors, ret, nb_sectors, sector_num = 0;
2844     int n;
2845
2846     target_sectors = bdrv_nb_sectors(bs);
2847     if (target_sectors < 0) {
2848         return target_sectors;
2849     }
2850
2851     for (;;) {
2852         nb_sectors = target_sectors - sector_num;
2853         if (nb_sectors <= 0) {
2854             return 0;
2855         }
2856         if (nb_sectors > INT_MAX) {
2857             nb_sectors = INT_MAX;
2858         }
2859         ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2860         if (ret < 0) {
2861             error_report("error getting block status at sector %" PRId64 ": %s",
2862                          sector_num, strerror(-ret));
2863             return ret;
2864         }
2865         if (ret & BDRV_BLOCK_ZERO) {
2866             sector_num += n;
2867             continue;
2868         }
2869         ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2870         if (ret < 0) {
2871             error_report("error writing zeroes at sector %" PRId64 ": %s",
2872                          sector_num, strerror(-ret));
2873             return ret;
2874         }
2875         sector_num += n;
2876     }
2877 }
2878
2879 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2880 {
2881     QEMUIOVector qiov;
2882     struct iovec iov = {
2883         .iov_base = (void *)buf,
2884         .iov_len = bytes,
2885     };
2886     int ret;
2887
2888     if (bytes < 0) {
2889         return -EINVAL;
2890     }
2891
2892     qemu_iovec_init_external(&qiov, &iov, 1);
2893     ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2894     if (ret < 0) {
2895         return ret;
2896     }
2897
2898     return bytes;
2899 }
2900
2901 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2902 {
2903     int ret;
2904
2905     ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2906     if (ret < 0) {
2907         return ret;
2908     }
2909
2910     return qiov->size;
2911 }
2912
2913 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2914                 const void *buf, int bytes)
2915 {
2916     QEMUIOVector qiov;
2917     struct iovec iov = {
2918         .iov_base   = (void *) buf,
2919         .iov_len    = bytes,
2920     };
2921
2922     if (bytes < 0) {
2923         return -EINVAL;
2924     }
2925
2926     qemu_iovec_init_external(&qiov, &iov, 1);
2927     return bdrv_pwritev(bs, offset, &qiov);
2928 }
2929
2930 /*
2931  * Writes to the file and ensures that no writes are reordered across this
2932  * request (acts as a barrier)
2933  *
2934  * Returns 0 on success, -errno in error cases.
2935  */
2936 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2937     const void *buf, int count)
2938 {
2939     int ret;
2940
2941     ret = bdrv_pwrite(bs, offset, buf, count);
2942     if (ret < 0) {
2943         return ret;
2944     }
2945
2946     /* No flush needed for cache modes that already do it */
2947     if (bs->enable_write_cache) {
2948         bdrv_flush(bs);
2949     }
2950
2951     return 0;
2952 }
2953
2954 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2955         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2956 {
2957     /* Perform I/O through a temporary buffer so that users who scribble over
2958      * their read buffer while the operation is in progress do not end up
2959      * modifying the image file.  This is critical for zero-copy guest I/O
2960      * where anything might happen inside guest memory.
2961      */
2962     void *bounce_buffer;
2963
2964     BlockDriver *drv = bs->drv;
2965     struct iovec iov;
2966     QEMUIOVector bounce_qiov;
2967     int64_t cluster_sector_num;
2968     int cluster_nb_sectors;
2969     size_t skip_bytes;
2970     int ret;
2971
2972     /* Cover entire cluster so no additional backing file I/O is required when
2973      * allocating cluster in the image file.
2974      */
2975     bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2976                            &cluster_sector_num, &cluster_nb_sectors);
2977
2978     trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2979                                    cluster_sector_num, cluster_nb_sectors);
2980
2981     iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2982     iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
2983     if (bounce_buffer == NULL) {
2984         ret = -ENOMEM;
2985         goto err;
2986     }
2987
2988     qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2989
2990     ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2991                              &bounce_qiov);
2992     if (ret < 0) {
2993         goto err;
2994     }
2995
2996     if (drv->bdrv_co_write_zeroes &&
2997         buffer_is_zero(bounce_buffer, iov.iov_len)) {
2998         ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2999                                       cluster_nb_sectors, 0);
3000     } else {
3001         /* This does not change the data on the disk, it is not necessary
3002          * to flush even in cache=writethrough mode.
3003          */
3004         ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
3005                                   &bounce_qiov);
3006     }
3007
3008     if (ret < 0) {
3009         /* It might be okay to ignore write errors for guest requests.  If this
3010          * is a deliberate copy-on-read then we don't want to ignore the error.
3011          * Simply report it in all cases.
3012          */
3013         goto err;
3014     }
3015
3016     skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3017     qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3018                         nb_sectors * BDRV_SECTOR_SIZE);
3019
3020 err:
3021     qemu_vfree(bounce_buffer);
3022     return ret;
3023 }
3024
3025 /*
3026  * Forwards an already correctly aligned request to the BlockDriver. This
3027  * handles copy on read and zeroing after EOF; any other features must be
3028  * implemented by the caller.
3029  */
3030 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3031     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3032     int64_t align, QEMUIOVector *qiov, int flags)
3033 {
3034     BlockDriver *drv = bs->drv;
3035     int ret;
3036
3037     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3038     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3039
3040     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3041     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3042     assert(!qiov || bytes == qiov->size);
3043
3044     /* Handle Copy on Read and associated serialisation */
3045     if (flags & BDRV_REQ_COPY_ON_READ) {
3046         /* If we touch the same cluster it counts as an overlap.  This
3047          * guarantees that allocating writes will be serialized and not race
3048          * with each other for the same cluster.  For example, in copy-on-read
3049          * it ensures that the CoR read and write operations are atomic and
3050          * guest writes cannot interleave between them. */
3051         mark_request_serialising(req, bdrv_get_cluster_size(bs));
3052     }
3053
3054     wait_serialising_requests(req);
3055
3056     if (flags & BDRV_REQ_COPY_ON_READ) {
3057         int pnum;
3058
3059         ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3060         if (ret < 0) {
3061             goto out;
3062         }
3063
3064         if (!ret || pnum != nb_sectors) {
3065             ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3066             goto out;
3067         }
3068     }
3069
3070     /* Forward the request to the BlockDriver */
3071     if (!(bs->zero_beyond_eof && bs->growable)) {
3072         ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3073     } else {
3074         /* Read zeros after EOF of growable BDSes */
3075         int64_t total_sectors, max_nb_sectors;
3076
3077         total_sectors = bdrv_nb_sectors(bs);
3078         if (total_sectors < 0) {
3079             ret = total_sectors;
3080             goto out;
3081         }
3082
3083         max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3084                                   align >> BDRV_SECTOR_BITS);
3085         if (max_nb_sectors > 0) {
3086             QEMUIOVector local_qiov;
3087             size_t local_sectors;
3088
3089             max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
3090             local_sectors = MIN(max_nb_sectors, nb_sectors);
3091
3092             qemu_iovec_init(&local_qiov, qiov->niov);
3093             qemu_iovec_concat(&local_qiov, qiov, 0,
3094                               local_sectors * BDRV_SECTOR_SIZE);
3095
3096             ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
3097                                      &local_qiov);
3098
3099             qemu_iovec_destroy(&local_qiov);
3100         } else {
3101             ret = 0;
3102         }
3103
3104         /* Reading beyond end of file is supposed to produce zeroes */
3105         if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3106             uint64_t offset = MAX(0, total_sectors - sector_num);
3107             uint64_t bytes = (sector_num + nb_sectors - offset) *
3108                               BDRV_SECTOR_SIZE;
3109             qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3110         }
3111     }
3112
3113 out:
3114     return ret;
3115 }
3116
3117 /*
3118  * Handle a read request in coroutine context
3119  */
3120 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3121     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3122     BdrvRequestFlags flags)
3123 {
3124     BlockDriver *drv = bs->drv;
3125     BdrvTrackedRequest req;
3126
3127     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3128     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3129     uint8_t *head_buf = NULL;
3130     uint8_t *tail_buf = NULL;
3131     QEMUIOVector local_qiov;
3132     bool use_local_qiov = false;
3133     int ret;
3134
3135     if (!drv) {
3136         return -ENOMEDIUM;
3137     }
3138     if (bdrv_check_byte_request(bs, offset, bytes)) {
3139         return -EIO;
3140     }
3141
3142     if (bs->copy_on_read) {
3143         flags |= BDRV_REQ_COPY_ON_READ;
3144     }
3145
3146     /* throttling disk I/O */
3147     if (bs->io_limits_enabled) {
3148         bdrv_io_limits_intercept(bs, bytes, false);
3149     }
3150
3151     /* Align read if necessary by padding qiov */
3152     if (offset & (align - 1)) {
3153         head_buf = qemu_blockalign(bs, align);
3154         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3155         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3156         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3157         use_local_qiov = true;
3158
3159         bytes += offset & (align - 1);
3160         offset = offset & ~(align - 1);
3161     }
3162
3163     if ((offset + bytes) & (align - 1)) {
3164         if (!use_local_qiov) {
3165             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3166             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3167             use_local_qiov = true;
3168         }
3169         tail_buf = qemu_blockalign(bs, align);
3170         qemu_iovec_add(&local_qiov, tail_buf,
3171                        align - ((offset + bytes) & (align - 1)));
3172
3173         bytes = ROUND_UP(bytes, align);
3174     }
3175
3176     tracked_request_begin(&req, bs, offset, bytes, false);
3177     ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3178                               use_local_qiov ? &local_qiov : qiov,
3179                               flags);
3180     tracked_request_end(&req);
3181
3182     if (use_local_qiov) {
3183         qemu_iovec_destroy(&local_qiov);
3184         qemu_vfree(head_buf);
3185         qemu_vfree(tail_buf);
3186     }
3187
3188     return ret;
3189 }
3190
3191 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3192     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3193     BdrvRequestFlags flags)
3194 {
3195     if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3196         return -EINVAL;
3197     }
3198
3199     return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3200                              nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3201 }
3202
3203 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3204     int nb_sectors, QEMUIOVector *qiov)
3205 {
3206     trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3207
3208     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3209 }
3210
3211 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3212     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3213 {
3214     trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3215
3216     return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3217                             BDRV_REQ_COPY_ON_READ);
3218 }
3219
3220 /* if no limit is specified in the BlockLimits use a default
3221  * of 32768 512-byte sectors (16 MiB) per request.
3222  */
3223 #define MAX_WRITE_ZEROES_DEFAULT 32768
3224
3225 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3226     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3227 {
3228     BlockDriver *drv = bs->drv;
3229     QEMUIOVector qiov;
3230     struct iovec iov = {0};
3231     int ret = 0;
3232
3233     int max_write_zeroes = bs->bl.max_write_zeroes ?
3234                            bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3235
3236     while (nb_sectors > 0 && !ret) {
3237         int num = nb_sectors;
3238
3239         /* Align request.  Block drivers can expect the "bulk" of the request
3240          * to be aligned.
3241          */
3242         if (bs->bl.write_zeroes_alignment
3243             && num > bs->bl.write_zeroes_alignment) {
3244             if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3245                 /* Make a small request up to the first aligned sector.  */
3246                 num = bs->bl.write_zeroes_alignment;
3247                 num -= sector_num % bs->bl.write_zeroes_alignment;
3248             } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3249                 /* Shorten the request to the last aligned sector.  num cannot
3250                  * underflow because num > bs->bl.write_zeroes_alignment.
3251                  */
3252                 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3253             }
3254         }
3255
3256         /* limit request size */
3257         if (num > max_write_zeroes) {
3258             num = max_write_zeroes;
3259         }
3260
3261         ret = -ENOTSUP;
3262         /* First try the efficient write zeroes operation */
3263         if (drv->bdrv_co_write_zeroes) {
3264             ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3265         }
3266
3267         if (ret == -ENOTSUP) {
3268             /* Fall back to bounce buffer if write zeroes is unsupported */
3269             iov.iov_len = num * BDRV_SECTOR_SIZE;
3270             if (iov.iov_base == NULL) {
3271                 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
3272                 if (iov.iov_base == NULL) {
3273                     ret = -ENOMEM;
3274                     goto fail;
3275                 }
3276                 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3277             }
3278             qemu_iovec_init_external(&qiov, &iov, 1);
3279
3280             ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3281
3282             /* Keep bounce buffer around if it is big enough for all
3283              * all future requests.
3284              */
3285             if (num < max_write_zeroes) {
3286                 qemu_vfree(iov.iov_base);
3287                 iov.iov_base = NULL;
3288             }
3289         }
3290
3291         sector_num += num;
3292         nb_sectors -= num;
3293     }
3294
3295 fail:
3296     qemu_vfree(iov.iov_base);
3297     return ret;
3298 }
3299
3300 /*
3301  * Forwards an already correctly aligned write request to the BlockDriver.
3302  */
3303 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3304     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3305     QEMUIOVector *qiov, int flags)
3306 {
3307     BlockDriver *drv = bs->drv;
3308     bool waited;
3309     int ret;
3310
3311     int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3312     unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3313
3314     assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3315     assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3316     assert(!qiov || bytes == qiov->size);
3317
3318     waited = wait_serialising_requests(req);
3319     assert(!waited || !req->serialising);
3320     assert(req->overlap_offset <= offset);
3321     assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3322
3323     ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3324
3325     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3326         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3327         qemu_iovec_is_zero(qiov)) {
3328         flags |= BDRV_REQ_ZERO_WRITE;
3329         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3330             flags |= BDRV_REQ_MAY_UNMAP;
3331         }
3332     }
3333
3334     if (ret < 0) {
3335         /* Do nothing, write notifier decided to fail this request */
3336     } else if (flags & BDRV_REQ_ZERO_WRITE) {
3337         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3338         ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3339     } else {
3340         BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3341         ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3342     }
3343     BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3344
3345     if (ret == 0 && !bs->enable_write_cache) {
3346         ret = bdrv_co_flush(bs);
3347     }
3348
3349     bdrv_set_dirty(bs, sector_num, nb_sectors);
3350
3351     if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3352         bs->wr_highest_sector = sector_num + nb_sectors - 1;
3353     }
3354     if (bs->growable && ret >= 0) {
3355         bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3356     }
3357
3358     return ret;
3359 }
3360
3361 /*
3362  * Handle a write request in coroutine context
3363  */
3364 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3365     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3366     BdrvRequestFlags flags)
3367 {
3368     BdrvTrackedRequest req;
3369     /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3370     uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3371     uint8_t *head_buf = NULL;
3372     uint8_t *tail_buf = NULL;
3373     QEMUIOVector local_qiov;
3374     bool use_local_qiov = false;
3375     int ret;
3376
3377     if (!bs->drv) {
3378         return -ENOMEDIUM;
3379     }
3380     if (bs->read_only) {
3381         return -EACCES;
3382     }
3383     if (bdrv_check_byte_request(bs, offset, bytes)) {
3384         return -EIO;
3385     }
3386
3387     /* throttling disk I/O */
3388     if (bs->io_limits_enabled) {
3389         bdrv_io_limits_intercept(bs, bytes, true);
3390     }
3391
3392     /*
3393      * Align write if necessary by performing a read-modify-write cycle.
3394      * Pad qiov with the read parts and be sure to have a tracked request not
3395      * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3396      */
3397     tracked_request_begin(&req, bs, offset, bytes, true);
3398
3399     if (offset & (align - 1)) {
3400         QEMUIOVector head_qiov;
3401         struct iovec head_iov;
3402
3403         mark_request_serialising(&req, align);
3404         wait_serialising_requests(&req);
3405
3406         head_buf = qemu_blockalign(bs, align);
3407         head_iov = (struct iovec) {
3408             .iov_base   = head_buf,
3409             .iov_len    = align,
3410         };
3411         qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3412
3413         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3414         ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3415                                   align, &head_qiov, 0);
3416         if (ret < 0) {
3417             goto fail;
3418         }
3419         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3420
3421         qemu_iovec_init(&local_qiov, qiov->niov + 2);
3422         qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3423         qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3424         use_local_qiov = true;
3425
3426         bytes += offset & (align - 1);
3427         offset = offset & ~(align - 1);
3428     }
3429
3430     if ((offset + bytes) & (align - 1)) {
3431         QEMUIOVector tail_qiov;
3432         struct iovec tail_iov;
3433         size_t tail_bytes;
3434         bool waited;
3435
3436         mark_request_serialising(&req, align);
3437         waited = wait_serialising_requests(&req);
3438         assert(!waited || !use_local_qiov);
3439
3440         tail_buf = qemu_blockalign(bs, align);
3441         tail_iov = (struct iovec) {
3442             .iov_base   = tail_buf,
3443             .iov_len    = align,
3444         };
3445         qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3446
3447         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3448         ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3449                                   align, &tail_qiov, 0);
3450         if (ret < 0) {
3451             goto fail;
3452         }
3453         BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3454
3455         if (!use_local_qiov) {
3456             qemu_iovec_init(&local_qiov, qiov->niov + 1);
3457             qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3458             use_local_qiov = true;
3459         }
3460
3461         tail_bytes = (offset + bytes) & (align - 1);
3462         qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3463
3464         bytes = ROUND_UP(bytes, align);
3465     }
3466
3467     ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3468                                use_local_qiov ? &local_qiov : qiov,
3469                                flags);
3470
3471 fail:
3472     tracked_request_end(&req);
3473
3474     if (use_local_qiov) {
3475         qemu_iovec_destroy(&local_qiov);
3476     }
3477     qemu_vfree(head_buf);
3478     qemu_vfree(tail_buf);
3479
3480     return ret;
3481 }
3482
3483 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3484     int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3485     BdrvRequestFlags flags)
3486 {
3487     if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3488         return -EINVAL;
3489     }
3490
3491     return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3492                               nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3493 }
3494
3495 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3496     int nb_sectors, QEMUIOVector *qiov)
3497 {
3498     trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3499
3500     return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3501 }
3502
3503 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3504                                       int64_t sector_num, int nb_sectors,
3505                                       BdrvRequestFlags flags)
3506 {
3507     trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3508
3509     if (!(bs->open_flags & BDRV_O_UNMAP)) {
3510         flags &= ~BDRV_REQ_MAY_UNMAP;
3511     }
3512
3513     return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3514                              BDRV_REQ_ZERO_WRITE | flags);
3515 }
3516
3517 /**
3518  * Truncate file to 'offset' bytes (needed only for file protocols)
3519  */
3520 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3521 {
3522     BlockDriver *drv = bs->drv;
3523     int ret;
3524     if (!drv)
3525         return -ENOMEDIUM;
3526     if (!drv->bdrv_truncate)
3527         return -ENOTSUP;
3528     if (bs->read_only)
3529         return -EACCES;
3530
3531     ret = drv->bdrv_truncate(bs, offset);
3532     if (ret == 0) {
3533         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3534         bdrv_dev_resize_cb(bs);
3535     }
3536     return ret;
3537 }
3538
3539 /**
3540  * Length of a allocated file in bytes. Sparse files are counted by actual
3541  * allocated space. Return < 0 if error or unknown.
3542  */
3543 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3544 {
3545     BlockDriver *drv = bs->drv;
3546     if (!drv) {
3547         return -ENOMEDIUM;
3548     }
3549     if (drv->bdrv_get_allocated_file_size) {
3550         return drv->bdrv_get_allocated_file_size(bs);
3551     }
3552     if (bs->file) {
3553         return bdrv_get_allocated_file_size(bs->file);
3554     }
3555     return -ENOTSUP;
3556 }
3557
3558 /**
3559  * Return number of sectors on success, -errno on error.
3560  */
3561 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3562 {
3563     BlockDriver *drv = bs->drv;
3564
3565     if (!drv)
3566         return -ENOMEDIUM;
3567
3568     if (drv->has_variable_length) {
3569         int ret = refresh_total_sectors(bs, bs->total_sectors);
3570         if (ret < 0) {
3571             return ret;
3572         }
3573     }
3574     return bs->total_sectors;
3575 }
3576
3577 /**
3578  * Return length in bytes on success, -errno on error.
3579  * The length is always a multiple of BDRV_SECTOR_SIZE.
3580  */
3581 int64_t bdrv_getlength(BlockDriverState *bs)
3582 {
3583     int64_t ret = bdrv_nb_sectors(bs);
3584
3585     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3586 }
3587
3588 /* return 0 as number of sectors if no device present or error */
3589 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3590 {
3591     int64_t nb_sectors = bdrv_nb_sectors(bs);
3592
3593     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3594 }
3595
3596 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3597                        BlockdevOnError on_write_error)
3598 {
3599     bs->on_read_error = on_read_error;
3600     bs->on_write_error = on_write_error;
3601 }
3602
3603 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3604 {
3605     return is_read ? bs->on_read_error : bs->on_write_error;
3606 }
3607
3608 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3609 {
3610     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3611
3612     switch (on_err) {
3613     case BLOCKDEV_ON_ERROR_ENOSPC:
3614         return (error == ENOSPC) ?
3615                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3616     case BLOCKDEV_ON_ERROR_STOP:
3617         return BLOCK_ERROR_ACTION_STOP;
3618     case BLOCKDEV_ON_ERROR_REPORT:
3619         return BLOCK_ERROR_ACTION_REPORT;
3620     case BLOCKDEV_ON_ERROR_IGNORE:
3621         return BLOCK_ERROR_ACTION_IGNORE;
3622     default:
3623         abort();
3624     }
3625 }
3626
3627 /* This is done by device models because, while the block layer knows
3628  * about the error, it does not know whether an operation comes from
3629  * the device or the block layer (from a job, for example).
3630  */
3631 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3632                        bool is_read, int error)
3633 {
3634     assert(error >= 0);
3635
3636     if (action == BLOCK_ERROR_ACTION_STOP) {
3637         /* First set the iostatus, so that "info block" returns an iostatus
3638          * that matches the events raised so far (an additional error iostatus
3639          * is fine, but not a lost one).
3640          */
3641         bdrv_iostatus_set_err(bs, error);
3642
3643         /* Then raise the request to stop the VM and the event.
3644          * qemu_system_vmstop_request_prepare has two effects.  First,
3645          * it ensures that the STOP event always comes after the
3646          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
3647          * can observe the STOP event and do a "cont" before the STOP
3648          * event is issued, the VM will not stop.  In this case, vm_start()
3649          * also ensures that the STOP/RESUME pair of events is emitted.
3650          */
3651         qemu_system_vmstop_request_prepare();
3652         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3653                                        is_read ? IO_OPERATION_TYPE_READ :
3654                                        IO_OPERATION_TYPE_WRITE,
3655                                        action, &error_abort);
3656         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3657     } else {
3658         qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3659                                        is_read ? IO_OPERATION_TYPE_READ :
3660                                        IO_OPERATION_TYPE_WRITE,
3661                                        action, &error_abort);
3662     }
3663 }
3664
3665 int bdrv_is_read_only(BlockDriverState *bs)
3666 {
3667     return bs->read_only;
3668 }
3669
3670 int bdrv_is_sg(BlockDriverState *bs)
3671 {
3672     return bs->sg;
3673 }
3674
3675 int bdrv_enable_write_cache(BlockDriverState *bs)
3676 {
3677     return bs->enable_write_cache;
3678 }
3679
3680 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3681 {
3682     bs->enable_write_cache = wce;
3683
3684     /* so a reopen() will preserve wce */
3685     if (wce) {
3686         bs->open_flags |= BDRV_O_CACHE_WB;
3687     } else {
3688         bs->open_flags &= ~BDRV_O_CACHE_WB;
3689     }
3690 }
3691
3692 int bdrv_is_encrypted(BlockDriverState *bs)
3693 {
3694     if (bs->backing_hd && bs->backing_hd->encrypted)
3695         return 1;
3696     return bs->encrypted;
3697 }
3698
3699 int bdrv_key_required(BlockDriverState *bs)
3700 {
3701     BlockDriverState *backing_hd = bs->backing_hd;
3702
3703     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3704         return 1;
3705     return (bs->encrypted && !bs->valid_key);
3706 }
3707
3708 int bdrv_set_key(BlockDriverState *bs, const char *key)
3709 {
3710     int ret;
3711     if (bs->backing_hd && bs->backing_hd->encrypted) {
3712         ret = bdrv_set_key(bs->backing_hd, key);
3713         if (ret < 0)
3714             return ret;
3715         if (!bs->encrypted)
3716             return 0;
3717     }
3718     if (!bs->encrypted) {
3719         return -EINVAL;
3720     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3721         return -ENOMEDIUM;
3722     }
3723     ret = bs->drv->bdrv_set_key(bs, key);
3724     if (ret < 0) {
3725         bs->valid_key = 0;
3726     } else if (!bs->valid_key) {
3727         bs->valid_key = 1;
3728         /* call the change callback now, we skipped it on open */
3729         bdrv_dev_change_media_cb(bs, true);
3730     }
3731     return ret;
3732 }
3733
3734 const char *bdrv_get_format_name(BlockDriverState *bs)
3735 {
3736     return bs->drv ? bs->drv->format_name : NULL;
3737 }
3738
3739 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3740                          void *opaque)
3741 {
3742     BlockDriver *drv;
3743     int count = 0;
3744     const char **formats = NULL;
3745
3746     QLIST_FOREACH(drv, &bdrv_drivers, list) {
3747         if (drv->format_name) {
3748             bool found = false;
3749             int i = count;
3750             while (formats && i && !found) {
3751                 found = !strcmp(formats[--i], drv->format_name);
3752             }
3753
3754             if (!found) {
3755                 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3756                 formats[count++] = drv->format_name;
3757                 it(opaque, drv->format_name);
3758             }
3759         }
3760     }
3761     g_free(formats);
3762 }
3763
3764 /* This function is to find block backend bs */
3765 BlockDriverState *bdrv_find(const char *name)
3766 {
3767     BlockDriverState *bs;
3768
3769     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3770         if (!strcmp(name, bs->device_name)) {
3771             return bs;
3772         }
3773     }
3774     return NULL;
3775 }
3776
3777 /* This function is to find a node in the bs graph */
3778 BlockDriverState *bdrv_find_node(const char *node_name)
3779 {
3780     BlockDriverState *bs;
3781
3782     assert(node_name);
3783
3784     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3785         if (!strcmp(node_name, bs->node_name)) {
3786             return bs;
3787         }
3788     }
3789     return NULL;
3790 }
3791
3792 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3793 BlockDeviceInfoList *bdrv_named_nodes_list(void)
3794 {
3795     BlockDeviceInfoList *list, *entry;
3796     BlockDriverState *bs;
3797
3798     list = NULL;
3799     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3800         entry = g_malloc0(sizeof(*entry));
3801         entry->value = bdrv_block_device_info(bs);
3802         entry->next = list;
3803         list = entry;
3804     }
3805
3806     return list;
3807 }
3808
3809 BlockDriverState *bdrv_lookup_bs(const char *device,
3810                                  const char *node_name,
3811                                  Error **errp)
3812 {
3813     BlockDriverState *bs = NULL;
3814
3815     if (device) {
3816         bs = bdrv_find(device);
3817
3818         if (bs) {
3819             return bs;
3820         }
3821     }
3822
3823     if (node_name) {
3824         bs = bdrv_find_node(node_name);
3825
3826         if (bs) {
3827             return bs;
3828         }
3829     }
3830
3831     error_setg(errp, "Cannot find device=%s nor node_name=%s",
3832                      device ? device : "",
3833                      node_name ? node_name : "");
3834     return NULL;
3835 }
3836
3837 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3838  * return false.  If either argument is NULL, return false. */
3839 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3840 {
3841     while (top && top != base) {
3842         top = top->backing_hd;
3843     }
3844
3845     return top != NULL;
3846 }
3847
3848 BlockDriverState *bdrv_next(BlockDriverState *bs)
3849 {
3850     if (!bs) {
3851         return QTAILQ_FIRST(&bdrv_states);
3852     }
3853     return QTAILQ_NEXT(bs, device_list);
3854 }
3855
3856 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
3857 {
3858     BlockDriverState *bs;
3859
3860     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3861         it(opaque, bs);
3862     }
3863 }
3864
3865 const char *bdrv_get_device_name(BlockDriverState *bs)
3866 {
3867     return bs->device_name;
3868 }
3869
3870 int bdrv_get_flags(BlockDriverState *bs)
3871 {
3872     return bs->open_flags;
3873 }
3874
3875 int bdrv_flush_all(void)
3876 {
3877     BlockDriverState *bs;
3878     int result = 0;
3879
3880     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3881         AioContext *aio_context = bdrv_get_aio_context(bs);
3882         int ret;
3883
3884         aio_context_acquire(aio_context);
3885         ret = bdrv_flush(bs);
3886         if (ret < 0 && !result) {
3887             result = ret;
3888         }
3889         aio_context_release(aio_context);
3890     }
3891
3892     return result;
3893 }
3894
3895 int bdrv_has_zero_init_1(BlockDriverState *bs)
3896 {
3897     return 1;
3898 }
3899
3900 int bdrv_has_zero_init(BlockDriverState *bs)
3901 {
3902     assert(bs->drv);
3903
3904     /* If BS is a copy on write image, it is initialized to
3905        the contents of the base image, which may not be zeroes.  */
3906     if (bs->backing_hd) {
3907         return 0;
3908     }
3909     if (bs->drv->bdrv_has_zero_init) {
3910         return bs->drv->bdrv_has_zero_init(bs);
3911     }
3912
3913     /* safe default */
3914     return 0;
3915 }
3916
3917 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3918 {
3919     BlockDriverInfo bdi;
3920
3921     if (bs->backing_hd) {
3922         return false;
3923     }
3924
3925     if (bdrv_get_info(bs, &bdi) == 0) {
3926         return bdi.unallocated_blocks_are_zero;
3927     }
3928
3929     return false;
3930 }
3931
3932 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3933 {
3934     BlockDriverInfo bdi;
3935
3936     if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3937         return false;
3938     }
3939
3940     if (bdrv_get_info(bs, &bdi) == 0) {
3941         return bdi.can_write_zeroes_with_unmap;
3942     }
3943
3944     return false;
3945 }
3946
3947 typedef struct BdrvCoGetBlockStatusData {
3948     BlockDriverState *bs;
3949     BlockDriverState *base;
3950     int64_t sector_num;
3951     int nb_sectors;
3952     int *pnum;
3953     int64_t ret;
3954     bool done;
3955 } BdrvCoGetBlockStatusData;
3956
3957 /*
3958  * Returns true iff the specified sector is present in the disk image. Drivers
3959  * not implementing the functionality are assumed to not support backing files,
3960  * hence all their sectors are reported as allocated.
3961  *
3962  * If 'sector_num' is beyond the end of the disk image the return value is 0
3963  * and 'pnum' is set to 0.
3964  *
3965  * 'pnum' is set to the number of sectors (including and immediately following
3966  * the specified sector) that are known to be in the same
3967  * allocated/unallocated state.
3968  *
3969  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
3970  * beyond the end of the disk image it will be clamped.
3971  */
3972 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3973                                                      int64_t sector_num,
3974                                                      int nb_sectors, int *pnum)
3975 {
3976     int64_t total_sectors;
3977     int64_t n;
3978     int64_t ret, ret2;
3979
3980     total_sectors = bdrv_nb_sectors(bs);
3981     if (total_sectors < 0) {
3982         return total_sectors;
3983     }
3984
3985     if (sector_num >= total_sectors) {
3986         *pnum = 0;
3987         return 0;
3988     }
3989
3990     n = total_sectors - sector_num;
3991     if (n < nb_sectors) {
3992         nb_sectors = n;
3993     }
3994
3995     if (!bs->drv->bdrv_co_get_block_status) {
3996         *pnum = nb_sectors;
3997         ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
3998         if (bs->drv->protocol_name) {
3999             ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
4000         }
4001         return ret;
4002     }
4003
4004     ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
4005     if (ret < 0) {
4006         *pnum = 0;
4007         return ret;
4008     }
4009
4010     if (ret & BDRV_BLOCK_RAW) {
4011         assert(ret & BDRV_BLOCK_OFFSET_VALID);
4012         return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4013                                      *pnum, pnum);
4014     }
4015
4016     if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
4017         ret |= BDRV_BLOCK_ALLOCATED;
4018     }
4019
4020     if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
4021         if (bdrv_unallocated_blocks_are_zero(bs)) {
4022             ret |= BDRV_BLOCK_ZERO;
4023         } else if (bs->backing_hd) {
4024             BlockDriverState *bs2 = bs->backing_hd;
4025             int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
4026             if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
4027                 ret |= BDRV_BLOCK_ZERO;
4028             }
4029         }
4030     }
4031
4032     if (bs->file &&
4033         (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
4034         (ret & BDRV_BLOCK_OFFSET_VALID)) {
4035         ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4036                                         *pnum, pnum);
4037         if (ret2 >= 0) {
4038             /* Ignore errors.  This is just providing extra information, it
4039              * is useful but not necessary.
4040              */
4041             ret |= (ret2 & BDRV_BLOCK_ZERO);
4042         }
4043     }
4044
4045     return ret;
4046 }
4047
4048 /* Coroutine wrapper for bdrv_get_block_status() */
4049 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4050 {
4051     BdrvCoGetBlockStatusData *data = opaque;
4052     BlockDriverState *bs = data->bs;
4053
4054     data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4055                                          data->pnum);
4056     data->done = true;
4057 }
4058
4059 /*
4060  * Synchronous wrapper around bdrv_co_get_block_status().
4061  *
4062  * See bdrv_co_get_block_status() for details.
4063  */
4064 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4065                               int nb_sectors, int *pnum)
4066 {
4067     Coroutine *co;
4068     BdrvCoGetBlockStatusData data = {
4069         .bs = bs,
4070         .sector_num = sector_num,
4071         .nb_sectors = nb_sectors,
4072         .pnum = pnum,
4073         .done = false,
4074     };
4075
4076     if (qemu_in_coroutine()) {
4077         /* Fast-path if already in coroutine context */
4078         bdrv_get_block_status_co_entry(&data);
4079     } else {
4080         AioContext *aio_context = bdrv_get_aio_context(bs);
4081
4082         co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4083         qemu_coroutine_enter(co, &data);
4084         while (!data.done) {
4085             aio_poll(aio_context, true);
4086         }
4087     }
4088     return data.ret;
4089 }
4090
4091 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4092                                    int nb_sectors, int *pnum)
4093 {
4094     int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4095     if (ret < 0) {
4096         return ret;
4097     }
4098     return !!(ret & BDRV_BLOCK_ALLOCATED);
4099 }
4100
4101 /*
4102  * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4103  *
4104  * Return true if the given sector is allocated in any image between
4105  * BASE and TOP (inclusive).  BASE can be NULL to check if the given
4106  * sector is allocated in any image of the chain.  Return false otherwise.
4107  *
4108  * 'pnum' is set to the number of sectors (including and immediately following
4109  *  the specified sector) that are known to be in the same
4110  *  allocated/unallocated state.
4111  *
4112  */
4113 int bdrv_is_allocated_above(BlockDriverState *top,
4114                             BlockDriverState *base,
4115                             int64_t sector_num,
4116                             int nb_sectors, int *pnum)
4117 {
4118     BlockDriverState *intermediate;
4119     int ret, n = nb_sectors;
4120
4121     intermediate = top;
4122     while (intermediate && intermediate != base) {
4123         int pnum_inter;
4124         ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4125                                 &pnum_inter);
4126         if (ret < 0) {
4127             return ret;
4128         } else if (ret) {
4129             *pnum = pnum_inter;
4130             return 1;
4131         }
4132
4133         /*
4134          * [sector_num, nb_sectors] is unallocated on top but intermediate
4135          * might have
4136          *
4137          * [sector_num+x, nr_sectors] allocated.
4138          */
4139         if (n > pnum_inter &&
4140             (intermediate == top ||
4141              sector_num + pnum_inter < intermediate->total_sectors)) {
4142             n = pnum_inter;
4143         }
4144
4145         intermediate = intermediate->backing_hd;
4146     }
4147
4148     *pnum = n;
4149     return 0;
4150 }
4151
4152 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4153 {
4154     if (bs->backing_hd && bs->backing_hd->encrypted)
4155         return bs->backing_file;
4156     else if (bs->encrypted)
4157         return bs->filename;
4158     else
4159         return NULL;
4160 }
4161
4162 void bdrv_get_backing_filename(BlockDriverState *bs,
4163                                char *filename, int filename_size)
4164 {
4165     pstrcpy(filename, filename_size, bs->backing_file);
4166 }
4167
4168 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
4169                           const uint8_t *buf, int nb_sectors)
4170 {
4171     BlockDriver *drv = bs->drv;
4172     if (!drv)
4173         return -ENOMEDIUM;
4174     if (!drv->bdrv_write_compressed)
4175         return -ENOTSUP;
4176     if (bdrv_check_request(bs, sector_num, nb_sectors))
4177         return -EIO;
4178
4179     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4180
4181     return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4182 }
4183
4184 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4185 {
4186     BlockDriver *drv = bs->drv;
4187     if (!drv)
4188         return -ENOMEDIUM;
4189     if (!drv->bdrv_get_info)
4190         return -ENOTSUP;
4191     memset(bdi, 0, sizeof(*bdi));
4192     return drv->bdrv_get_info(bs, bdi);
4193 }
4194
4195 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4196 {
4197     BlockDriver *drv = bs->drv;
4198     if (drv && drv->bdrv_get_specific_info) {
4199         return drv->bdrv_get_specific_info(bs);
4200     }
4201     return NULL;
4202 }
4203
4204 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4205                       int64_t pos, int size)
4206 {
4207     QEMUIOVector qiov;
4208     struct iovec iov = {
4209         .iov_base   = (void *) buf,
4210         .iov_len    = size,
4211     };
4212
4213     qemu_iovec_init_external(&qiov, &iov, 1);
4214     return bdrv_writev_vmstate(bs, &qiov, pos);
4215 }
4216
4217 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4218 {
4219     BlockDriver *drv = bs->drv;
4220
4221     if (!drv) {
4222         return -ENOMEDIUM;
4223     } else if (drv->bdrv_save_vmstate) {
4224         return drv->bdrv_save_vmstate(bs, qiov, pos);
4225     } else if (bs->file) {
4226         return bdrv_writev_vmstate(bs->file, qiov, pos);
4227     }
4228
4229     return -ENOTSUP;
4230 }
4231
4232 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4233                       int64_t pos, int size)
4234 {
4235     BlockDriver *drv = bs->drv;
4236     if (!drv)
4237         return -ENOMEDIUM;
4238     if (drv->bdrv_load_vmstate)
4239         return drv->bdrv_load_vmstate(bs, buf, pos, size);
4240     if (bs->file)
4241         return bdrv_load_vmstate(bs->file, buf, pos, size);
4242     return -ENOTSUP;
4243 }
4244
4245 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4246 {
4247     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4248         return;
4249     }
4250
4251     bs->drv->bdrv_debug_event(bs, event);
4252 }
4253
4254 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4255                           const char *tag)
4256 {
4257     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4258         bs = bs->file;
4259     }
4260
4261     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4262         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4263     }
4264
4265     return -ENOTSUP;
4266 }
4267
4268 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4269 {
4270     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4271         bs = bs->file;
4272     }
4273
4274     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4275         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4276     }
4277
4278     return -ENOTSUP;
4279 }
4280
4281 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4282 {
4283     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4284         bs = bs->file;
4285     }
4286
4287     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4288         return bs->drv->bdrv_debug_resume(bs, tag);
4289     }
4290
4291     return -ENOTSUP;
4292 }
4293
4294 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4295 {
4296     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4297         bs = bs->file;
4298     }
4299
4300     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4301         return bs->drv->bdrv_debug_is_suspended(bs, tag);
4302     }
4303
4304     return false;
4305 }
4306
4307 int bdrv_is_snapshot(BlockDriverState *bs)
4308 {
4309     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4310 }
4311
4312 /* backing_file can either be relative, or absolute, or a protocol.  If it is
4313  * relative, it must be relative to the chain.  So, passing in bs->filename
4314  * from a BDS as backing_file should not be done, as that may be relative to
4315  * the CWD rather than the chain. */
4316 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4317         const char *backing_file)
4318 {
4319     char *filename_full = NULL;
4320     char *backing_file_full = NULL;
4321     char *filename_tmp = NULL;
4322     int is_protocol = 0;
4323     BlockDriverState *curr_bs = NULL;
4324     BlockDriverState *retval = NULL;
4325
4326     if (!bs || !bs->drv || !backing_file) {
4327         return NULL;
4328     }
4329
4330     filename_full     = g_malloc(PATH_MAX);
4331     backing_file_full = g_malloc(PATH_MAX);
4332     filename_tmp      = g_malloc(PATH_MAX);
4333
4334     is_protocol = path_has_protocol(backing_file);
4335
4336     for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4337
4338         /* If either of the filename paths is actually a protocol, then
4339          * compare unmodified paths; otherwise make paths relative */
4340         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4341             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4342                 retval = curr_bs->backing_hd;
4343                 break;
4344             }
4345         } else {
4346             /* If not an absolute filename path, make it relative to the current
4347              * image's filename path */
4348             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4349                          backing_file);
4350
4351             /* We are going to compare absolute pathnames */
4352             if (!realpath(filename_tmp, filename_full)) {
4353                 continue;
4354             }
4355
4356             /* We need to make sure the backing filename we are comparing against
4357              * is relative to the current image filename (or absolute) */
4358             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4359                          curr_bs->backing_file);
4360
4361             if (!realpath(filename_tmp, backing_file_full)) {
4362                 continue;
4363             }
4364
4365             if (strcmp(backing_file_full, filename_full) == 0) {
4366                 retval = curr_bs->backing_hd;
4367                 break;
4368             }
4369         }
4370     }
4371
4372     g_free(filename_full);
4373     g_free(backing_file_full);
4374     g_free(filename_tmp);
4375     return retval;
4376 }
4377
4378 int bdrv_get_backing_file_depth(BlockDriverState *bs)
4379 {
4380     if (!bs->drv) {
4381         return 0;
4382     }
4383
4384     if (!bs->backing_hd) {
4385         return 0;
4386     }
4387
4388     return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4389 }
4390
4391 /**************************************************************/
4392 /* async I/Os */
4393
4394 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4395                                  QEMUIOVector *qiov, int nb_sectors,
4396                                  BlockDriverCompletionFunc *cb, void *opaque)
4397 {
4398     trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4399
4400     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4401                                  cb, opaque, false);
4402 }
4403
4404 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4405                                   QEMUIOVector *qiov, int nb_sectors,
4406                                   BlockDriverCompletionFunc *cb, void *opaque)
4407 {
4408     trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4409
4410     return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4411                                  cb, opaque, true);
4412 }
4413
4414 BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4415         int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4416         BlockDriverCompletionFunc *cb, void *opaque)
4417 {
4418     trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4419
4420     return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4421                                  BDRV_REQ_ZERO_WRITE | flags,
4422                                  cb, opaque, true);
4423 }
4424
4425
4426 typedef struct MultiwriteCB {
4427     int error;
4428     int num_requests;
4429     int num_callbacks;
4430     struct {
4431         BlockDriverCompletionFunc *cb;
4432         void *opaque;
4433         QEMUIOVector *free_qiov;
4434     } callbacks[];
4435 } MultiwriteCB;
4436
4437 static void multiwrite_user_cb(MultiwriteCB *mcb)
4438 {
4439     int i;
4440
4441     for (i = 0; i < mcb->num_callbacks; i++) {
4442         mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4443         if (mcb->callbacks[i].free_qiov) {
4444             qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4445         }
4446         g_free(mcb->callbacks[i].free_qiov);
4447     }
4448 }
4449
4450 static void multiwrite_cb(void *opaque, int ret)
4451 {
4452     MultiwriteCB *mcb = opaque;
4453
4454     trace_multiwrite_cb(mcb, ret);
4455
4456     if (ret < 0 && !mcb->error) {
4457         mcb->error = ret;
4458     }
4459
4460     mcb->num_requests--;
4461     if (mcb->num_requests == 0) {
4462         multiwrite_user_cb(mcb);
4463         g_free(mcb);
4464     }
4465 }
4466
4467 static int multiwrite_req_compare(const void *a, const void *b)
4468 {
4469     const BlockRequest *req1 = a, *req2 = b;
4470
4471     /*
4472      * Note that we can't simply subtract req2->sector from req1->sector
4473      * here as that could overflow the return value.
4474      */
4475     if (req1->sector > req2->sector) {
4476         return 1;
4477     } else if (req1->sector < req2->sector) {
4478         return -1;
4479     } else {
4480         return 0;
4481     }
4482 }
4483
4484 /*
4485  * Takes a bunch of requests and tries to merge them. Returns the number of
4486  * requests that remain after merging.
4487  */
4488 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4489     int num_reqs, MultiwriteCB *mcb)
4490 {
4491     int i, outidx;
4492
4493     // Sort requests by start sector
4494     qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4495
4496     // Check if adjacent requests touch the same clusters. If so, combine them,
4497     // filling up gaps with zero sectors.
4498     outidx = 0;
4499     for (i = 1; i < num_reqs; i++) {
4500         int merge = 0;
4501         int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4502
4503         // Handle exactly sequential writes and overlapping writes.
4504         if (reqs[i].sector <= oldreq_last) {
4505             merge = 1;
4506         }
4507
4508         if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4509             merge = 0;
4510         }
4511
4512         if (merge) {
4513             size_t size;
4514             QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
4515             qemu_iovec_init(qiov,
4516                 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4517
4518             // Add the first request to the merged one. If the requests are
4519             // overlapping, drop the last sectors of the first request.
4520             size = (reqs[i].sector - reqs[outidx].sector) << 9;
4521             qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
4522
4523             // We should need to add any zeros between the two requests
4524             assert (reqs[i].sector <= oldreq_last);
4525
4526             // Add the second request
4527             qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
4528
4529             reqs[outidx].nb_sectors = qiov->size >> 9;
4530             reqs[outidx].qiov = qiov;
4531
4532             mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4533         } else {
4534             outidx++;
4535             reqs[outidx].sector     = reqs[i].sector;
4536             reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4537             reqs[outidx].qiov       = reqs[i].qiov;
4538         }
4539     }
4540
4541     return outidx + 1;
4542 }
4543
4544 /*
4545  * Submit multiple AIO write requests at once.
4546  *
4547  * On success, the function returns 0 and all requests in the reqs array have
4548  * been submitted. In error case this function returns -1, and any of the
4549  * requests may or may not be submitted yet. In particular, this means that the
4550  * callback will be called for some of the requests, for others it won't. The
4551  * caller must check the error field of the BlockRequest to wait for the right
4552  * callbacks (if error != 0, no callback will be called).
4553  *
4554  * The implementation may modify the contents of the reqs array, e.g. to merge
4555  * requests. However, the fields opaque and error are left unmodified as they
4556  * are used to signal failure for a single request to the caller.
4557  */
4558 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4559 {
4560     MultiwriteCB *mcb;
4561     int i;
4562
4563     /* don't submit writes if we don't have a medium */
4564     if (bs->drv == NULL) {
4565         for (i = 0; i < num_reqs; i++) {
4566             reqs[i].error = -ENOMEDIUM;
4567         }
4568         return -1;
4569     }
4570
4571     if (num_reqs == 0) {
4572         return 0;
4573     }
4574
4575     // Create MultiwriteCB structure
4576     mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
4577     mcb->num_requests = 0;
4578     mcb->num_callbacks = num_reqs;
4579
4580     for (i = 0; i < num_reqs; i++) {
4581         mcb->callbacks[i].cb = reqs[i].cb;
4582         mcb->callbacks[i].opaque = reqs[i].opaque;
4583     }
4584
4585     // Check for mergable requests
4586     num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4587
4588     trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4589
4590     /* Run the aio requests. */
4591     mcb->num_requests = num_reqs;
4592     for (i = 0; i < num_reqs; i++) {
4593         bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4594                               reqs[i].nb_sectors, reqs[i].flags,
4595                               multiwrite_cb, mcb,
4596                               true);
4597     }
4598
4599     return 0;
4600 }
4601
4602 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
4603 {
4604     acb->aiocb_info->cancel(acb);
4605 }
4606
4607 /**************************************************************/
4608 /* async block device emulation */
4609
4610 typedef struct BlockDriverAIOCBSync {
4611     BlockDriverAIOCB common;
4612     QEMUBH *bh;
4613     int ret;
4614     /* vector translation state */
4615     QEMUIOVector *qiov;
4616     uint8_t *bounce;
4617     int is_write;
4618 } BlockDriverAIOCBSync;
4619
4620 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4621 {
4622     BlockDriverAIOCBSync *acb =
4623         container_of(blockacb, BlockDriverAIOCBSync, common);
4624     qemu_bh_delete(acb->bh);
4625     acb->bh = NULL;
4626     qemu_aio_release(acb);
4627 }
4628
4629 static const AIOCBInfo bdrv_em_aiocb_info = {
4630     .aiocb_size         = sizeof(BlockDriverAIOCBSync),
4631     .cancel             = bdrv_aio_cancel_em,
4632 };
4633
4634 static void bdrv_aio_bh_cb(void *opaque)
4635 {
4636     BlockDriverAIOCBSync *acb = opaque;
4637
4638     if (!acb->is_write && acb->ret >= 0) {
4639         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4640     }
4641     qemu_vfree(acb->bounce);
4642     acb->common.cb(acb->common.opaque, acb->ret);
4643     qemu_bh_delete(acb->bh);
4644     acb->bh = NULL;
4645     qemu_aio_release(acb);
4646 }
4647
4648 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4649                                             int64_t sector_num,
4650                                             QEMUIOVector *qiov,
4651                                             int nb_sectors,
4652                                             BlockDriverCompletionFunc *cb,
4653                                             void *opaque,
4654                                             int is_write)
4655
4656 {
4657     BlockDriverAIOCBSync *acb;
4658
4659     acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4660     acb->is_write = is_write;
4661     acb->qiov = qiov;
4662     acb->bounce = qemu_try_blockalign(bs, qiov->size);
4663     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4664
4665     if (acb->bounce == NULL) {
4666         acb->ret = -ENOMEM;
4667     } else if (is_write) {
4668         qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4669         acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4670     } else {
4671         acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4672     }
4673
4674     qemu_bh_schedule(acb->bh);
4675
4676     return &acb->common;
4677 }
4678
4679 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4680         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4681         BlockDriverCompletionFunc *cb, void *opaque)
4682 {
4683     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4684 }
4685
4686 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4687         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4688         BlockDriverCompletionFunc *cb, void *opaque)
4689 {
4690     return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4691 }
4692
4693
4694 typedef struct BlockDriverAIOCBCoroutine {
4695     BlockDriverAIOCB common;
4696     BlockRequest req;
4697     bool is_write;
4698     bool *done;
4699     QEMUBH* bh;
4700 } BlockDriverAIOCBCoroutine;
4701
4702 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4703 {
4704     AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
4705     BlockDriverAIOCBCoroutine *acb =
4706         container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4707     bool done = false;
4708
4709     acb->done = &done;
4710     while (!done) {
4711         aio_poll(aio_context, true);
4712     }
4713 }
4714
4715 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4716     .aiocb_size         = sizeof(BlockDriverAIOCBCoroutine),
4717     .cancel             = bdrv_aio_co_cancel_em,
4718 };
4719
4720 static void bdrv_co_em_bh(void *opaque)
4721 {
4722     BlockDriverAIOCBCoroutine *acb = opaque;
4723
4724     acb->common.cb(acb->common.opaque, acb->req.error);
4725
4726     if (acb->done) {
4727         *acb->done = true;
4728     }
4729
4730     qemu_bh_delete(acb->bh);
4731     qemu_aio_release(acb);
4732 }
4733
4734 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4735 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4736 {
4737     BlockDriverAIOCBCoroutine *acb = opaque;
4738     BlockDriverState *bs = acb->common.bs;
4739
4740     if (!acb->is_write) {
4741         acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4742             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4743     } else {
4744         acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4745             acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4746     }
4747
4748     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4749     qemu_bh_schedule(acb->bh);
4750 }
4751
4752 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4753                                                int64_t sector_num,
4754                                                QEMUIOVector *qiov,
4755                                                int nb_sectors,
4756                                                BdrvRequestFlags flags,
4757                                                BlockDriverCompletionFunc *cb,
4758                                                void *opaque,
4759                                                bool is_write)
4760 {
4761     Coroutine *co;
4762     BlockDriverAIOCBCoroutine *acb;
4763
4764     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4765     acb->req.sector = sector_num;
4766     acb->req.nb_sectors = nb_sectors;
4767     acb->req.qiov = qiov;
4768     acb->req.flags = flags;
4769     acb->is_write = is_write;
4770     acb->done = NULL;
4771
4772     co = qemu_coroutine_create(bdrv_co_do_rw);
4773     qemu_coroutine_enter(co, acb);
4774
4775     return &acb->common;
4776 }
4777
4778 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4779 {
4780     BlockDriverAIOCBCoroutine *acb = opaque;
4781     BlockDriverState *bs = acb->common.bs;
4782
4783     acb->req.error = bdrv_co_flush(bs);
4784     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4785     qemu_bh_schedule(acb->bh);
4786 }
4787
4788 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4789         BlockDriverCompletionFunc *cb, void *opaque)
4790 {
4791     trace_bdrv_aio_flush(bs, opaque);
4792
4793     Coroutine *co;
4794     BlockDriverAIOCBCoroutine *acb;
4795
4796     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4797     acb->done = NULL;
4798
4799     co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4800     qemu_coroutine_enter(co, acb);
4801
4802     return &acb->common;
4803 }
4804
4805 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4806 {
4807     BlockDriverAIOCBCoroutine *acb = opaque;
4808     BlockDriverState *bs = acb->common.bs;
4809
4810     acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4811     acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4812     qemu_bh_schedule(acb->bh);
4813 }
4814
4815 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4816         int64_t sector_num, int nb_sectors,
4817         BlockDriverCompletionFunc *cb, void *opaque)
4818 {
4819     Coroutine *co;
4820     BlockDriverAIOCBCoroutine *acb;
4821
4822     trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4823
4824     acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4825     acb->req.sector = sector_num;
4826     acb->req.nb_sectors = nb_sectors;
4827     acb->done = NULL;
4828     co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4829     qemu_coroutine_enter(co, acb);
4830
4831     return &acb->common;
4832 }
4833
4834 void bdrv_init(void)
4835 {
4836     module_call_init(MODULE_INIT_BLOCK);
4837 }
4838
4839 void bdrv_init_with_whitelist(void)
4840 {
4841     use_bdrv_whitelist = 1;
4842     bdrv_init();
4843 }
4844
4845 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4846                    BlockDriverCompletionFunc *cb, void *opaque)
4847 {
4848     BlockDriverAIOCB *acb;
4849
4850     acb = g_slice_alloc(aiocb_info->aiocb_size);
4851     acb->aiocb_info = aiocb_info;
4852     acb->bs = bs;
4853     acb->cb = cb;
4854     acb->opaque = opaque;
4855     return acb;
4856 }
4857
4858 void qemu_aio_release(void *p)
4859 {
4860     BlockDriverAIOCB *acb = p;
4861     g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4862 }
4863
4864 /**************************************************************/
4865 /* Coroutine block device emulation */
4866
4867 typedef struct CoroutineIOCompletion {
4868     Coroutine *coroutine;
4869     int ret;
4870 } CoroutineIOCompletion;
4871
4872 static void bdrv_co_io_em_complete(void *opaque, int ret)
4873 {
4874     CoroutineIOCompletion *co = opaque;
4875
4876     co->ret = ret;
4877     qemu_coroutine_enter(co->coroutine, NULL);
4878 }
4879
4880 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4881                                       int nb_sectors, QEMUIOVector *iov,
4882                                       bool is_write)
4883 {
4884     CoroutineIOCompletion co = {
4885         .coroutine = qemu_coroutine_self(),
4886     };
4887     BlockDriverAIOCB *acb;
4888
4889     if (is_write) {
4890         acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4891                                        bdrv_co_io_em_complete, &co);
4892     } else {
4893         acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4894                                       bdrv_co_io_em_complete, &co);
4895     }
4896
4897     trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4898     if (!acb) {
4899         return -EIO;
4900     }
4901     qemu_coroutine_yield();
4902
4903     return co.ret;
4904 }
4905
4906 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4907                                          int64_t sector_num, int nb_sectors,
4908                                          QEMUIOVector *iov)
4909 {
4910     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4911 }
4912
4913 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4914                                          int64_t sector_num, int nb_sectors,
4915                                          QEMUIOVector *iov)
4916 {
4917     return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4918 }
4919
4920 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4921 {
4922     RwCo *rwco = opaque;
4923
4924     rwco->ret = bdrv_co_flush(rwco->bs);
4925 }
4926
4927 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4928 {
4929     int ret;
4930
4931     if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4932         return 0;
4933     }
4934
4935     /* Write back cached data to the OS even with cache=unsafe */
4936     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
4937     if (bs->drv->bdrv_co_flush_to_os) {
4938         ret = bs->drv->bdrv_co_flush_to_os(bs);
4939         if (ret < 0) {
4940             return ret;
4941         }
4942     }
4943
4944     /* But don't actually force it to the disk with cache=unsafe */
4945     if (bs->open_flags & BDRV_O_NO_FLUSH) {
4946         goto flush_parent;
4947     }
4948
4949     BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
4950     if (bs->drv->bdrv_co_flush_to_disk) {
4951         ret = bs->drv->bdrv_co_flush_to_disk(bs);
4952     } else if (bs->drv->bdrv_aio_flush) {
4953         BlockDriverAIOCB *acb;
4954         CoroutineIOCompletion co = {
4955             .coroutine = qemu_coroutine_self(),
4956         };
4957
4958         acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4959         if (acb == NULL) {
4960             ret = -EIO;
4961         } else {
4962             qemu_coroutine_yield();
4963             ret = co.ret;
4964         }
4965     } else {
4966         /*
4967          * Some block drivers always operate in either writethrough or unsafe
4968          * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4969          * know how the server works (because the behaviour is hardcoded or
4970          * depends on server-side configuration), so we can't ensure that
4971          * everything is safe on disk. Returning an error doesn't work because
4972          * that would break guests even if the server operates in writethrough
4973          * mode.
4974          *
4975          * Let's hope the user knows what he's doing.
4976          */
4977         ret = 0;
4978     }
4979     if (ret < 0) {
4980         return ret;
4981     }
4982
4983     /* Now flush the underlying protocol.  It will also have BDRV_O_NO_FLUSH
4984      * in the case of cache=unsafe, so there are no useless flushes.
4985      */
4986 flush_parent:
4987     return bdrv_co_flush(bs->file);
4988 }
4989
4990 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4991 {
4992     Error *local_err = NULL;
4993     int ret;
4994
4995     if (!bs->drv)  {
4996         return;
4997     }
4998
4999     if (bs->drv->bdrv_invalidate_cache) {
5000         bs->drv->bdrv_invalidate_cache(bs, &local_err);
5001     } else if (bs->file) {
5002         bdrv_invalidate_cache(bs->file, &local_err);
5003     }
5004     if (local_err) {
5005         error_propagate(errp, local_err);
5006         return;
5007     }
5008
5009     ret = refresh_total_sectors(bs, bs->total_sectors);
5010     if (ret < 0) {
5011         error_setg_errno(errp, -ret, "Could not refresh total sector count");
5012         return;
5013     }
5014 }
5015
5016 void bdrv_invalidate_cache_all(Error **errp)
5017 {
5018     BlockDriverState *bs;
5019     Error *local_err = NULL;
5020
5021     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5022         AioContext *aio_context = bdrv_get_aio_context(bs);
5023
5024         aio_context_acquire(aio_context);
5025         bdrv_invalidate_cache(bs, &local_err);
5026         aio_context_release(aio_context);
5027         if (local_err) {
5028             error_propagate(errp, local_err);
5029             return;
5030         }
5031     }
5032 }
5033
5034 void bdrv_clear_incoming_migration_all(void)
5035 {
5036     BlockDriverState *bs;
5037
5038     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5039         AioContext *aio_context = bdrv_get_aio_context(bs);
5040
5041         aio_context_acquire(aio_context);
5042         bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
5043         aio_context_release(aio_context);
5044     }
5045 }
5046
5047 int bdrv_flush(BlockDriverState *bs)
5048 {
5049     Coroutine *co;
5050     RwCo rwco = {
5051         .bs = bs,
5052         .ret = NOT_DONE,
5053     };
5054
5055     if (qemu_in_coroutine()) {
5056         /* Fast-path if already in coroutine context */
5057         bdrv_flush_co_entry(&rwco);
5058     } else {
5059         AioContext *aio_context = bdrv_get_aio_context(bs);
5060
5061         co = qemu_coroutine_create(bdrv_flush_co_entry);
5062         qemu_coroutine_enter(co, &rwco);
5063         while (rwco.ret == NOT_DONE) {
5064             aio_poll(aio_context, true);
5065         }
5066     }
5067
5068     return rwco.ret;
5069 }
5070
5071 typedef struct DiscardCo {
5072     BlockDriverState *bs;
5073     int64_t sector_num;
5074     int nb_sectors;
5075     int ret;
5076 } DiscardCo;
5077 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5078 {
5079     DiscardCo *rwco = opaque;
5080
5081     rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5082 }
5083
5084 /* if no limit is specified in the BlockLimits use a default
5085  * of 32768 512-byte sectors (16 MiB) per request.
5086  */
5087 #define MAX_DISCARD_DEFAULT 32768
5088
5089 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5090                                  int nb_sectors)
5091 {
5092     int max_discard;
5093
5094     if (!bs->drv) {
5095         return -ENOMEDIUM;
5096     } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5097         return -EIO;
5098     } else if (bs->read_only) {
5099         return -EROFS;
5100     }
5101
5102     bdrv_reset_dirty(bs, sector_num, nb_sectors);
5103
5104     /* Do nothing if disabled.  */
5105     if (!(bs->open_flags & BDRV_O_UNMAP)) {
5106         return 0;
5107     }
5108
5109     if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
5110         return 0;
5111     }
5112
5113     max_discard = bs->bl.max_discard ?  bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5114     while (nb_sectors > 0) {
5115         int ret;
5116         int num = nb_sectors;
5117
5118         /* align request */
5119         if (bs->bl.discard_alignment &&
5120             num >= bs->bl.discard_alignment &&
5121             sector_num % bs->bl.discard_alignment) {
5122             if (num > bs->bl.discard_alignment) {
5123                 num = bs->bl.discard_alignment;
5124             }
5125             num -= sector_num % bs->bl.discard_alignment;
5126         }
5127
5128         /* limit request size */
5129         if (num > max_discard) {
5130             num = max_discard;
5131         }
5132
5133         if (bs->drv->bdrv_co_discard) {
5134             ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5135         } else {
5136             BlockDriverAIOCB *acb;
5137             CoroutineIOCompletion co = {
5138                 .coroutine = qemu_coroutine_self(),
5139             };
5140
5141             acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5142                                             bdrv_co_io_em_complete, &co);
5143             if (acb == NULL) {
5144                 return -EIO;
5145             } else {
5146                 qemu_coroutine_yield();
5147                 ret = co.ret;
5148             }
5149         }
5150         if (ret && ret != -ENOTSUP) {
5151             return ret;
5152         }
5153
5154         sector_num += num;
5155         nb_sectors -= num;
5156     }
5157     return 0;
5158 }
5159
5160 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5161 {
5162     Coroutine *co;
5163     DiscardCo rwco = {
5164         .bs = bs,
5165         .sector_num = sector_num,
5166         .nb_sectors = nb_sectors,
5167         .ret = NOT_DONE,
5168     };
5169
5170     if (qemu_in_coroutine()) {
5171         /* Fast-path if already in coroutine context */
5172         bdrv_discard_co_entry(&rwco);
5173     } else {
5174         AioContext *aio_context = bdrv_get_aio_context(bs);
5175
5176         co = qemu_coroutine_create(bdrv_discard_co_entry);
5177         qemu_coroutine_enter(co, &rwco);
5178         while (rwco.ret == NOT_DONE) {
5179             aio_poll(aio_context, true);
5180         }
5181     }
5182
5183     return rwco.ret;
5184 }
5185
5186 /**************************************************************/
5187 /* removable device support */
5188
5189 /**
5190  * Return TRUE if the media is present
5191  */
5192 int bdrv_is_inserted(BlockDriverState *bs)
5193 {
5194     BlockDriver *drv = bs->drv;
5195
5196     if (!drv)
5197         return 0;
5198     if (!drv->bdrv_is_inserted)
5199         return 1;
5200     return drv->bdrv_is_inserted(bs);
5201 }
5202
5203 /**
5204  * Return whether the media changed since the last call to this
5205  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
5206  */
5207 int bdrv_media_changed(BlockDriverState *bs)
5208 {
5209     BlockDriver *drv = bs->drv;
5210
5211     if (drv && drv->bdrv_media_changed) {
5212         return drv->bdrv_media_changed(bs);
5213     }
5214     return -ENOTSUP;
5215 }
5216
5217 /**
5218  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5219  */
5220 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5221 {
5222     BlockDriver *drv = bs->drv;
5223
5224     if (drv && drv->bdrv_eject) {
5225         drv->bdrv_eject(bs, eject_flag);
5226     }
5227
5228     if (bs->device_name[0] != '\0') {
5229         qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
5230                                           eject_flag, &error_abort);
5231     }
5232 }
5233
5234 /**
5235  * Lock or unlock the media (if it is locked, the user won't be able
5236  * to eject it manually).
5237  */
5238 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5239 {
5240     BlockDriver *drv = bs->drv;
5241
5242     trace_bdrv_lock_medium(bs, locked);
5243
5244     if (drv && drv->bdrv_lock_medium) {
5245         drv->bdrv_lock_medium(bs, locked);
5246     }
5247 }
5248
5249 /* needed for generic scsi interface */
5250
5251 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5252 {
5253     BlockDriver *drv = bs->drv;
5254
5255     if (drv && drv->bdrv_ioctl)
5256         return drv->bdrv_ioctl(bs, req, buf);
5257     return -ENOTSUP;
5258 }
5259
5260 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5261         unsigned long int req, void *buf,
5262         BlockDriverCompletionFunc *cb, void *opaque)
5263 {
5264     BlockDriver *drv = bs->drv;
5265
5266     if (drv && drv->bdrv_aio_ioctl)
5267         return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5268     return NULL;
5269 }
5270
5271 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5272 {
5273     bs->guest_block_size = align;
5274 }
5275
5276 void *qemu_blockalign(BlockDriverState *bs, size_t size)
5277 {
5278     return qemu_memalign(bdrv_opt_mem_align(bs), size);
5279 }
5280
5281 void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
5282 {
5283     size_t align = bdrv_opt_mem_align(bs);
5284
5285     /* Ensure that NULL is never returned on success */
5286     assert(align > 0);
5287     if (size == 0) {
5288         size = align;
5289     }
5290
5291     return qemu_try_memalign(align, size);
5292 }
5293
5294 /*
5295  * Check if all memory in this vector is sector aligned.
5296  */
5297 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5298 {
5299     int i;
5300     size_t alignment = bdrv_opt_mem_align(bs);
5301
5302     for (i = 0; i < qiov->niov; i++) {
5303         if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5304             return false;
5305         }
5306         if (qiov->iov[i].iov_len % alignment) {
5307             return false;
5308         }
5309     }
5310
5311     return true;
5312 }
5313
5314 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5315                                           Error **errp)
5316 {
5317     int64_t bitmap_size;
5318     BdrvDirtyBitmap *bitmap;
5319
5320     assert((granularity & (granularity - 1)) == 0);
5321
5322     granularity >>= BDRV_SECTOR_BITS;
5323     assert(granularity);
5324     bitmap_size = bdrv_nb_sectors(bs);
5325     if (bitmap_size < 0) {
5326         error_setg_errno(errp, -bitmap_size, "could not get length of device");
5327         errno = -bitmap_size;
5328         return NULL;
5329     }
5330     bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5331     bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5332     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5333     return bitmap;
5334 }
5335
5336 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5337 {
5338     BdrvDirtyBitmap *bm, *next;
5339     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5340         if (bm == bitmap) {
5341             QLIST_REMOVE(bitmap, list);
5342             hbitmap_free(bitmap->bitmap);
5343             g_free(bitmap);
5344             return;
5345         }
5346     }
5347 }
5348
5349 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5350 {
5351     BdrvDirtyBitmap *bm;
5352     BlockDirtyInfoList *list = NULL;
5353     BlockDirtyInfoList **plist = &list;
5354
5355     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5356         BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5357         BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5358         info->count = bdrv_get_dirty_count(bs, bm);
5359         info->granularity =
5360             ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5361         entry->value = info;
5362         *plist = entry;
5363         plist = &entry->next;
5364     }
5365
5366     return list;
5367 }
5368
5369 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5370 {
5371     if (bitmap) {
5372         return hbitmap_get(bitmap->bitmap, sector);
5373     } else {
5374         return 0;
5375     }
5376 }
5377
5378 void bdrv_dirty_iter_init(BlockDriverState *bs,
5379                           BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5380 {
5381     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5382 }
5383
5384 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5385                     int nr_sectors)
5386 {
5387     BdrvDirtyBitmap *bitmap;
5388     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5389         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5390     }
5391 }
5392
5393 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5394 {
5395     BdrvDirtyBitmap *bitmap;
5396     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5397         hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5398     }
5399 }
5400
5401 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5402 {
5403     return hbitmap_count(bitmap->bitmap);
5404 }
5405
5406 /* Get a reference to bs */
5407 void bdrv_ref(BlockDriverState *bs)
5408 {
5409     bs->refcnt++;
5410 }
5411
5412 /* Release a previously grabbed reference to bs.
5413  * If after releasing, reference count is zero, the BlockDriverState is
5414  * deleted. */
5415 void bdrv_unref(BlockDriverState *bs)
5416 {
5417     if (!bs) {
5418         return;
5419     }
5420     assert(bs->refcnt > 0);
5421     if (--bs->refcnt == 0) {
5422         bdrv_delete(bs);
5423     }
5424 }
5425
5426 struct BdrvOpBlocker {
5427     Error *reason;
5428     QLIST_ENTRY(BdrvOpBlocker) list;
5429 };
5430
5431 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5432 {
5433     BdrvOpBlocker *blocker;
5434     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5435     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5436         blocker = QLIST_FIRST(&bs->op_blockers[op]);
5437         if (errp) {
5438             error_setg(errp, "Device '%s' is busy: %s",
5439                        bs->device_name, error_get_pretty(blocker->reason));
5440         }
5441         return true;
5442     }
5443     return false;
5444 }
5445
5446 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5447 {
5448     BdrvOpBlocker *blocker;
5449     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5450
5451     blocker = g_malloc0(sizeof(BdrvOpBlocker));
5452     blocker->reason = reason;
5453     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5454 }
5455
5456 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5457 {
5458     BdrvOpBlocker *blocker, *next;
5459     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5460     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5461         if (blocker->reason == reason) {
5462             QLIST_REMOVE(blocker, list);
5463             g_free(blocker);
5464         }
5465     }
5466 }
5467
5468 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5469 {
5470     int i;
5471     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5472         bdrv_op_block(bs, i, reason);
5473     }
5474 }
5475
5476 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5477 {
5478     int i;
5479     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5480         bdrv_op_unblock(bs, i, reason);
5481     }
5482 }
5483
5484 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5485 {
5486     int i;
5487
5488     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5489         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5490             return false;
5491         }
5492     }
5493     return true;
5494 }
5495
5496 void bdrv_iostatus_enable(BlockDriverState *bs)
5497 {
5498     bs->iostatus_enabled = true;
5499     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5500 }
5501
5502 /* The I/O status is only enabled if the drive explicitly
5503  * enables it _and_ the VM is configured to stop on errors */
5504 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5505 {
5506     return (bs->iostatus_enabled &&
5507            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5508             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
5509             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5510 }
5511
5512 void bdrv_iostatus_disable(BlockDriverState *bs)
5513 {
5514     bs->iostatus_enabled = false;
5515 }
5516
5517 void bdrv_iostatus_reset(BlockDriverState *bs)
5518 {
5519     if (bdrv_iostatus_is_enabled(bs)) {
5520         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5521         if (bs->job) {
5522             block_job_iostatus_reset(bs->job);
5523         }
5524     }
5525 }
5526
5527 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5528 {
5529     assert(bdrv_iostatus_is_enabled(bs));
5530     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5531         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5532                                          BLOCK_DEVICE_IO_STATUS_FAILED;
5533     }
5534 }
5535
5536 void
5537 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5538         enum BlockAcctType type)
5539 {
5540     assert(type < BDRV_MAX_IOTYPE);
5541
5542     cookie->bytes = bytes;
5543     cookie->start_time_ns = get_clock();
5544     cookie->type = type;
5545 }
5546
5547 void
5548 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5549 {
5550     assert(cookie->type < BDRV_MAX_IOTYPE);
5551
5552     bs->nr_bytes[cookie->type] += cookie->bytes;
5553     bs->nr_ops[cookie->type]++;
5554     bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5555 }
5556
5557 void bdrv_img_create(const char *filename, const char *fmt,
5558                      const char *base_filename, const char *base_fmt,
5559                      char *options, uint64_t img_size, int flags,
5560                      Error **errp, bool quiet)
5561 {
5562     QemuOptsList *create_opts = NULL;
5563     QemuOpts *opts = NULL;
5564     const char *backing_fmt, *backing_file;
5565     int64_t size;
5566     BlockDriver *drv, *proto_drv;
5567     BlockDriver *backing_drv = NULL;
5568     Error *local_err = NULL;
5569     int ret = 0;
5570
5571     /* Find driver and parse its options */
5572     drv = bdrv_find_format(fmt);
5573     if (!drv) {
5574         error_setg(errp, "Unknown file format '%s'", fmt);
5575         return;
5576     }
5577
5578     proto_drv = bdrv_find_protocol(filename, true);
5579     if (!proto_drv) {
5580         error_setg(errp, "Unknown protocol '%s'", filename);
5581         return;
5582     }
5583
5584     create_opts = qemu_opts_append(create_opts, drv->create_opts);
5585     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5586
5587     /* Create parameter list with default values */
5588     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5589     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
5590
5591     /* Parse -o options */
5592     if (options) {
5593         if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5594             error_setg(errp, "Invalid options for file format '%s'", fmt);
5595             goto out;
5596         }
5597     }
5598
5599     if (base_filename) {
5600         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5601             error_setg(errp, "Backing file not supported for file format '%s'",
5602                        fmt);
5603             goto out;
5604         }
5605     }
5606
5607     if (base_fmt) {
5608         if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5609             error_setg(errp, "Backing file format not supported for file "
5610                              "format '%s'", fmt);
5611             goto out;
5612         }
5613     }
5614
5615     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5616     if (backing_file) {
5617         if (!strcmp(filename, backing_file)) {
5618             error_setg(errp, "Error: Trying to create an image with the "
5619                              "same filename as the backing file");
5620             goto out;
5621         }
5622     }
5623
5624     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5625     if (backing_fmt) {
5626         backing_drv = bdrv_find_format(backing_fmt);
5627         if (!backing_drv) {
5628             error_setg(errp, "Unknown backing file format '%s'",
5629                        backing_fmt);
5630             goto out;
5631         }
5632     }
5633
5634     // The size for the image must always be specified, with one exception:
5635     // If we are using a backing file, we can obtain the size from there
5636     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5637     if (size == -1) {
5638         if (backing_file) {
5639             BlockDriverState *bs;
5640             int64_t size;
5641             int back_flags;
5642
5643             /* backing files always opened read-only */
5644             back_flags =
5645                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5646
5647             bs = NULL;
5648             ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5649                             backing_drv, &local_err);
5650             if (ret < 0) {
5651                 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5652                                  backing_file,
5653                                  error_get_pretty(local_err));
5654                 error_free(local_err);
5655                 local_err = NULL;
5656                 goto out;
5657             }
5658             size = bdrv_getlength(bs);
5659             if (size < 0) {
5660                 error_setg_errno(errp, -size, "Could not get size of '%s'",
5661                                  backing_file);
5662                 bdrv_unref(bs);
5663                 goto out;
5664             }
5665
5666             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5667
5668             bdrv_unref(bs);
5669         } else {
5670             error_setg(errp, "Image creation needs a size parameter");
5671             goto out;
5672         }
5673     }
5674
5675     if (!quiet) {
5676         printf("Formatting '%s', fmt=%s ", filename, fmt);
5677         qemu_opts_print(opts);
5678         puts("");
5679     }
5680
5681     ret = bdrv_create(drv, filename, opts, &local_err);
5682
5683     if (ret == -EFBIG) {
5684         /* This is generally a better message than whatever the driver would
5685          * deliver (especially because of the cluster_size_hint), since that
5686          * is most probably not much different from "image too large". */
5687         const char *cluster_size_hint = "";
5688         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5689             cluster_size_hint = " (try using a larger cluster size)";
5690         }
5691         error_setg(errp, "The image size is too large for file format '%s'"
5692                    "%s", fmt, cluster_size_hint);
5693         error_free(local_err);
5694         local_err = NULL;
5695     }
5696
5697 out:
5698     qemu_opts_del(opts);
5699     qemu_opts_free(create_opts);
5700     if (local_err) {
5701         error_propagate(errp, local_err);
5702     }
5703 }
5704
5705 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5706 {
5707     return bs->aio_context;
5708 }
5709
5710 void bdrv_detach_aio_context(BlockDriverState *bs)
5711 {
5712     if (!bs->drv) {
5713         return;
5714     }
5715
5716     if (bs->io_limits_enabled) {
5717         throttle_detach_aio_context(&bs->throttle_state);
5718     }
5719     if (bs->drv->bdrv_detach_aio_context) {
5720         bs->drv->bdrv_detach_aio_context(bs);
5721     }
5722     if (bs->file) {
5723         bdrv_detach_aio_context(bs->file);
5724     }
5725     if (bs->backing_hd) {
5726         bdrv_detach_aio_context(bs->backing_hd);
5727     }
5728
5729     bs->aio_context = NULL;
5730 }
5731
5732 void bdrv_attach_aio_context(BlockDriverState *bs,
5733                              AioContext *new_context)
5734 {
5735     if (!bs->drv) {
5736         return;
5737     }
5738
5739     bs->aio_context = new_context;
5740
5741     if (bs->backing_hd) {
5742         bdrv_attach_aio_context(bs->backing_hd, new_context);
5743     }
5744     if (bs->file) {
5745         bdrv_attach_aio_context(bs->file, new_context);
5746     }
5747     if (bs->drv->bdrv_attach_aio_context) {
5748         bs->drv->bdrv_attach_aio_context(bs, new_context);
5749     }
5750     if (bs->io_limits_enabled) {
5751         throttle_attach_aio_context(&bs->throttle_state, new_context);
5752     }
5753 }
5754
5755 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5756 {
5757     bdrv_drain_all(); /* ensure there are no in-flight requests */
5758
5759     bdrv_detach_aio_context(bs);
5760
5761     /* This function executes in the old AioContext so acquire the new one in
5762      * case it runs in a different thread.
5763      */
5764     aio_context_acquire(new_context);
5765     bdrv_attach_aio_context(bs, new_context);
5766     aio_context_release(new_context);
5767 }
5768
5769 void bdrv_add_before_write_notifier(BlockDriverState *bs,
5770                                     NotifierWithReturn *notifier)
5771 {
5772     notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5773 }
5774
5775 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
5776 {
5777     if (!bs->drv->bdrv_amend_options) {
5778         return -ENOTSUP;
5779     }
5780     return bs->drv->bdrv_amend_options(bs, opts);
5781 }
5782
5783 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5784  * of block filter and by bdrv_is_first_non_filter.
5785  * It is used to test if the given bs is the candidate or recurse more in the
5786  * node graph.
5787  */
5788 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5789                                       BlockDriverState *candidate)
5790 {
5791     /* return false if basic checks fails */
5792     if (!bs || !bs->drv) {
5793         return false;
5794     }
5795
5796     /* the code reached a non block filter driver -> check if the bs is
5797      * the same as the candidate. It's the recursion termination condition.
5798      */
5799     if (!bs->drv->is_filter) {
5800         return bs == candidate;
5801     }
5802     /* Down this path the driver is a block filter driver */
5803
5804     /* If the block filter recursion method is defined use it to recurse down
5805      * the node graph.
5806      */
5807     if (bs->drv->bdrv_recurse_is_first_non_filter) {
5808         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5809     }
5810
5811     /* the driver is a block filter but don't allow to recurse -> return false
5812      */
5813     return false;
5814 }
5815
5816 /* This function checks if the candidate is the first non filter bs down it's
5817  * bs chain. Since we don't have pointers to parents it explore all bs chains
5818  * from the top. Some filters can choose not to pass down the recursion.
5819  */
5820 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5821 {
5822     BlockDriverState *bs;
5823
5824     /* walk down the bs forest recursively */
5825     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5826         bool perm;
5827
5828         /* try to recurse in this top level bs */
5829         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5830
5831         /* candidate is the first non filter */
5832         if (perm) {
5833             return true;
5834         }
5835     }
5836
5837     return false;
5838 }
5839
5840 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5841 {
5842     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5843     if (!to_replace_bs) {
5844         error_setg(errp, "Node name '%s' not found", node_name);
5845         return NULL;
5846     }
5847
5848     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5849         return NULL;
5850     }
5851
5852     /* We don't want arbitrary node of the BDS chain to be replaced only the top
5853      * most non filter in order to prevent data corruption.
5854      * Another benefit is that this tests exclude backing files which are
5855      * blocked by the backing blockers.
5856      */
5857     if (!bdrv_is_first_non_filter(to_replace_bs)) {
5858         error_setg(errp, "Only top most non filter can be replaced");
5859         return NULL;
5860     }
5861
5862     return to_replace_bs;
5863 }
5864
5865 void bdrv_io_plug(BlockDriverState *bs)
5866 {
5867     BlockDriver *drv = bs->drv;
5868     if (drv && drv->bdrv_io_plug) {
5869         drv->bdrv_io_plug(bs);
5870     } else if (bs->file) {
5871         bdrv_io_plug(bs->file);
5872     }
5873 }
5874
5875 void bdrv_io_unplug(BlockDriverState *bs)
5876 {
5877     BlockDriver *drv = bs->drv;
5878     if (drv && drv->bdrv_io_unplug) {
5879         drv->bdrv_io_unplug(bs);
5880     } else if (bs->file) {
5881         bdrv_io_unplug(bs->file);
5882     }
5883 }
5884
5885 void bdrv_flush_io_queue(BlockDriverState *bs)
5886 {
5887     BlockDriver *drv = bs->drv;
5888     if (drv && drv->bdrv_flush_io_queue) {
5889         drv->bdrv_flush_io_queue(bs);
5890     } else if (bs->file) {
5891         bdrv_flush_io_queue(bs->file);
5892     }
5893 }