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