block.c

   1 /*
   2  * QEMU System Emulator block driver
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "config-host.h"
  25 #include "qemu-common.h"
  26 #include "trace.h"
  27 #include "block/block_int.h"
  28 #include "block/blockjob.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/module.h"
  31 #include "qapi/qmp/qerror.h"
  32 #include "qapi/qmp/qjson.h"
  33 #include "sysemu/block-backend.h"
  34 #include "sysemu/sysemu.h"
  35 #include "qemu/notify.h"
  36 #include "block/coroutine.h"
  37 #include "block/qapi.h"
  38 #include "qmp-commands.h"
  39 #include "qemu/timer.h"
  40 #include "qapi-event.h"
  41 #include "block/throttle-groups.h"
  42
  43 #ifdef CONFIG_BSD
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #include <sys/ioctl.h>
  47 #include <sys/queue.h>
  48 #ifndef __DragonFly__
  49 #include <sys/disk.h>
  50 #endif
  51 #endif
  52
  53 #ifdef _WIN32
  54 #include <windows.h>
  55 #endif
  56
  57 /**
  58  * A BdrvDirtyBitmap can be in three possible states:
  59  * (1) successor is NULL and disabled is false: full r/w mode
  60  * (2) successor is NULL and disabled is true: read only mode ("disabled")
  61  * (3) successor is set: frozen mode.
  62  *     A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
  63  *     or enabled. A frozen bitmap can only abdicate() or reclaim().
  64  */
  65 struct BdrvDirtyBitmap {
  66     HBitmap *bitmap;            /* Dirty sector bitmap implementation */
  67     BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
  68     char *name;                 /* Optional non-empty unique ID */
  69     int64_t size;               /* Size of the bitmap (Number of sectors) */
  70     bool disabled;              /* Bitmap is read-only */
  71     QLIST_ENTRY(BdrvDirtyBitmap) list;
  72 };
  73
  74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
  75
  76 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
  77     QTAILQ_HEAD_INITIALIZER(bdrv_states);
  78
  79 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
  80     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
  81
  82 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
  83     QLIST_HEAD_INITIALIZER(bdrv_drivers);
  84
  85 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
  86                              const char *reference, QDict *options, int flags,
  87                              BlockDriverState *parent,
  88                              const BdrvChildRole *child_role, Error **errp);
  89
  90 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
  91 /* If non-zero, use only whitelisted block drivers */
  92 static int use_bdrv_whitelist;
  93
  94 #ifdef _WIN32
  95 static int is_windows_drive_prefix(const char *filename)
  96 {
  97     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
  98              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
  99             filename[1] == ':');
 100 }
 101
 102 int is_windows_drive(const char *filename)
 103 {
 104     if (is_windows_drive_prefix(filename) &&
 105         filename[2] == '\0')
 106         return 1;
 107     if (strstart(filename, "\\\\.\\", NULL) ||
 108         strstart(filename, "//./", NULL))
 109         return 1;
 110     return 0;
 111 }
 112 #endif
 113
 114 size_t bdrv_opt_mem_align(BlockDriverState *bs)
 115 {
 116     if (!bs || !bs->drv) {
 117         /* page size or 4k (hdd sector size) should be on the safe side */
 118         return MAX(4096, getpagesize());
 119     }
 120
 121     return bs->bl.opt_mem_alignment;
 122 }
 123
 124 size_t bdrv_min_mem_align(BlockDriverState *bs)
 125 {
 126     if (!bs || !bs->drv) {
 127         /* page size or 4k (hdd sector size) should be on the safe side */
 128         return MAX(4096, getpagesize());
 129     }
 130
 131     return bs->bl.min_mem_alignment;
 132 }
 133
 134 /* check if the path starts with "<protocol>:" */
 135 int path_has_protocol(const char *path)
 136 {
 137     const char *p;
 138
 139 #ifdef _WIN32
 140     if (is_windows_drive(path) ||
 141         is_windows_drive_prefix(path)) {
 142         return 0;
 143     }
 144     p = path + strcspn(path, ":/\\");
 145 #else
 146     p = path + strcspn(path, ":/");
 147 #endif
 148
 149     return *p == ':';
 150 }
 151
 152 int path_is_absolute(const char *path)
 153 {
 154 #ifdef _WIN32
 155     /* specific case for names like: "\\.\d:" */
 156     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
 157         return 1;
 158     }
 159     return (*path == '/' || *path == '\\');
 160 #else
 161     return (*path == '/');
 162 #endif
 163 }
 164
 165 /* if filename is absolute, just copy it to dest. Otherwise, build a
 166    path to it by considering it is relative to base_path. URL are
 167    supported. */
 168 void path_combine(char *dest, int dest_size,
 169                   const char *base_path,
 170                   const char *filename)
 171 {
 172     const char *p, *p1;
 173     int len;
 174
 175     if (dest_size <= 0)
 176         return;
 177     if (path_is_absolute(filename)) {
 178         pstrcpy(dest, dest_size, filename);
 179     } else {
 180         p = strchr(base_path, ':');
 181         if (p)
 182             p++;
 183         else
 184             p = base_path;
 185         p1 = strrchr(base_path, '/');
 186 #ifdef _WIN32
 187         {
 188             const char *p2;
 189             p2 = strrchr(base_path, '\\');
 190             if (!p1 || p2 > p1)
 191                 p1 = p2;
 192         }
 193 #endif
 194         if (p1)
 195             p1++;
 196         else
 197             p1 = base_path;
 198         if (p1 > p)
 199             p = p1;
 200         len = p - base_path;
 201         if (len > dest_size - 1)
 202             len = dest_size - 1;
 203         memcpy(dest, base_path, len);
 204         dest[len] = '\0';
 205         pstrcat(dest, dest_size, filename);
 206     }
 207 }
 208
 209 void bdrv_get_full_backing_filename_from_filename(const char *backed,
 210                                                   const char *backing,
 211                                                   char *dest, size_t sz,
 212                                                   Error **errp)
 213 {
 214     if (backing[0] == '\0' || path_has_protocol(backing) ||
 215         path_is_absolute(backing))
 216     {
 217         pstrcpy(dest, sz, backing);
 218     } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
 219         error_setg(errp, "Cannot use relative backing file names for '%s'",
 220                    backed);
 221     } else {
 222         path_combine(dest, sz, backed, backing);
 223     }
 224 }
 225
 226 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
 227                                     Error **errp)
 228 {
 229     char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
 230
 231     bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
 232                                                  dest, sz, errp);
 233 }
 234
 235 void bdrv_register(BlockDriver *bdrv)
 236 {
 237     bdrv_setup_io_funcs(bdrv);
 238
 239     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 240 }
 241
 242 BlockDriverState *bdrv_new_root(void)
 243 {
 244     BlockDriverState *bs = bdrv_new();
 245
 246     QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
 247     return bs;
 248 }
 249
 250 BlockDriverState *bdrv_new(void)
 251 {
 252     BlockDriverState *bs;
 253     int i;
 254
 255     bs = g_new0(BlockDriverState, 1);
 256     QLIST_INIT(&bs->dirty_bitmaps);
 257     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
 258         QLIST_INIT(&bs->op_blockers[i]);
 259     }
 260     bdrv_iostatus_disable(bs);
 261     notifier_list_init(&bs->close_notifiers);
 262     notifier_with_return_list_init(&bs->before_write_notifiers);
 263     qemu_co_queue_init(&bs->throttled_reqs[0]);
 264     qemu_co_queue_init(&bs->throttled_reqs[1]);
 265     bs->refcnt = 1;
 266     bs->aio_context = qemu_get_aio_context();
 267
 268     return bs;
 269 }
 270
 271 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
 272 {
 273     notifier_list_add(&bs->close_notifiers, notify);
 274 }
 275
 276 BlockDriver *bdrv_find_format(const char *format_name)
 277 {
 278     BlockDriver *drv1;
 279     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 280         if (!strcmp(drv1->format_name, format_name)) {
 281             return drv1;
 282         }
 283     }
 284     return NULL;
 285 }
 286
 287 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
 288 {
 289     static const char *whitelist_rw[] = {
 290         CONFIG_BDRV_RW_WHITELIST
 291     };
 292     static const char *whitelist_ro[] = {
 293         CONFIG_BDRV_RO_WHITELIST
 294     };
 295     const char **p;
 296
 297     if (!whitelist_rw[0] && !whitelist_ro[0]) {
 298         return 1;               /* no whitelist, anything goes */
 299     }
 300
 301     for (p = whitelist_rw; *p; p++) {
 302         if (!strcmp(drv->format_name, *p)) {
 303             return 1;
 304         }
 305     }
 306     if (read_only) {
 307         for (p = whitelist_ro; *p; p++) {
 308             if (!strcmp(drv->format_name, *p)) {
 309                 return 1;
 310             }
 311         }
 312     }
 313     return 0;
 314 }
 315
 316 typedef struct CreateCo {
 317     BlockDriver *drv;
 318     char *filename;
 319     QemuOpts *opts;
 320     int ret;
 321     Error *err;
 322 } CreateCo;
 323
 324 static void coroutine_fn bdrv_create_co_entry(void *opaque)
 325 {
 326     Error *local_err = NULL;
 327     int ret;
 328
 329     CreateCo *cco = opaque;
 330     assert(cco->drv);
 331
 332     ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
 333     if (local_err) {
 334         error_propagate(&cco->err, local_err);
 335     }
 336     cco->ret = ret;
 337 }
 338
 339 int bdrv_create(BlockDriver *drv, const char* filename,
 340                 QemuOpts *opts, Error **errp)
 341 {
 342     int ret;
 343
 344     Coroutine *co;
 345     CreateCo cco = {
 346         .drv = drv,
 347         .filename = g_strdup(filename),
 348         .opts = opts,
 349         .ret = NOT_DONE,
 350         .err = NULL,
 351     };
 352
 353     if (!drv->bdrv_create) {
 354         error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
 355         ret = -ENOTSUP;
 356         goto out;
 357     }
 358
 359     if (qemu_in_coroutine()) {
 360         /* Fast-path if already in coroutine context */
 361         bdrv_create_co_entry(&cco);
 362     } else {
 363         co = qemu_coroutine_create(bdrv_create_co_entry);
 364         qemu_coroutine_enter(co, &cco);
 365         while (cco.ret == NOT_DONE) {
 366             aio_poll(qemu_get_aio_context(), true);
 367         }
 368     }
 369
 370     ret = cco.ret;
 371     if (ret < 0) {
 372         if (cco.err) {
 373             error_propagate(errp, cco.err);
 374         } else {
 375             error_setg_errno(errp, -ret, "Could not create image");
 376         }
 377     }
 378
 379 out:
 380     g_free(cco.filename);
 381     return ret;
 382 }
 383
 384 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
 385 {
 386     BlockDriver *drv;
 387     Error *local_err = NULL;
 388     int ret;
 389
 390     drv = bdrv_find_protocol(filename, true, errp);
 391     if (drv == NULL) {
 392         return -ENOENT;
 393     }
 394
 395     ret = bdrv_create(drv, filename, opts, &local_err);
 396     if (local_err) {
 397         error_propagate(errp, local_err);
 398     }
 399     return ret;
 400 }
 401
 402 /**
 403  * Try to get @bs's logical and physical block size.
 404  * On success, store them in @bsz struct and return 0.
 405  * On failure return -errno.
 406  * @bs must not be empty.
 407  */
 408 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 409 {
 410     BlockDriver *drv = bs->drv;
 411
 412     if (drv && drv->bdrv_probe_blocksizes) {
 413         return drv->bdrv_probe_blocksizes(bs, bsz);
 414     }
 415
 416     return -ENOTSUP;
 417 }
 418
 419 /**
 420  * Try to get @bs's geometry (cyls, heads, sectors).
 421  * On success, store them in @geo struct and return 0.
 422  * On failure return -errno.
 423  * @bs must not be empty.
 424  */
 425 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 426 {
 427     BlockDriver *drv = bs->drv;
 428
 429     if (drv && drv->bdrv_probe_geometry) {
 430         return drv->bdrv_probe_geometry(bs, geo);
 431     }
 432
 433     return -ENOTSUP;
 434 }
 435
 436 /*
 437  * Create a uniquely-named empty temporary file.
 438  * Return 0 upon success, otherwise a negative errno value.
 439  */
 440 int get_tmp_filename(char *filename, int size)
 441 {
 442 #ifdef _WIN32
 443     char temp_dir[MAX_PATH];
 444     /* GetTempFileName requires that its output buffer (4th param)
 445        have length MAX_PATH or greater.  */
 446     assert(size >= MAX_PATH);
 447     return (GetTempPath(MAX_PATH, temp_dir)
 448             && GetTempFileName(temp_dir, "qem", 0, filename)
 449             ? 0 : -GetLastError());
 450 #else
 451     int fd;
 452     const char *tmpdir;
 453     tmpdir = getenv("TMPDIR");
 454     if (!tmpdir) {
 455         tmpdir = "/var/tmp";
 456     }
 457     if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
 458         return -EOVERFLOW;
 459     }
 460     fd = mkstemp(filename);
 461     if (fd < 0) {
 462         return -errno;
 463     }
 464     if (close(fd) != 0) {
 465         unlink(filename);
 466         return -errno;
 467     }
 468     return 0;
 469 #endif
 470 }
 471
 472 /*
 473  * Detect host devices. By convention, /dev/cdrom[N] is always
 474  * recognized as a host CDROM.
 475  */
 476 static BlockDriver *find_hdev_driver(const char *filename)
 477 {
 478     int score_max = 0, score;
 479     BlockDriver *drv = NULL, *d;
 480
 481     QLIST_FOREACH(d, &bdrv_drivers, list) {
 482         if (d->bdrv_probe_device) {
 483             score = d->bdrv_probe_device(filename);
 484             if (score > score_max) {
 485                 score_max = score;
 486                 drv = d;
 487             }
 488         }
 489     }
 490
 491     return drv;
 492 }
 493
 494 BlockDriver *bdrv_find_protocol(const char *filename,
 495                                 bool allow_protocol_prefix,
 496                                 Error **errp)
 497 {
 498     BlockDriver *drv1;
 499     char protocol[128];
 500     int len;
 501     const char *p;
 502
 503     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 504
 505     /*
 506      * XXX(hch): we really should not let host device detection
 507      * override an explicit protocol specification, but moving this
 508      * later breaks access to device names with colons in them.
 509      * Thanks to the brain-dead persistent naming schemes on udev-
 510      * based Linux systems those actually are quite common.
 511      */
 512     drv1 = find_hdev_driver(filename);
 513     if (drv1) {
 514         return drv1;
 515     }
 516
 517     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
 518         return &bdrv_file;
 519     }
 520
 521     p = strchr(filename, ':');
 522     assert(p != NULL);
 523     len = p - filename;
 524     if (len > sizeof(protocol) - 1)
 525         len = sizeof(protocol) - 1;
 526     memcpy(protocol, filename, len);
 527     protocol[len] = '\0';
 528     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 529         if (drv1->protocol_name &&
 530             !strcmp(drv1->protocol_name, protocol)) {
 531             return drv1;
 532         }
 533     }
 534
 535     error_setg(errp, "Unknown protocol '%s'", protocol);
 536     return NULL;
 537 }
 538
 539 /*
 540  * Guess image format by probing its contents.
 541  * This is not a good idea when your image is raw (CVE-2008-2004), but
 542  * we do it anyway for backward compatibility.
 543  *
 544  * @buf         contains the image's first @buf_size bytes.
 545  * @buf_size    is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
 546  *              but can be smaller if the image file is smaller)
 547  * @filename    is its filename.
 548  *
 549  * For all block drivers, call the bdrv_probe() method to get its
 550  * probing score.
 551  * Return the first block driver with the highest probing score.
 552  */
 553 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
 554                             const char *filename)
 555 {
 556     int score_max = 0, score;
 557     BlockDriver *drv = NULL, *d;
 558
 559     QLIST_FOREACH(d, &bdrv_drivers, list) {
 560         if (d->bdrv_probe) {
 561             score = d->bdrv_probe(buf, buf_size, filename);
 562             if (score > score_max) {
 563                 score_max = score;
 564                 drv = d;
 565             }
 566         }
 567     }
 568
 569     return drv;
 570 }
 571
 572 static int find_image_format(BlockDriverState *bs, const char *filename,
 573                              BlockDriver **pdrv, Error **errp)
 574 {
 575     BlockDriver *drv;
 576     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
 577     int ret = 0;
 578
 579     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
 580     if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
 581         *pdrv = &bdrv_raw;
 582         return ret;
 583     }
 584
 585     ret = bdrv_pread(bs, 0, buf, sizeof(buf));
 586     if (ret < 0) {
 587         error_setg_errno(errp, -ret, "Could not read image for determining its "
 588                          "format");
 589         *pdrv = NULL;
 590         return ret;
 591     }
 592
 593     drv = bdrv_probe_all(buf, ret, filename);
 594     if (!drv) {
 595         error_setg(errp, "Could not determine image format: No compatible "
 596                    "driver found");
 597         ret = -ENOENT;
 598     }
 599     *pdrv = drv;
 600     return ret;
 601 }
 602
 603 /**
 604  * Set the current 'total_sectors' value
 605  * Return 0 on success, -errno on error.
 606  */
 607 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 608 {
 609     BlockDriver *drv = bs->drv;
 610
 611     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
 612     if (bdrv_is_sg(bs))
 613         return 0;
 614
 615     /* query actual device if possible, otherwise just trust the hint */
 616     if (drv->bdrv_getlength) {
 617         int64_t length = drv->bdrv_getlength(bs);
 618         if (length < 0) {
 619             return length;
 620         }
 621         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
 622     }
 623
 624     bs->total_sectors = hint;
 625     return 0;
 626 }
 627
 628 /**
 629  * Set open flags for a given discard mode
 630  *
 631  * Return 0 on success, -1 if the discard mode was invalid.
 632  */
 633 int bdrv_parse_discard_flags(const char *mode, int *flags)
 634 {
 635     *flags &= ~BDRV_O_UNMAP;
 636
 637     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
 638         /* do nothing */
 639     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
 640         *flags |= BDRV_O_UNMAP;
 641     } else {
 642         return -1;
 643     }
 644
 645     return 0;
 646 }
 647
 648 /**
 649  * Set open flags for a given cache mode
 650  *
 651  * Return 0 on success, -1 if the cache mode was invalid.
 652  */
 653 int bdrv_parse_cache_flags(const char *mode, int *flags)
 654 {
 655     *flags &= ~BDRV_O_CACHE_MASK;
 656
 657     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
 658         *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
 659     } else if (!strcmp(mode, "directsync")) {
 660         *flags |= BDRV_O_NOCACHE;
 661     } else if (!strcmp(mode, "writeback")) {
 662         *flags |= BDRV_O_CACHE_WB;
 663     } else if (!strcmp(mode, "unsafe")) {
 664         *flags |= BDRV_O_CACHE_WB;
 665         *flags |= BDRV_O_NO_FLUSH;
 666     } else if (!strcmp(mode, "writethrough")) {
 667         /* this is the default */
 668     } else {
 669         return -1;
 670     }
 671
 672     return 0;
 673 }
 674
 675 /*
 676  * Returns the flags that a temporary snapshot should get, based on the
 677  * originally requested flags (the originally requested image will have flags
 678  * like a backing file)
 679  */
 680 static int bdrv_temp_snapshot_flags(int flags)
 681 {
 682     return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
 683 }
 684
 685 /*
 686  * Returns the flags that bs->file should get if a protocol driver is expected,
 687  * based on the given flags for the parent BDS
 688  */
 689 static int bdrv_inherited_flags(int flags)
 690 {
 691     /* Enable protocol handling, disable format probing for bs->file */
 692     flags |= BDRV_O_PROTOCOL;
 693
 694     /* Our block drivers take care to send flushes and respect unmap policy,
 695      * so we can enable both unconditionally on lower layers. */
 696     flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
 697
 698     /* Clear flags that only apply to the top layer */
 699     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
 700
 701     return flags;
 702 }
 703
 704 const BdrvChildRole child_file = {
 705     .inherit_flags = bdrv_inherited_flags,
 706 };
 707
 708 /*
 709  * Returns the flags that bs->file should get if the use of formats (and not
 710  * only protocols) is permitted for it, based on the given flags for the parent
 711  * BDS
 712  */
 713 static int bdrv_inherited_fmt_flags(int parent_flags)
 714 {
 715     int flags = child_file.inherit_flags(parent_flags);
 716     return flags & ~BDRV_O_PROTOCOL;
 717 }
 718
 719 const BdrvChildRole child_format = {
 720     .inherit_flags = bdrv_inherited_fmt_flags,
 721 };
 722
 723 /*
 724  * Returns the flags that bs->backing should get, based on the given flags
 725  * for the parent BDS
 726  */
 727 static int bdrv_backing_flags(int flags)
 728 {
 729     /* backing files always opened read-only */
 730     flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
 731
 732     /* snapshot=on is handled on the top layer */
 733     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
 734
 735     return flags;
 736 }
 737
 738 static const BdrvChildRole child_backing = {
 739     .inherit_flags = bdrv_backing_flags,
 740 };
 741
 742 static int bdrv_open_flags(BlockDriverState *bs, int flags)
 743 {
 744     int open_flags = flags | BDRV_O_CACHE_WB;
 745
 746     /*
 747      * Clear flags that are internal to the block layer before opening the
 748      * image.
 749      */
 750     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
 751
 752     /*
 753      * Snapshots should be writable.
 754      */
 755     if (flags & BDRV_O_TEMPORARY) {
 756         open_flags |= BDRV_O_RDWR;
 757     }
 758
 759     return open_flags;
 760 }
 761
 762 static void bdrv_assign_node_name(BlockDriverState *bs,
 763                                   const char *node_name,
 764                                   Error **errp)
 765 {
 766     if (!node_name) {
 767         return;
 768     }
 769
 770     /* Check for empty string or invalid characters */
 771     if (!id_wellformed(node_name)) {
 772         error_setg(errp, "Invalid node name");
 773         return;
 774     }
 775
 776     /* takes care of avoiding namespaces collisions */
 777     if (blk_by_name(node_name)) {
 778         error_setg(errp, "node-name=%s is conflicting with a device id",
 779                    node_name);
 780         return;
 781     }
 782
 783     /* takes care of avoiding duplicates node names */
 784     if (bdrv_find_node(node_name)) {
 785         error_setg(errp, "Duplicate node name");
 786         return;
 787     }
 788
 789     /* copy node name into the bs and insert it into the graph list */
 790     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
 791     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
 792 }
 793
 794 static QemuOptsList bdrv_runtime_opts = {
 795     .name = "bdrv_common",
 796     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
 797     .desc = {
 798         {
 799             .name = "node-name",
 800             .type = QEMU_OPT_STRING,
 801             .help = "Node name of the block device node",
 802         },
 803         { /* end of list */ }
 804     },
 805 };
 806
 807 /*
 808  * Common part for opening disk images and files
 809  *
 810  * Removes all processed options from *options.
 811  */
 812 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
 813     QDict *options, int flags, BlockDriver *drv, Error **errp)
 814 {
 815     int ret, open_flags;
 816     const char *filename;
 817     const char *node_name = NULL;
 818     QemuOpts *opts;
 819     Error *local_err = NULL;
 820
 821     assert(drv != NULL);
 822     assert(bs->file == NULL);
 823     assert(options != NULL && bs->options != options);
 824
 825     if (file != NULL) {
 826         filename = file->bs->filename;
 827     } else {
 828         filename = qdict_get_try_str(options, "filename");
 829     }
 830
 831     if (drv->bdrv_needs_filename && !filename) {
 832         error_setg(errp, "The '%s' block driver requires a file name",
 833                    drv->format_name);
 834         return -EINVAL;
 835     }
 836
 837     trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
 838
 839     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
 840     qemu_opts_absorb_qdict(opts, options, &local_err);
 841     if (local_err) {
 842         error_propagate(errp, local_err);
 843         ret = -EINVAL;
 844         goto fail_opts;
 845     }
 846
 847     node_name = qemu_opt_get(opts, "node-name");
 848     bdrv_assign_node_name(bs, node_name, &local_err);
 849     if (local_err) {
 850         error_propagate(errp, local_err);
 851         ret = -EINVAL;
 852         goto fail_opts;
 853     }
 854
 855     bs->guest_block_size = 512;
 856     bs->request_alignment = 512;
 857     bs->zero_beyond_eof = true;
 858     open_flags = bdrv_open_flags(bs, flags);
 859     bs->read_only = !(open_flags & BDRV_O_RDWR);
 860
 861     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
 862         error_setg(errp,
 863                    !bs->read_only && bdrv_is_whitelisted(drv, true)
 864                         ? "Driver '%s' can only be used for read-only devices"
 865                         : "Driver '%s' is not whitelisted",
 866                    drv->format_name);
 867         ret = -ENOTSUP;
 868         goto fail_opts;
 869     }
 870
 871     assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
 872     if (flags & BDRV_O_COPY_ON_READ) {
 873         if (!bs->read_only) {
 874             bdrv_enable_copy_on_read(bs);
 875         } else {
 876             error_setg(errp, "Can't use copy-on-read on read-only device");
 877             ret = -EINVAL;
 878             goto fail_opts;
 879         }
 880     }
 881
 882     if (filename != NULL) {
 883         pstrcpy(bs->filename, sizeof(bs->filename), filename);
 884     } else {
 885         bs->filename[0] = '\0';
 886     }
 887     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
 888
 889     bs->drv = drv;
 890     bs->opaque = g_malloc0(drv->instance_size);
 891
 892     bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
 893
 894     /* Open the image, either directly or using a protocol */
 895     if (drv->bdrv_file_open) {
 896         assert(file == NULL);
 897         assert(!drv->bdrv_needs_filename || filename != NULL);
 898         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
 899     } else {
 900         if (file == NULL) {
 901             error_setg(errp, "Can't use '%s' as a block driver for the "
 902                        "protocol level", drv->format_name);
 903             ret = -EINVAL;
 904             goto free_and_fail;
 905         }
 906         bs->file = file;
 907         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
 908     }
 909
 910     if (ret < 0) {
 911         if (local_err) {
 912             error_propagate(errp, local_err);
 913         } else if (bs->filename[0]) {
 914             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
 915         } else {
 916             error_setg_errno(errp, -ret, "Could not open image");
 917         }
 918         goto free_and_fail;
 919     }
 920
 921     if (bs->encrypted) {
 922         error_report("Encrypted images are deprecated");
 923         error_printf("Support for them will be removed in a future release.\n"
 924                      "You can use 'qemu-img convert' to convert your image"
 925                      " to an unencrypted one.\n");
 926     }
 927
 928     ret = refresh_total_sectors(bs, bs->total_sectors);
 929     if (ret < 0) {
 930         error_setg_errno(errp, -ret, "Could not refresh total sector count");
 931         goto free_and_fail;
 932     }
 933
 934     bdrv_refresh_limits(bs, &local_err);
 935     if (local_err) {
 936         error_propagate(errp, local_err);
 937         ret = -EINVAL;
 938         goto free_and_fail;
 939     }
 940
 941     assert(bdrv_opt_mem_align(bs) != 0);
 942     assert(bdrv_min_mem_align(bs) != 0);
 943     assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
 944
 945     qemu_opts_del(opts);
 946     return 0;
 947
 948 free_and_fail:
 949     bs->file = NULL;
 950     g_free(bs->opaque);
 951     bs->opaque = NULL;
 952     bs->drv = NULL;
 953 fail_opts:
 954     qemu_opts_del(opts);
 955     return ret;
 956 }
 957
 958 static QDict *parse_json_filename(const char *filename, Error **errp)
 959 {
 960     QObject *options_obj;
 961     QDict *options;
 962     int ret;
 963
 964     ret = strstart(filename, "json:", &filename);
 965     assert(ret);
 966
 967     options_obj = qobject_from_json(filename);
 968     if (!options_obj) {
 969         error_setg(errp, "Could not parse the JSON options");
 970         return NULL;
 971     }
 972
 973     if (qobject_type(options_obj) != QTYPE_QDICT) {
 974         qobject_decref(options_obj);
 975         error_setg(errp, "Invalid JSON object given");
 976         return NULL;
 977     }
 978
 979     options = qobject_to_qdict(options_obj);
 980     qdict_flatten(options);
 981
 982     return options;
 983 }
 984
 985 /*
 986  * Fills in default options for opening images and converts the legacy
 987  * filename/flags pair to option QDict entries.
 988  * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
 989  * block driver has been specified explicitly.
 990  */
 991 static int bdrv_fill_options(QDict **options, const char **pfilename,
 992                              int *flags, Error **errp)
 993 {
 994     const char *filename = *pfilename;
 995     const char *drvname;
 996     bool protocol = *flags & BDRV_O_PROTOCOL;
 997     bool parse_filename = false;
 998     BlockDriver *drv = NULL;
 999     Error *local_err = NULL;
1000
1001     /* Parse json: pseudo-protocol */
1002     if (filename && g_str_has_prefix(filename, "json:")) {
1003         QDict *json_options = parse_json_filename(filename, &local_err);
1004         if (local_err) {
1005             error_propagate(errp, local_err);
1006             return -EINVAL;
1007         }
1008
1009         /* Options given in the filename have lower priority than options
1010          * specified directly */
1011         qdict_join(*options, json_options, false);
1012         QDECREF(json_options);
1013         *pfilename = filename = NULL;
1014     }
1015
1016     drvname = qdict_get_try_str(*options, "driver");
1017     if (drvname) {
1018         drv = bdrv_find_format(drvname);
1019         if (!drv) {
1020             error_setg(errp, "Unknown driver '%s'", drvname);
1021             return -ENOENT;
1022         }
1023         /* If the user has explicitly specified the driver, this choice should
1024          * override the BDRV_O_PROTOCOL flag */
1025         protocol = drv->bdrv_file_open;
1026     }
1027
1028     if (protocol) {
1029         *flags |= BDRV_O_PROTOCOL;
1030     } else {
1031         *flags &= ~BDRV_O_PROTOCOL;
1032     }
1033
1034     /* Fetch the file name from the options QDict if necessary */
1035     if (protocol && filename) {
1036         if (!qdict_haskey(*options, "filename")) {
1037             qdict_put(*options, "filename", qstring_from_str(filename));
1038             parse_filename = true;
1039         } else {
1040             error_setg(errp, "Can't specify 'file' and 'filename' options at "
1041                              "the same time");
1042             return -EINVAL;
1043         }
1044     }
1045
1046     /* Find the right block driver */
1047     filename = qdict_get_try_str(*options, "filename");
1048
1049     if (!drvname && protocol) {
1050         if (filename) {
1051             drv = bdrv_find_protocol(filename, parse_filename, errp);
1052             if (!drv) {
1053                 return -EINVAL;
1054             }
1055
1056             drvname = drv->format_name;
1057             qdict_put(*options, "driver", qstring_from_str(drvname));
1058         } else {
1059             error_setg(errp, "Must specify either driver or file");
1060             return -EINVAL;
1061         }
1062     }
1063
1064     assert(drv || !protocol);
1065
1066     /* Driver-specific filename parsing */
1067     if (drv && drv->bdrv_parse_filename && parse_filename) {
1068         drv->bdrv_parse_filename(filename, *options, &local_err);
1069         if (local_err) {
1070             error_propagate(errp, local_err);
1071             return -EINVAL;
1072         }
1073
1074         if (!drv->bdrv_needs_filename) {
1075             qdict_del(*options, "filename");
1076         }
1077     }
1078
1079     return 0;
1080 }
1081
1082 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1083                                     BlockDriverState *child_bs,
1084                                     const BdrvChildRole *child_role)
1085 {
1086     BdrvChild *child = g_new(BdrvChild, 1);
1087     *child = (BdrvChild) {
1088         .bs     = child_bs,
1089         .role   = child_role,
1090     };
1091
1092     QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1093
1094     return child;
1095 }
1096
1097 static void bdrv_detach_child(BdrvChild *child)
1098 {
1099     QLIST_REMOVE(child, next);
1100     g_free(child);
1101 }
1102
1103 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1104 {
1105     BlockDriverState *child_bs = child->bs;
1106
1107     if (child->bs->inherits_from == parent) {
1108         child->bs->inherits_from = NULL;
1109     }
1110
1111     bdrv_detach_child(child);
1112     bdrv_unref(child_bs);
1113 }
1114
1115 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1116 {
1117
1118     if (bs->backing) {
1119         assert(bs->backing_blocker);
1120         bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1121         bdrv_detach_child(bs->backing);
1122     } else if (backing_hd) {
1123         error_setg(&bs->backing_blocker,
1124                    "node is used as backing hd of '%s'",
1125                    bdrv_get_device_or_node_name(bs));
1126     }
1127
1128     if (!backing_hd) {
1129         error_free(bs->backing_blocker);
1130         bs->backing_blocker = NULL;
1131         bs->backing = NULL;
1132         goto out;
1133     }
1134     bs->backing = bdrv_attach_child(bs, backing_hd, &child_backing);
1135     bs->open_flags &= ~BDRV_O_NO_BACKING;
1136     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1137     pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1138             backing_hd->drv ? backing_hd->drv->format_name : "");
1139
1140     bdrv_op_block_all(backing_hd, bs->backing_blocker);
1141     /* Otherwise we won't be able to commit due to check in bdrv_commit */
1142     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1143                     bs->backing_blocker);
1144 out:
1145     bdrv_refresh_limits(bs, NULL);
1146 }
1147
1148 /*
1149  * Opens the backing file for a BlockDriverState if not yet open
1150  *
1151  * options is a QDict of options to pass to the block drivers, or NULL for an
1152  * empty set of options. The reference to the QDict is transferred to this
1153  * function (even on failure), so if the caller intends to reuse the dictionary,
1154  * it needs to use QINCREF() before calling bdrv_file_open.
1155  */
1156 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1157 {
1158     char *backing_filename = g_malloc0(PATH_MAX);
1159     int ret = 0;
1160     BlockDriverState *backing_hd;
1161     Error *local_err = NULL;
1162
1163     if (bs->backing != NULL) {
1164         QDECREF(options);
1165         goto free_exit;
1166     }
1167
1168     /* NULL means an empty set of options */
1169     if (options == NULL) {
1170         options = qdict_new();
1171     }
1172
1173     bs->open_flags &= ~BDRV_O_NO_BACKING;
1174     if (qdict_haskey(options, "file.filename")) {
1175         backing_filename[0] = '\0';
1176     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1177         QDECREF(options);
1178         goto free_exit;
1179     } else {
1180         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1181                                        &local_err);
1182         if (local_err) {
1183             ret = -EINVAL;
1184             error_propagate(errp, local_err);
1185             QDECREF(options);
1186             goto free_exit;
1187         }
1188     }
1189
1190     if (!bs->drv || !bs->drv->supports_backing) {
1191         ret = -EINVAL;
1192         error_setg(errp, "Driver doesn't support backing files");
1193         QDECREF(options);
1194         goto free_exit;
1195     }
1196
1197     backing_hd = bdrv_new();
1198
1199     if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1200         qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1201     }
1202
1203     assert(bs->backing == NULL);
1204     ret = bdrv_open_inherit(&backing_hd,
1205                             *backing_filename ? backing_filename : NULL,
1206                             NULL, options, 0, bs, &child_backing, &local_err);
1207     if (ret < 0) {
1208         bdrv_unref(backing_hd);
1209         backing_hd = NULL;
1210         bs->open_flags |= BDRV_O_NO_BACKING;
1211         error_setg(errp, "Could not open backing file: %s",
1212                    error_get_pretty(local_err));
1213         error_free(local_err);
1214         goto free_exit;
1215     }
1216
1217     bdrv_set_backing_hd(bs, backing_hd);
1218
1219 free_exit:
1220     g_free(backing_filename);
1221     return ret;
1222 }
1223
1224 /*
1225  * Opens a disk image whose options are given as BlockdevRef in another block
1226  * device's options.
1227  *
1228  * If allow_none is true, no image will be opened if filename is false and no
1229  * BlockdevRef is given. NULL will be returned, but errp remains unset.
1230  *
1231  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1232  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1233  * itself, all options starting with "${bdref_key}." are considered part of the
1234  * BlockdevRef.
1235  *
1236  * The BlockdevRef will be removed from the options QDict.
1237  */
1238 BdrvChild *bdrv_open_child(const char *filename,
1239                            QDict *options, const char *bdref_key,
1240                            BlockDriverState* parent,
1241                            const BdrvChildRole *child_role,
1242                            bool allow_none, Error **errp)
1243 {
1244     BdrvChild *c = NULL;
1245     BlockDriverState *bs;
1246     QDict *image_options;
1247     int ret;
1248     char *bdref_key_dot;
1249     const char *reference;
1250
1251     assert(child_role != NULL);
1252
1253     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1254     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1255     g_free(bdref_key_dot);
1256
1257     reference = qdict_get_try_str(options, bdref_key);
1258     if (!filename && !reference && !qdict_size(image_options)) {
1259         if (!allow_none) {
1260             error_setg(errp, "A block device must be specified for \"%s\"",
1261                        bdref_key);
1262         }
1263         QDECREF(image_options);
1264         goto done;
1265     }
1266
1267     bs = NULL;
1268     ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1269                             parent, child_role, errp);
1270     if (ret < 0) {
1271         goto done;
1272     }
1273
1274     c = bdrv_attach_child(parent, bs, child_role);
1275
1276 done:
1277     qdict_del(options, bdref_key);
1278     return c;
1279 }
1280
1281 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1282 {
1283     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1284     char *tmp_filename = g_malloc0(PATH_MAX + 1);
1285     int64_t total_size;
1286     QemuOpts *opts = NULL;
1287     QDict *snapshot_options;
1288     BlockDriverState *bs_snapshot;
1289     Error *local_err = NULL;
1290     int ret;
1291
1292     /* if snapshot, we create a temporary backing file and open it
1293        instead of opening 'filename' directly */
1294
1295     /* Get the required size from the image */
1296     total_size = bdrv_getlength(bs);
1297     if (total_size < 0) {
1298         ret = total_size;
1299         error_setg_errno(errp, -total_size, "Could not get image size");
1300         goto out;
1301     }
1302
1303     /* Create the temporary image */
1304     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1305     if (ret < 0) {
1306         error_setg_errno(errp, -ret, "Could not get temporary filename");
1307         goto out;
1308     }
1309
1310     opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1311                             &error_abort);
1312     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1313     ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1314     qemu_opts_del(opts);
1315     if (ret < 0) {
1316         error_setg_errno(errp, -ret, "Could not create temporary overlay "
1317                          "'%s': %s", tmp_filename,
1318                          error_get_pretty(local_err));
1319         error_free(local_err);
1320         goto out;
1321     }
1322
1323     /* Prepare a new options QDict for the temporary file */
1324     snapshot_options = qdict_new();
1325     qdict_put(snapshot_options, "file.driver",
1326               qstring_from_str("file"));
1327     qdict_put(snapshot_options, "file.filename",
1328               qstring_from_str(tmp_filename));
1329     qdict_put(snapshot_options, "driver",
1330               qstring_from_str("qcow2"));
1331
1332     bs_snapshot = bdrv_new();
1333
1334     ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1335                     flags, &local_err);
1336     if (ret < 0) {
1337         error_propagate(errp, local_err);
1338         goto out;
1339     }
1340
1341     bdrv_append(bs_snapshot, bs);
1342
1343 out:
1344     g_free(tmp_filename);
1345     return ret;
1346 }
1347
1348 /*
1349  * Opens a disk image (raw, qcow2, vmdk, ...)
1350  *
1351  * options is a QDict of options to pass to the block drivers, or NULL for an
1352  * empty set of options. The reference to the QDict belongs to the block layer
1353  * after the call (even on failure), so if the caller intends to reuse the
1354  * dictionary, it needs to use QINCREF() before calling bdrv_open.
1355  *
1356  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1357  * If it is not NULL, the referenced BDS will be reused.
1358  *
1359  * The reference parameter may be used to specify an existing block device which
1360  * should be opened. If specified, neither options nor a filename may be given,
1361  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1362  */
1363 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1364                              const char *reference, QDict *options, int flags,
1365                              BlockDriverState *parent,
1366                              const BdrvChildRole *child_role, Error **errp)
1367 {
1368     int ret;
1369     BdrvChild *file = NULL;
1370     BlockDriverState *bs;
1371     BlockDriver *drv = NULL;
1372     const char *drvname;
1373     Error *local_err = NULL;
1374     int snapshot_flags = 0;
1375
1376     assert(pbs);
1377     assert(!child_role || !flags);
1378     assert(!child_role == !parent);
1379
1380     if (reference) {
1381         bool options_non_empty = options ? qdict_size(options) : false;
1382         QDECREF(options);
1383
1384         if (*pbs) {
1385             error_setg(errp, "Cannot reuse an existing BDS when referencing "
1386                        "another block device");
1387             return -EINVAL;
1388         }
1389
1390         if (filename || options_non_empty) {
1391             error_setg(errp, "Cannot reference an existing block device with "
1392                        "additional options or a new filename");
1393             return -EINVAL;
1394         }
1395
1396         bs = bdrv_lookup_bs(reference, reference, errp);
1397         if (!bs) {
1398             return -ENODEV;
1399         }
1400         bdrv_ref(bs);
1401         *pbs = bs;
1402         return 0;
1403     }
1404
1405     if (*pbs) {
1406         bs = *pbs;
1407     } else {
1408         bs = bdrv_new();
1409     }
1410
1411     /* NULL means an empty set of options */
1412     if (options == NULL) {
1413         options = qdict_new();
1414     }
1415
1416     if (child_role) {
1417         bs->inherits_from = parent;
1418         flags = child_role->inherit_flags(parent->open_flags);
1419     }
1420
1421     ret = bdrv_fill_options(&options, &filename, &flags, &local_err);
1422     if (local_err) {
1423         goto fail;
1424     }
1425
1426     /* Find the right image format driver */
1427     drvname = qdict_get_try_str(options, "driver");
1428     if (drvname) {
1429         drv = bdrv_find_format(drvname);
1430         qdict_del(options, "driver");
1431         if (!drv) {
1432             error_setg(errp, "Unknown driver: '%s'", drvname);
1433             ret = -EINVAL;
1434             goto fail;
1435         }
1436     }
1437
1438     assert(drvname || !(flags & BDRV_O_PROTOCOL));
1439
1440     bs->open_flags = flags;
1441     bs->options = options;
1442     options = qdict_clone_shallow(options);
1443
1444     /* Open image file without format layer */
1445     if ((flags & BDRV_O_PROTOCOL) == 0) {
1446         if (flags & BDRV_O_RDWR) {
1447             flags |= BDRV_O_ALLOW_RDWR;
1448         }
1449         if (flags & BDRV_O_SNAPSHOT) {
1450             snapshot_flags = bdrv_temp_snapshot_flags(flags);
1451             flags = bdrv_backing_flags(flags);
1452         }
1453
1454         bs->open_flags = flags;
1455
1456         file = bdrv_open_child(filename, options, "file", bs,
1457                                &child_file, true, &local_err);
1458         if (local_err) {
1459             ret = -EINVAL;
1460             goto fail;
1461         }
1462     }
1463
1464     /* Image format probing */
1465     bs->probed = !drv;
1466     if (!drv && file) {
1467         ret = find_image_format(file->bs, filename, &drv, &local_err);
1468         if (ret < 0) {
1469             goto fail;
1470         }
1471     } else if (!drv) {
1472         error_setg(errp, "Must specify either driver or file");
1473         ret = -EINVAL;
1474         goto fail;
1475     }
1476
1477     /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1478     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1479     /* file must be NULL if a protocol BDS is about to be created
1480      * (the inverse results in an error message from bdrv_open_common()) */
1481     assert(!(flags & BDRV_O_PROTOCOL) || !file);
1482
1483     /* Open the image */
1484     ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1485     if (ret < 0) {
1486         goto fail;
1487     }
1488
1489     if (file && (bs->file != file)) {
1490         bdrv_unref_child(bs, file);
1491         file = NULL;
1492     }
1493
1494     /* If there is a backing file, use it */
1495     if ((flags & BDRV_O_NO_BACKING) == 0) {
1496         QDict *backing_options;
1497
1498         qdict_extract_subqdict(options, &backing_options, "backing.");
1499         ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1500         if (ret < 0) {
1501             goto close_and_fail;
1502         }
1503     }
1504
1505     bdrv_refresh_filename(bs);
1506
1507     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1508      * temporary snapshot afterwards. */
1509     if (snapshot_flags) {
1510         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1511         if (local_err) {
1512             goto close_and_fail;
1513         }
1514     }
1515
1516     /* Check if any unknown options were used */
1517     if (options && (qdict_size(options) != 0)) {
1518         const QDictEntry *entry = qdict_first(options);
1519         if (flags & BDRV_O_PROTOCOL) {
1520             error_setg(errp, "Block protocol '%s' doesn't support the option "
1521                        "'%s'", drv->format_name, entry->key);
1522         } else {
1523             error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1524                        "support the option '%s'", drv->format_name,
1525                        bdrv_get_device_name(bs), entry->key);
1526         }
1527
1528         ret = -EINVAL;
1529         goto close_and_fail;
1530     }
1531
1532     if (!bdrv_key_required(bs)) {
1533         if (bs->blk) {
1534             blk_dev_change_media_cb(bs->blk, true);
1535         }
1536     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1537                && !runstate_check(RUN_STATE_INMIGRATE)
1538                && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1539         error_setg(errp,
1540                    "Guest must be stopped for opening of encrypted image");
1541         ret = -EBUSY;
1542         goto close_and_fail;
1543     }
1544
1545     QDECREF(options);
1546     *pbs = bs;
1547     return 0;
1548
1549 fail:
1550     if (file != NULL) {
1551         bdrv_unref_child(bs, file);
1552     }
1553     QDECREF(bs->options);
1554     QDECREF(options);
1555     bs->options = NULL;
1556     if (!*pbs) {
1557         /* If *pbs is NULL, a new BDS has been created in this function and
1558            needs to be freed now. Otherwise, it does not need to be closed,
1559            since it has not really been opened yet. */
1560         bdrv_unref(bs);
1561     }
1562     if (local_err) {
1563         error_propagate(errp, local_err);
1564     }
1565     return ret;
1566
1567 close_and_fail:
1568     /* See fail path, but now the BDS has to be always closed */
1569     if (*pbs) {
1570         bdrv_close(bs);
1571     } else {
1572         bdrv_unref(bs);
1573     }
1574     QDECREF(options);
1575     if (local_err) {
1576         error_propagate(errp, local_err);
1577     }
1578     return ret;
1579 }
1580
1581 int bdrv_open(BlockDriverState **pbs, const char *filename,
1582               const char *reference, QDict *options, int flags, Error **errp)
1583 {
1584     return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1585                              NULL, errp);
1586 }
1587
1588 typedef struct BlockReopenQueueEntry {
1589      bool prepared;
1590      BDRVReopenState state;
1591      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1592 } BlockReopenQueueEntry;
1593
1594 /*
1595  * Adds a BlockDriverState to a simple queue for an atomic, transactional
1596  * reopen of multiple devices.
1597  *
1598  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1599  * already performed, or alternatively may be NULL a new BlockReopenQueue will
1600  * be created and initialized. This newly created BlockReopenQueue should be
1601  * passed back in for subsequent calls that are intended to be of the same
1602  * atomic 'set'.
1603  *
1604  * bs is the BlockDriverState to add to the reopen queue.
1605  *
1606  * options contains the changed options for the associated bs
1607  * (the BlockReopenQueue takes ownership)
1608  *
1609  * flags contains the open flags for the associated bs
1610  *
1611  * returns a pointer to bs_queue, which is either the newly allocated
1612  * bs_queue, or the existing bs_queue being used.
1613  *
1614  */
1615 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1616                                     BlockDriverState *bs,
1617                                     QDict *options, int flags)
1618 {
1619     assert(bs != NULL);
1620
1621     BlockReopenQueueEntry *bs_entry;
1622     BdrvChild *child;
1623     QDict *old_options;
1624
1625     if (bs_queue == NULL) {
1626         bs_queue = g_new0(BlockReopenQueue, 1);
1627         QSIMPLEQ_INIT(bs_queue);
1628     }
1629
1630     if (!options) {
1631         options = qdict_new();
1632     }
1633
1634     old_options = qdict_clone_shallow(bs->options);
1635     qdict_join(options, old_options, false);
1636     QDECREF(old_options);
1637
1638     /* bdrv_open() masks this flag out */
1639     flags &= ~BDRV_O_PROTOCOL;
1640
1641     QLIST_FOREACH(child, &bs->children, next) {
1642         int child_flags;
1643
1644         if (child->bs->inherits_from != bs) {
1645             continue;
1646         }
1647
1648         child_flags = child->role->inherit_flags(flags);
1649         /* TODO Pass down child flags (backing.*, extents.*, ...) */
1650         bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
1651     }
1652
1653     bs_entry = g_new0(BlockReopenQueueEntry, 1);
1654     QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1655
1656     bs_entry->state.bs = bs;
1657     bs_entry->state.options = options;
1658     bs_entry->state.flags = flags;
1659
1660     return bs_queue;
1661 }
1662
1663 /*
1664  * Reopen multiple BlockDriverStates atomically & transactionally.
1665  *
1666  * The queue passed in (bs_queue) must have been built up previous
1667  * via bdrv_reopen_queue().
1668  *
1669  * Reopens all BDS specified in the queue, with the appropriate
1670  * flags.  All devices are prepared for reopen, and failure of any
1671  * device will cause all device changes to be abandonded, and intermediate
1672  * data cleaned up.
1673  *
1674  * If all devices prepare successfully, then the changes are committed
1675  * to all devices.
1676  *
1677  */
1678 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1679 {
1680     int ret = -1;
1681     BlockReopenQueueEntry *bs_entry, *next;
1682     Error *local_err = NULL;
1683
1684     assert(bs_queue != NULL);
1685
1686     bdrv_drain_all();
1687
1688     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1689         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1690             error_propagate(errp, local_err);
1691             goto cleanup;
1692         }
1693         bs_entry->prepared = true;
1694     }
1695
1696     /* If we reach this point, we have success and just need to apply the
1697      * changes
1698      */
1699     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1700         bdrv_reopen_commit(&bs_entry->state);
1701     }
1702
1703     ret = 0;
1704
1705 cleanup:
1706     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1707         if (ret && bs_entry->prepared) {
1708             bdrv_reopen_abort(&bs_entry->state);
1709         }
1710         QDECREF(bs_entry->state.options);
1711         g_free(bs_entry);
1712     }
1713     g_free(bs_queue);
1714     return ret;
1715 }
1716
1717
1718 /* Reopen a single BlockDriverState with the specified flags. */
1719 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1720 {
1721     int ret = -1;
1722     Error *local_err = NULL;
1723     BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1724
1725     ret = bdrv_reopen_multiple(queue, &local_err);
1726     if (local_err != NULL) {
1727         error_propagate(errp, local_err);
1728     }
1729     return ret;
1730 }
1731
1732
1733 /*
1734  * Prepares a BlockDriverState for reopen. All changes are staged in the
1735  * 'opaque' field of the BDRVReopenState, which is used and allocated by
1736  * the block driver layer .bdrv_reopen_prepare()
1737  *
1738  * bs is the BlockDriverState to reopen
1739  * flags are the new open flags
1740  * queue is the reopen queue
1741  *
1742  * Returns 0 on success, non-zero on error.  On error errp will be set
1743  * as well.
1744  *
1745  * On failure, bdrv_reopen_abort() will be called to clean up any data.
1746  * It is the responsibility of the caller to then call the abort() or
1747  * commit() for any other BDS that have been left in a prepare() state
1748  *
1749  */
1750 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1751                         Error **errp)
1752 {
1753     int ret = -1;
1754     Error *local_err = NULL;
1755     BlockDriver *drv;
1756
1757     assert(reopen_state != NULL);
1758     assert(reopen_state->bs->drv != NULL);
1759     drv = reopen_state->bs->drv;
1760
1761     /* if we are to stay read-only, do not allow permission change
1762      * to r/w */
1763     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1764         reopen_state->flags & BDRV_O_RDWR) {
1765         error_setg(errp, "Node '%s' is read only",
1766                    bdrv_get_device_or_node_name(reopen_state->bs));
1767         goto error;
1768     }
1769
1770
1771     ret = bdrv_flush(reopen_state->bs);
1772     if (ret) {
1773         error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1774                   strerror(-ret));
1775         goto error;
1776     }
1777
1778     if (drv->bdrv_reopen_prepare) {
1779         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1780         if (ret) {
1781             if (local_err != NULL) {
1782                 error_propagate(errp, local_err);
1783             } else {
1784                 error_setg(errp, "failed while preparing to reopen image '%s'",
1785                            reopen_state->bs->filename);
1786             }
1787             goto error;
1788         }
1789     } else {
1790         /* It is currently mandatory to have a bdrv_reopen_prepare()
1791          * handler for each supported drv. */
1792         error_setg(errp, "Block format '%s' used by node '%s' "
1793                    "does not support reopening files", drv->format_name,
1794                    bdrv_get_device_or_node_name(reopen_state->bs));
1795         ret = -1;
1796         goto error;
1797     }
1798
1799     /* Options that are not handled are only okay if they are unchanged
1800      * compared to the old state. It is expected that some options are only
1801      * used for the initial open, but not reopen (e.g. filename) */
1802     if (qdict_size(reopen_state->options)) {
1803         const QDictEntry *entry = qdict_first(reopen_state->options);
1804
1805         do {
1806             QString *new_obj = qobject_to_qstring(entry->value);
1807             const char *new = qstring_get_str(new_obj);
1808             const char *old = qdict_get_try_str(reopen_state->bs->options,
1809                                                 entry->key);
1810
1811             if (!old || strcmp(new, old)) {
1812                 error_setg(errp, "Cannot change the option '%s'", entry->key);
1813                 ret = -EINVAL;
1814                 goto error;
1815             }
1816         } while ((entry = qdict_next(reopen_state->options, entry)));
1817     }
1818
1819     ret = 0;
1820
1821 error:
1822     return ret;
1823 }
1824
1825 /*
1826  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1827  * makes them final by swapping the staging BlockDriverState contents into
1828  * the active BlockDriverState contents.
1829  */
1830 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1831 {
1832     BlockDriver *drv;
1833
1834     assert(reopen_state != NULL);
1835     drv = reopen_state->bs->drv;
1836     assert(drv != NULL);
1837
1838     /* If there are any driver level actions to take */
1839     if (drv->bdrv_reopen_commit) {
1840         drv->bdrv_reopen_commit(reopen_state);
1841     }
1842
1843     /* set BDS specific flags now */
1844     reopen_state->bs->open_flags         = reopen_state->flags;
1845     reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1846                                               BDRV_O_CACHE_WB);
1847     reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1848
1849     bdrv_refresh_limits(reopen_state->bs, NULL);
1850 }
1851
1852 /*
1853  * Abort the reopen, and delete and free the staged changes in
1854  * reopen_state
1855  */
1856 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1857 {
1858     BlockDriver *drv;
1859
1860     assert(reopen_state != NULL);
1861     drv = reopen_state->bs->drv;
1862     assert(drv != NULL);
1863
1864     if (drv->bdrv_reopen_abort) {
1865         drv->bdrv_reopen_abort(reopen_state);
1866     }
1867 }
1868
1869
1870 void bdrv_close(BlockDriverState *bs)
1871 {
1872     BdrvAioNotifier *ban, *ban_next;
1873
1874     if (bs->job) {
1875         block_job_cancel_sync(bs->job);
1876     }
1877
1878     /* Disable I/O limits and drain all pending throttled requests */
1879     if (bs->io_limits_enabled) {
1880         bdrv_io_limits_disable(bs);
1881     }
1882
1883     bdrv_drain(bs); /* complete I/O */
1884     bdrv_flush(bs);
1885     bdrv_drain(bs); /* in case flush left pending I/O */
1886     notifier_list_notify(&bs->close_notifiers, bs);
1887
1888     if (bs->drv) {
1889         BdrvChild *child, *next;
1890
1891         bs->drv->bdrv_close(bs);
1892         bs->drv = NULL;
1893
1894         if (bs->backing) {
1895             BlockDriverState *backing_hd = bs->backing->bs;
1896             bdrv_set_backing_hd(bs, NULL);
1897             bdrv_unref(backing_hd);
1898         }
1899
1900         if (bs->file != NULL) {
1901             bdrv_unref_child(bs, bs->file);
1902             bs->file = NULL;
1903         }
1904
1905         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1906             /* TODO Remove bdrv_unref() from drivers' close function and use
1907              * bdrv_unref_child() here */
1908             if (child->bs->inherits_from == bs) {
1909                 child->bs->inherits_from = NULL;
1910             }
1911             bdrv_detach_child(child);
1912         }
1913
1914         g_free(bs->opaque);
1915         bs->opaque = NULL;
1916         bs->copy_on_read = 0;
1917         bs->backing_file[0] = '\0';
1918         bs->backing_format[0] = '\0';
1919         bs->total_sectors = 0;
1920         bs->encrypted = 0;
1921         bs->valid_key = 0;
1922         bs->sg = 0;
1923         bs->zero_beyond_eof = false;
1924         QDECREF(bs->options);
1925         bs->options = NULL;
1926         QDECREF(bs->full_open_options);
1927         bs->full_open_options = NULL;
1928     }
1929
1930     if (bs->blk) {
1931         blk_dev_change_media_cb(bs->blk, false);
1932     }
1933
1934     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1935         g_free(ban);
1936     }
1937     QLIST_INIT(&bs->aio_notifiers);
1938 }
1939
1940 void bdrv_close_all(void)
1941 {
1942     BlockDriverState *bs;
1943
1944     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1945         AioContext *aio_context = bdrv_get_aio_context(bs);
1946
1947         aio_context_acquire(aio_context);
1948         bdrv_close(bs);
1949         aio_context_release(aio_context);
1950     }
1951 }
1952
1953 /* make a BlockDriverState anonymous by removing from bdrv_state and
1954  * graph_bdrv_state list.
1955    Also, NULL terminate the device_name to prevent double remove */
1956 void bdrv_make_anon(BlockDriverState *bs)
1957 {
1958     /*
1959      * Take care to remove bs from bdrv_states only when it's actually
1960      * in it.  Note that bs->device_list.tqe_prev is initially null,
1961      * and gets set to non-null by QTAILQ_INSERT_TAIL().  Establish
1962      * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1963      * resetting it to null on remove.
1964      */
1965     if (bs->device_list.tqe_prev) {
1966         QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1967         bs->device_list.tqe_prev = NULL;
1968     }
1969     if (bs->node_name[0] != '\0') {
1970         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1971     }
1972     bs->node_name[0] = '\0';
1973 }
1974
1975 static void bdrv_rebind(BlockDriverState *bs)
1976 {
1977     if (bs->drv && bs->drv->bdrv_rebind) {
1978         bs->drv->bdrv_rebind(bs);
1979     }
1980 }
1981
1982 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1983                                      BlockDriverState *bs_src)
1984 {
1985     /* move some fields that need to stay attached to the device */
1986
1987     /* dev info */
1988     bs_dest->guest_block_size   = bs_src->guest_block_size;
1989     bs_dest->copy_on_read       = bs_src->copy_on_read;
1990
1991     bs_dest->enable_write_cache = bs_src->enable_write_cache;
1992
1993     /* i/o throttled req */
1994     bs_dest->throttle_state     = bs_src->throttle_state,
1995     bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1996     bs_dest->pending_reqs[0]    = bs_src->pending_reqs[0];
1997     bs_dest->pending_reqs[1]    = bs_src->pending_reqs[1];
1998     bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
1999     bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
2000     memcpy(&bs_dest->round_robin,
2001            &bs_src->round_robin,
2002            sizeof(bs_dest->round_robin));
2003     memcpy(&bs_dest->throttle_timers,
2004            &bs_src->throttle_timers,
2005            sizeof(ThrottleTimers));
2006
2007     /* r/w error */
2008     bs_dest->on_read_error      = bs_src->on_read_error;
2009     bs_dest->on_write_error     = bs_src->on_write_error;
2010
2011     /* i/o status */
2012     bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
2013     bs_dest->iostatus           = bs_src->iostatus;
2014
2015     /* dirty bitmap */
2016     bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
2017
2018     /* reference count */
2019     bs_dest->refcnt             = bs_src->refcnt;
2020
2021     /* job */
2022     bs_dest->job                = bs_src->job;
2023
2024     /* keep the same entry in bdrv_states */
2025     bs_dest->device_list = bs_src->device_list;
2026     bs_dest->blk = bs_src->blk;
2027
2028     memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2029            sizeof(bs_dest->op_blockers));
2030 }
2031
2032 /*
2033  * Swap bs contents for two image chains while they are live,
2034  * while keeping required fields on the BlockDriverState that is
2035  * actually attached to a device.
2036  *
2037  * This will modify the BlockDriverState fields, and swap contents
2038  * between bs_new and bs_old. Both bs_new and bs_old are modified.
2039  *
2040  * bs_new must not be attached to a BlockBackend.
2041  *
2042  * This function does not create any image files.
2043  */
2044 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2045 {
2046     BlockDriverState tmp;
2047     BdrvChild *child;
2048
2049     bdrv_drain(bs_new);
2050     bdrv_drain(bs_old);
2051
2052     /* The code needs to swap the node_name but simply swapping node_list won't
2053      * work so first remove the nodes from the graph list, do the swap then
2054      * insert them back if needed.
2055      */
2056     if (bs_new->node_name[0] != '\0') {
2057         QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2058     }
2059     if (bs_old->node_name[0] != '\0') {
2060         QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2061     }
2062
2063     /* If the BlockDriverState is part of a throttling group acquire
2064      * its lock since we're going to mess with the protected fields.
2065      * Otherwise there's no need to worry since no one else can touch
2066      * them. */
2067     if (bs_old->throttle_state) {
2068         throttle_group_lock(bs_old);
2069     }
2070
2071     /* bs_new must be unattached and shouldn't have anything fancy enabled */
2072     assert(!bs_new->blk);
2073     assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2074     assert(bs_new->job == NULL);
2075     assert(bs_new->io_limits_enabled == false);
2076     assert(bs_new->throttle_state == NULL);
2077     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2078
2079     tmp = *bs_new;
2080     *bs_new = *bs_old;
2081     *bs_old = tmp;
2082
2083     /* there are some fields that should not be swapped, move them back */
2084     bdrv_move_feature_fields(&tmp, bs_old);
2085     bdrv_move_feature_fields(bs_old, bs_new);
2086     bdrv_move_feature_fields(bs_new, &tmp);
2087
2088     /* bs_new must remain unattached */
2089     assert(!bs_new->blk);
2090
2091     /* Check a few fields that should remain attached to the device */
2092     assert(bs_new->job == NULL);
2093     assert(bs_new->io_limits_enabled == false);
2094     assert(bs_new->throttle_state == NULL);
2095     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2096
2097     /* Release the ThrottleGroup lock */
2098     if (bs_old->throttle_state) {
2099         throttle_group_unlock(bs_old);
2100     }
2101
2102     /* insert the nodes back into the graph node list if needed */
2103     if (bs_new->node_name[0] != '\0') {
2104         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2105     }
2106     if (bs_old->node_name[0] != '\0') {
2107         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2108     }
2109
2110     /*
2111      * Update lh_first.le_prev for non-empty lists.
2112      *
2113      * The head of the op blocker list doesn't change because it is moved back
2114      * in bdrv_move_feature_fields().
2115      */
2116     assert(QLIST_EMPTY(&bs_old->tracked_requests));
2117     assert(QLIST_EMPTY(&bs_new->tracked_requests));
2118
2119     QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2120     QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2121
2122     /* Update references in bs->opaque and children */
2123     QLIST_FOREACH(child, &bs_old->children, next) {
2124         if (child->bs->inherits_from == bs_new) {
2125             child->bs->inherits_from = bs_old;
2126         }
2127     }
2128     QLIST_FOREACH(child, &bs_new->children, next) {
2129         if (child->bs->inherits_from == bs_old) {
2130             child->bs->inherits_from = bs_new;
2131         }
2132     }
2133
2134     bdrv_rebind(bs_new);
2135     bdrv_rebind(bs_old);
2136 }
2137
2138 /*
2139  * Add new bs contents at the top of an image chain while the chain is
2140  * live, while keeping required fields on the top layer.
2141  *
2142  * This will modify the BlockDriverState fields, and swap contents
2143  * between bs_new and bs_top. Both bs_new and bs_top are modified.
2144  *
2145  * bs_new must not be attached to a BlockBackend.
2146  *
2147  * This function does not create any image files.
2148  */
2149 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2150 {
2151     bdrv_swap(bs_new, bs_top);
2152
2153     /* The contents of 'tmp' will become bs_top, as we are
2154      * swapping bs_new and bs_top contents. */
2155     bdrv_set_backing_hd(bs_top, bs_new);
2156 }
2157
2158 static void bdrv_delete(BlockDriverState *bs)
2159 {
2160     assert(!bs->job);
2161     assert(bdrv_op_blocker_is_empty(bs));
2162     assert(!bs->refcnt);
2163     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2164
2165     bdrv_close(bs);
2166
2167     /* remove from list, if necessary */
2168     bdrv_make_anon(bs);
2169
2170     g_free(bs);
2171 }
2172
2173 /*
2174  * Run consistency checks on an image
2175  *
2176  * Returns 0 if the check could be completed (it doesn't mean that the image is
2177  * free of errors) or -errno when an internal error occurred. The results of the
2178  * check are stored in res.
2179  */
2180 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2181 {
2182     if (bs->drv == NULL) {
2183         return -ENOMEDIUM;
2184     }
2185     if (bs->drv->bdrv_check == NULL) {
2186         return -ENOTSUP;
2187     }
2188
2189     memset(res, 0, sizeof(*res));
2190     return bs->drv->bdrv_check(bs, res, fix);
2191 }
2192
2193 #define COMMIT_BUF_SECTORS 2048
2194
2195 /* commit COW file into the raw image */
2196 int bdrv_commit(BlockDriverState *bs)
2197 {
2198     BlockDriver *drv = bs->drv;
2199     int64_t sector, total_sectors, length, backing_length;
2200     int n, ro, open_flags;
2201     int ret = 0;
2202     uint8_t *buf = NULL;
2203
2204     if (!drv)
2205         return -ENOMEDIUM;
2206
2207     if (!bs->backing) {
2208         return -ENOTSUP;
2209     }
2210
2211     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2212         bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2213         return -EBUSY;
2214     }
2215
2216     ro = bs->backing->bs->read_only;
2217     open_flags =  bs->backing->bs->open_flags;
2218
2219     if (ro) {
2220         if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2221             return -EACCES;
2222         }
2223     }
2224
2225     length = bdrv_getlength(bs);
2226     if (length < 0) {
2227         ret = length;
2228         goto ro_cleanup;
2229     }
2230
2231     backing_length = bdrv_getlength(bs->backing->bs);
2232     if (backing_length < 0) {
2233         ret = backing_length;
2234         goto ro_cleanup;
2235     }
2236
2237     /* If our top snapshot is larger than the backing file image,
2238      * grow the backing file image if possible.  If not possible,
2239      * we must return an error */
2240     if (length > backing_length) {
2241         ret = bdrv_truncate(bs->backing->bs, length);
2242         if (ret < 0) {
2243             goto ro_cleanup;
2244         }
2245     }
2246
2247     total_sectors = length >> BDRV_SECTOR_BITS;
2248
2249     /* qemu_try_blockalign() for bs will choose an alignment that works for
2250      * bs->backing->bs as well, so no need to compare the alignment manually. */
2251     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2252     if (buf == NULL) {
2253         ret = -ENOMEM;
2254         goto ro_cleanup;
2255     }
2256
2257     for (sector = 0; sector < total_sectors; sector += n) {
2258         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2259         if (ret < 0) {
2260             goto ro_cleanup;
2261         }
2262         if (ret) {
2263             ret = bdrv_read(bs, sector, buf, n);
2264             if (ret < 0) {
2265                 goto ro_cleanup;
2266             }
2267
2268             ret = bdrv_write(bs->backing->bs, sector, buf, n);
2269             if (ret < 0) {
2270                 goto ro_cleanup;
2271             }
2272         }
2273     }
2274
2275     if (drv->bdrv_make_empty) {
2276         ret = drv->bdrv_make_empty(bs);
2277         if (ret < 0) {
2278             goto ro_cleanup;
2279         }
2280         bdrv_flush(bs);
2281     }
2282
2283     /*
2284      * Make sure all data we wrote to the backing device is actually
2285      * stable on disk.
2286      */
2287     if (bs->backing) {
2288         bdrv_flush(bs->backing->bs);
2289     }
2290
2291     ret = 0;
2292 ro_cleanup:
2293     qemu_vfree(buf);
2294
2295     if (ro) {
2296         /* ignoring error return here */
2297         bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2298     }
2299
2300     return ret;
2301 }
2302
2303 int bdrv_commit_all(void)
2304 {
2305     BlockDriverState *bs;
2306
2307     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2308         AioContext *aio_context = bdrv_get_aio_context(bs);
2309
2310         aio_context_acquire(aio_context);
2311         if (bs->drv && bs->backing) {
2312             int ret = bdrv_commit(bs);
2313             if (ret < 0) {
2314                 aio_context_release(aio_context);
2315                 return ret;
2316             }
2317         }
2318         aio_context_release(aio_context);
2319     }
2320     return 0;
2321 }
2322
2323 /*
2324  * Return values:
2325  * 0        - success
2326  * -EINVAL  - backing format specified, but no file
2327  * -ENOSPC  - can't update the backing file because no space is left in the
2328  *            image file header
2329  * -ENOTSUP - format driver doesn't support changing the backing file
2330  */
2331 int bdrv_change_backing_file(BlockDriverState *bs,
2332     const char *backing_file, const char *backing_fmt)
2333 {
2334     BlockDriver *drv = bs->drv;
2335     int ret;
2336
2337     /* Backing file format doesn't make sense without a backing file */
2338     if (backing_fmt && !backing_file) {
2339         return -EINVAL;
2340     }
2341
2342     if (drv->bdrv_change_backing_file != NULL) {
2343         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2344     } else {
2345         ret = -ENOTSUP;
2346     }
2347
2348     if (ret == 0) {
2349         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2350         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2351     }
2352     return ret;
2353 }
2354
2355 /*
2356  * Finds the image layer in the chain that has 'bs' as its backing file.
2357  *
2358  * active is the current topmost image.
2359  *
2360  * Returns NULL if bs is not found in active's image chain,
2361  * or if active == bs.
2362  *
2363  * Returns the bottommost base image if bs == NULL.
2364  */
2365 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2366                                     BlockDriverState *bs)
2367 {
2368     while (active && bs != backing_bs(active)) {
2369         active = backing_bs(active);
2370     }
2371
2372     return active;
2373 }
2374
2375 /* Given a BDS, searches for the base layer. */
2376 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2377 {
2378     return bdrv_find_overlay(bs, NULL);
2379 }
2380
2381 typedef struct BlkIntermediateStates {
2382     BlockDriverState *bs;
2383     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2384 } BlkIntermediateStates;
2385
2386
2387 /*
2388  * Drops images above 'base' up to and including 'top', and sets the image
2389  * above 'top' to have base as its backing file.
2390  *
2391  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2392  * information in 'bs' can be properly updated.
2393  *
2394  * E.g., this will convert the following chain:
2395  * bottom <- base <- intermediate <- top <- active
2396  *
2397  * to
2398  *
2399  * bottom <- base <- active
2400  *
2401  * It is allowed for bottom==base, in which case it converts:
2402  *
2403  * base <- intermediate <- top <- active
2404  *
2405  * to
2406  *
2407  * base <- active
2408  *
2409  * If backing_file_str is non-NULL, it will be used when modifying top's
2410  * overlay image metadata.
2411  *
2412  * Error conditions:
2413  *  if active == top, that is considered an error
2414  *
2415  */
2416 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2417                            BlockDriverState *base, const char *backing_file_str)
2418 {
2419     BlockDriverState *intermediate;
2420     BlockDriverState *base_bs = NULL;
2421     BlockDriverState *new_top_bs = NULL;
2422     BlkIntermediateStates *intermediate_state, *next;
2423     int ret = -EIO;
2424
2425     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2426     QSIMPLEQ_INIT(&states_to_delete);
2427
2428     if (!top->drv || !base->drv) {
2429         goto exit;
2430     }
2431
2432     new_top_bs = bdrv_find_overlay(active, top);
2433
2434     if (new_top_bs == NULL) {
2435         /* we could not find the image above 'top', this is an error */
2436         goto exit;
2437     }
2438
2439     /* special case of new_top_bs->backing->bs already pointing to base - nothing
2440      * to do, no intermediate images */
2441     if (backing_bs(new_top_bs) == base) {
2442         ret = 0;
2443         goto exit;
2444     }
2445
2446     intermediate = top;
2447
2448     /* now we will go down through the list, and add each BDS we find
2449      * into our deletion queue, until we hit the 'base'
2450      */
2451     while (intermediate) {
2452         intermediate_state = g_new0(BlkIntermediateStates, 1);
2453         intermediate_state->bs = intermediate;
2454         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2455
2456         if (backing_bs(intermediate) == base) {
2457             base_bs = backing_bs(intermediate);
2458             break;
2459         }
2460         intermediate = backing_bs(intermediate);
2461     }
2462     if (base_bs == NULL) {
2463         /* something went wrong, we did not end at the base. safely
2464          * unravel everything, and exit with error */
2465         goto exit;
2466     }
2467
2468     /* success - we can delete the intermediate states, and link top->base */
2469     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2470     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2471                                    base_bs->drv ? base_bs->drv->format_name : "");
2472     if (ret) {
2473         goto exit;
2474     }
2475     bdrv_set_backing_hd(new_top_bs, base_bs);
2476
2477     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2478         /* so that bdrv_close() does not recursively close the chain */
2479         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2480         bdrv_unref(intermediate_state->bs);
2481     }
2482     ret = 0;
2483
2484 exit:
2485     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2486         g_free(intermediate_state);
2487     }
2488     return ret;
2489 }
2490
2491 /**
2492  * Truncate file to 'offset' bytes (needed only for file protocols)
2493  */
2494 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2495 {
2496     BlockDriver *drv = bs->drv;
2497     int ret;
2498     if (!drv)
2499         return -ENOMEDIUM;
2500     if (!drv->bdrv_truncate)
2501         return -ENOTSUP;
2502     if (bs->read_only)
2503         return -EACCES;
2504
2505     ret = drv->bdrv_truncate(bs, offset);
2506     if (ret == 0) {
2507         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2508         bdrv_dirty_bitmap_truncate(bs);
2509         if (bs->blk) {
2510             blk_dev_resize_cb(bs->blk);
2511         }
2512     }
2513     return ret;
2514 }
2515
2516 /**
2517  * Length of a allocated file in bytes. Sparse files are counted by actual
2518  * allocated space. Return < 0 if error or unknown.
2519  */
2520 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2521 {
2522     BlockDriver *drv = bs->drv;
2523     if (!drv) {
2524         return -ENOMEDIUM;
2525     }
2526     if (drv->bdrv_get_allocated_file_size) {
2527         return drv->bdrv_get_allocated_file_size(bs);
2528     }
2529     if (bs->file) {
2530         return bdrv_get_allocated_file_size(bs->file->bs);
2531     }
2532     return -ENOTSUP;
2533 }
2534
2535 /**
2536  * Return number of sectors on success, -errno on error.
2537  */
2538 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2539 {
2540     BlockDriver *drv = bs->drv;
2541
2542     if (!drv)
2543         return -ENOMEDIUM;
2544
2545     if (drv->has_variable_length) {
2546         int ret = refresh_total_sectors(bs, bs->total_sectors);
2547         if (ret < 0) {
2548             return ret;
2549         }
2550     }
2551     return bs->total_sectors;
2552 }
2553
2554 /**
2555  * Return length in bytes on success, -errno on error.
2556  * The length is always a multiple of BDRV_SECTOR_SIZE.
2557  */
2558 int64_t bdrv_getlength(BlockDriverState *bs)
2559 {
2560     int64_t ret = bdrv_nb_sectors(bs);
2561
2562     ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2563     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2564 }
2565
2566 /* return 0 as number of sectors if no device present or error */
2567 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2568 {
2569     int64_t nb_sectors = bdrv_nb_sectors(bs);
2570
2571     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2572 }
2573
2574 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2575                        BlockdevOnError on_write_error)
2576 {
2577     bs->on_read_error = on_read_error;
2578     bs->on_write_error = on_write_error;
2579 }
2580
2581 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2582 {
2583     return is_read ? bs->on_read_error : bs->on_write_error;
2584 }
2585
2586 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2587 {
2588     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2589
2590     switch (on_err) {
2591     case BLOCKDEV_ON_ERROR_ENOSPC:
2592         return (error == ENOSPC) ?
2593                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2594     case BLOCKDEV_ON_ERROR_STOP:
2595         return BLOCK_ERROR_ACTION_STOP;
2596     case BLOCKDEV_ON_ERROR_REPORT:
2597         return BLOCK_ERROR_ACTION_REPORT;
2598     case BLOCKDEV_ON_ERROR_IGNORE:
2599         return BLOCK_ERROR_ACTION_IGNORE;
2600     default:
2601         abort();
2602     }
2603 }
2604
2605 static void send_qmp_error_event(BlockDriverState *bs,
2606                                  BlockErrorAction action,
2607                                  bool is_read, int error)
2608 {
2609     IoOperationType optype;
2610
2611     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2612     qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2613                                    bdrv_iostatus_is_enabled(bs),
2614                                    error == ENOSPC, strerror(error),
2615                                    &error_abort);
2616 }
2617
2618 /* This is done by device models because, while the block layer knows
2619  * about the error, it does not know whether an operation comes from
2620  * the device or the block layer (from a job, for example).
2621  */
2622 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2623                        bool is_read, int error)
2624 {
2625     assert(error >= 0);
2626
2627     if (action == BLOCK_ERROR_ACTION_STOP) {
2628         /* First set the iostatus, so that "info block" returns an iostatus
2629          * that matches the events raised so far (an additional error iostatus
2630          * is fine, but not a lost one).
2631          */
2632         bdrv_iostatus_set_err(bs, error);
2633
2634         /* Then raise the request to stop the VM and the event.
2635          * qemu_system_vmstop_request_prepare has two effects.  First,
2636          * it ensures that the STOP event always comes after the
2637          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
2638          * can observe the STOP event and do a "cont" before the STOP
2639          * event is issued, the VM will not stop.  In this case, vm_start()
2640          * also ensures that the STOP/RESUME pair of events is emitted.
2641          */
2642         qemu_system_vmstop_request_prepare();
2643         send_qmp_error_event(bs, action, is_read, error);
2644         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2645     } else {
2646         send_qmp_error_event(bs, action, is_read, error);
2647     }
2648 }
2649
2650 int bdrv_is_read_only(BlockDriverState *bs)
2651 {
2652     return bs->read_only;
2653 }
2654
2655 int bdrv_is_sg(BlockDriverState *bs)
2656 {
2657     return bs->sg;
2658 }
2659
2660 int bdrv_enable_write_cache(BlockDriverState *bs)
2661 {
2662     return bs->enable_write_cache;
2663 }
2664
2665 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2666 {
2667     bs->enable_write_cache = wce;
2668
2669     /* so a reopen() will preserve wce */
2670     if (wce) {
2671         bs->open_flags |= BDRV_O_CACHE_WB;
2672     } else {
2673         bs->open_flags &= ~BDRV_O_CACHE_WB;
2674     }
2675 }
2676
2677 int bdrv_is_encrypted(BlockDriverState *bs)
2678 {
2679     if (bs->backing && bs->backing->bs->encrypted) {
2680         return 1;
2681     }
2682     return bs->encrypted;
2683 }
2684
2685 int bdrv_key_required(BlockDriverState *bs)
2686 {
2687     BdrvChild *backing = bs->backing;
2688
2689     if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2690         return 1;
2691     }
2692     return (bs->encrypted && !bs->valid_key);
2693 }
2694
2695 int bdrv_set_key(BlockDriverState *bs, const char *key)
2696 {
2697     int ret;
2698     if (bs->backing && bs->backing->bs->encrypted) {
2699         ret = bdrv_set_key(bs->backing->bs, key);
2700         if (ret < 0)
2701             return ret;
2702         if (!bs->encrypted)
2703             return 0;
2704     }
2705     if (!bs->encrypted) {
2706         return -EINVAL;
2707     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2708         return -ENOMEDIUM;
2709     }
2710     ret = bs->drv->bdrv_set_key(bs, key);
2711     if (ret < 0) {
2712         bs->valid_key = 0;
2713     } else if (!bs->valid_key) {
2714         bs->valid_key = 1;
2715         if (bs->blk) {
2716             /* call the change callback now, we skipped it on open */
2717             blk_dev_change_media_cb(bs->blk, true);
2718         }
2719     }
2720     return ret;
2721 }
2722
2723 /*
2724  * Provide an encryption key for @bs.
2725  * If @key is non-null:
2726  *     If @bs is not encrypted, fail.
2727  *     Else if the key is invalid, fail.
2728  *     Else set @bs's key to @key, replacing the existing key, if any.
2729  * If @key is null:
2730  *     If @bs is encrypted and still lacks a key, fail.
2731  *     Else do nothing.
2732  * On failure, store an error object through @errp if non-null.
2733  */
2734 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2735 {
2736     if (key) {
2737         if (!bdrv_is_encrypted(bs)) {
2738             error_setg(errp, "Node '%s' is not encrypted",
2739                       bdrv_get_device_or_node_name(bs));
2740         } else if (bdrv_set_key(bs, key) < 0) {
2741             error_setg(errp, QERR_INVALID_PASSWORD);
2742         }
2743     } else {
2744         if (bdrv_key_required(bs)) {
2745             error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2746                       "'%s' (%s) is encrypted",
2747                       bdrv_get_device_or_node_name(bs),
2748                       bdrv_get_encrypted_filename(bs));
2749         }
2750     }
2751 }
2752
2753 const char *bdrv_get_format_name(BlockDriverState *bs)
2754 {
2755     return bs->drv ? bs->drv->format_name : NULL;
2756 }
2757
2758 static int qsort_strcmp(const void *a, const void *b)
2759 {
2760     return strcmp(a, b);
2761 }
2762
2763 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2764                          void *opaque)
2765 {
2766     BlockDriver *drv;
2767     int count = 0;
2768     int i;
2769     const char **formats = NULL;
2770
2771     QLIST_FOREACH(drv, &bdrv_drivers, list) {
2772         if (drv->format_name) {
2773             bool found = false;
2774             int i = count;
2775             while (formats && i && !found) {
2776                 found = !strcmp(formats[--i], drv->format_name);
2777             }
2778
2779             if (!found) {
2780                 formats = g_renew(const char *, formats, count + 1);
2781                 formats[count++] = drv->format_name;
2782             }
2783         }
2784     }
2785
2786     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2787
2788     for (i = 0; i < count; i++) {
2789         it(opaque, formats[i]);
2790     }
2791
2792     g_free(formats);
2793 }
2794
2795 /* This function is to find a node in the bs graph */
2796 BlockDriverState *bdrv_find_node(const char *node_name)
2797 {
2798     BlockDriverState *bs;
2799
2800     assert(node_name);
2801
2802     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2803         if (!strcmp(node_name, bs->node_name)) {
2804             return bs;
2805         }
2806     }
2807     return NULL;
2808 }
2809
2810 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2811 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2812 {
2813     BlockDeviceInfoList *list, *entry;
2814     BlockDriverState *bs;
2815
2816     list = NULL;
2817     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2818         BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2819         if (!info) {
2820             qapi_free_BlockDeviceInfoList(list);
2821             return NULL;
2822         }
2823         entry = g_malloc0(sizeof(*entry));
2824         entry->value = info;
2825         entry->next = list;
2826         list = entry;
2827     }
2828
2829     return list;
2830 }
2831
2832 BlockDriverState *bdrv_lookup_bs(const char *device,
2833                                  const char *node_name,
2834                                  Error **errp)
2835 {
2836     BlockBackend *blk;
2837     BlockDriverState *bs;
2838
2839     if (device) {
2840         blk = blk_by_name(device);
2841
2842         if (blk) {
2843             return blk_bs(blk);
2844         }
2845     }
2846
2847     if (node_name) {
2848         bs = bdrv_find_node(node_name);
2849
2850         if (bs) {
2851             return bs;
2852         }
2853     }
2854
2855     error_setg(errp, "Cannot find device=%s nor node_name=%s",
2856                      device ? device : "",
2857                      node_name ? node_name : "");
2858     return NULL;
2859 }
2860
2861 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2862  * return false.  If either argument is NULL, return false. */
2863 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2864 {
2865     while (top && top != base) {
2866         top = backing_bs(top);
2867     }
2868
2869     return top != NULL;
2870 }
2871
2872 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2873 {
2874     if (!bs) {
2875         return QTAILQ_FIRST(&graph_bdrv_states);
2876     }
2877     return QTAILQ_NEXT(bs, node_list);
2878 }
2879
2880 BlockDriverState *bdrv_next(BlockDriverState *bs)
2881 {
2882     if (!bs) {
2883         return QTAILQ_FIRST(&bdrv_states);
2884     }
2885     return QTAILQ_NEXT(bs, device_list);
2886 }
2887
2888 const char *bdrv_get_node_name(const BlockDriverState *bs)
2889 {
2890     return bs->node_name;
2891 }
2892
2893 /* TODO check what callers really want: bs->node_name or blk_name() */
2894 const char *bdrv_get_device_name(const BlockDriverState *bs)
2895 {
2896     return bs->blk ? blk_name(bs->blk) : "";
2897 }
2898
2899 /* This can be used to identify nodes that might not have a device
2900  * name associated. Since node and device names live in the same
2901  * namespace, the result is unambiguous. The exception is if both are
2902  * absent, then this returns an empty (non-null) string. */
2903 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2904 {
2905     return bs->blk ? blk_name(bs->blk) : bs->node_name;
2906 }
2907
2908 int bdrv_get_flags(BlockDriverState *bs)
2909 {
2910     return bs->open_flags;
2911 }
2912
2913 int bdrv_has_zero_init_1(BlockDriverState *bs)
2914 {
2915     return 1;
2916 }
2917
2918 int bdrv_has_zero_init(BlockDriverState *bs)
2919 {
2920     assert(bs->drv);
2921
2922     /* If BS is a copy on write image, it is initialized to
2923        the contents of the base image, which may not be zeroes.  */
2924     if (bs->backing) {
2925         return 0;
2926     }
2927     if (bs->drv->bdrv_has_zero_init) {
2928         return bs->drv->bdrv_has_zero_init(bs);
2929     }
2930
2931     /* safe default */
2932     return 0;
2933 }
2934
2935 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2936 {
2937     BlockDriverInfo bdi;
2938
2939     if (bs->backing) {
2940         return false;
2941     }
2942
2943     if (bdrv_get_info(bs, &bdi) == 0) {
2944         return bdi.unallocated_blocks_are_zero;
2945     }
2946
2947     return false;
2948 }
2949
2950 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2951 {
2952     BlockDriverInfo bdi;
2953
2954     if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
2955         return false;
2956     }
2957
2958     if (bdrv_get_info(bs, &bdi) == 0) {
2959         return bdi.can_write_zeroes_with_unmap;
2960     }
2961
2962     return false;
2963 }
2964
2965 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2966 {
2967     if (bs->backing && bs->backing->bs->encrypted)
2968         return bs->backing_file;
2969     else if (bs->encrypted)
2970         return bs->filename;
2971     else
2972         return NULL;
2973 }
2974
2975 void bdrv_get_backing_filename(BlockDriverState *bs,
2976                                char *filename, int filename_size)
2977 {
2978     pstrcpy(filename, filename_size, bs->backing_file);
2979 }
2980
2981 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2982 {
2983     BlockDriver *drv = bs->drv;
2984     if (!drv)
2985         return -ENOMEDIUM;
2986     if (!drv->bdrv_get_info)
2987         return -ENOTSUP;
2988     memset(bdi, 0, sizeof(*bdi));
2989     return drv->bdrv_get_info(bs, bdi);
2990 }
2991
2992 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2993 {
2994     BlockDriver *drv = bs->drv;
2995     if (drv && drv->bdrv_get_specific_info) {
2996         return drv->bdrv_get_specific_info(bs);
2997     }
2998     return NULL;
2999 }
3000
3001 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3002 {
3003     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3004         return;
3005     }
3006
3007     bs->drv->bdrv_debug_event(bs, event);
3008 }
3009
3010 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3011                           const char *tag)
3012 {
3013     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3014         bs = bs->file ? bs->file->bs : NULL;
3015     }
3016
3017     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3018         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3019     }
3020
3021     return -ENOTSUP;
3022 }
3023
3024 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3025 {
3026     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3027         bs = bs->file ? bs->file->bs : NULL;
3028     }
3029
3030     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3031         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3032     }
3033
3034     return -ENOTSUP;
3035 }
3036
3037 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3038 {
3039     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3040         bs = bs->file ? bs->file->bs : NULL;
3041     }
3042
3043     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3044         return bs->drv->bdrv_debug_resume(bs, tag);
3045     }
3046
3047     return -ENOTSUP;
3048 }
3049
3050 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3051 {
3052     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3053         bs = bs->file ? bs->file->bs : NULL;
3054     }
3055
3056     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3057         return bs->drv->bdrv_debug_is_suspended(bs, tag);
3058     }
3059
3060     return false;
3061 }
3062
3063 int bdrv_is_snapshot(BlockDriverState *bs)
3064 {
3065     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3066 }
3067
3068 /* backing_file can either be relative, or absolute, or a protocol.  If it is
3069  * relative, it must be relative to the chain.  So, passing in bs->filename
3070  * from a BDS as backing_file should not be done, as that may be relative to
3071  * the CWD rather than the chain. */
3072 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3073         const char *backing_file)
3074 {
3075     char *filename_full = NULL;
3076     char *backing_file_full = NULL;
3077     char *filename_tmp = NULL;
3078     int is_protocol = 0;
3079     BlockDriverState *curr_bs = NULL;
3080     BlockDriverState *retval = NULL;
3081
3082     if (!bs || !bs->drv || !backing_file) {
3083         return NULL;
3084     }
3085
3086     filename_full     = g_malloc(PATH_MAX);
3087     backing_file_full = g_malloc(PATH_MAX);
3088     filename_tmp      = g_malloc(PATH_MAX);
3089
3090     is_protocol = path_has_protocol(backing_file);
3091
3092     for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3093
3094         /* If either of the filename paths is actually a protocol, then
3095          * compare unmodified paths; otherwise make paths relative */
3096         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3097             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3098                 retval = curr_bs->backing->bs;
3099                 break;
3100             }
3101         } else {
3102             /* If not an absolute filename path, make it relative to the current
3103              * image's filename path */
3104             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3105                          backing_file);
3106
3107             /* We are going to compare absolute pathnames */
3108             if (!realpath(filename_tmp, filename_full)) {
3109                 continue;
3110             }
3111
3112             /* We need to make sure the backing filename we are comparing against
3113              * is relative to the current image filename (or absolute) */
3114             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3115                          curr_bs->backing_file);
3116
3117             if (!realpath(filename_tmp, backing_file_full)) {
3118                 continue;
3119             }
3120
3121             if (strcmp(backing_file_full, filename_full) == 0) {
3122                 retval = curr_bs->backing->bs;
3123                 break;
3124             }
3125         }
3126     }
3127
3128     g_free(filename_full);
3129     g_free(backing_file_full);
3130     g_free(filename_tmp);
3131     return retval;
3132 }
3133
3134 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3135 {
3136     if (!bs->drv) {
3137         return 0;
3138     }
3139
3140     if (!bs->backing) {
3141         return 0;
3142     }
3143
3144     return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3145 }
3146
3147 void bdrv_init(void)
3148 {
3149     module_call_init(MODULE_INIT_BLOCK);
3150 }
3151
3152 void bdrv_init_with_whitelist(void)
3153 {
3154     use_bdrv_whitelist = 1;
3155     bdrv_init();
3156 }
3157
3158 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3159 {
3160     Error *local_err = NULL;
3161     int ret;
3162
3163     if (!bs->drv)  {
3164         return;
3165     }
3166
3167     if (!(bs->open_flags & BDRV_O_INCOMING)) {
3168         return;
3169     }
3170     bs->open_flags &= ~BDRV_O_INCOMING;
3171
3172     if (bs->drv->bdrv_invalidate_cache) {
3173         bs->drv->bdrv_invalidate_cache(bs, &local_err);
3174     } else if (bs->file) {
3175         bdrv_invalidate_cache(bs->file->bs, &local_err);
3176     }
3177     if (local_err) {
3178         error_propagate(errp, local_err);
3179         return;
3180     }
3181
3182     ret = refresh_total_sectors(bs, bs->total_sectors);
3183     if (ret < 0) {
3184         error_setg_errno(errp, -ret, "Could not refresh total sector count");
3185         return;
3186     }
3187 }
3188
3189 void bdrv_invalidate_cache_all(Error **errp)
3190 {
3191     BlockDriverState *bs;
3192     Error *local_err = NULL;
3193
3194     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3195         AioContext *aio_context = bdrv_get_aio_context(bs);
3196
3197         aio_context_acquire(aio_context);
3198         bdrv_invalidate_cache(bs, &local_err);
3199         aio_context_release(aio_context);
3200         if (local_err) {
3201             error_propagate(errp, local_err);
3202             return;
3203         }
3204     }
3205 }
3206
3207 /**************************************************************/
3208 /* removable device support */
3209
3210 /**
3211  * Return TRUE if the media is present
3212  */
3213 int bdrv_is_inserted(BlockDriverState *bs)
3214 {
3215     BlockDriver *drv = bs->drv;
3216
3217     if (!drv)
3218         return 0;
3219     if (!drv->bdrv_is_inserted)
3220         return 1;
3221     return drv->bdrv_is_inserted(bs);
3222 }
3223
3224 /**
3225  * Return whether the media changed since the last call to this
3226  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
3227  */
3228 int bdrv_media_changed(BlockDriverState *bs)
3229 {
3230     BlockDriver *drv = bs->drv;
3231
3232     if (drv && drv->bdrv_media_changed) {
3233         return drv->bdrv_media_changed(bs);
3234     }
3235     return -ENOTSUP;
3236 }
3237
3238 /**
3239  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3240  */
3241 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3242 {
3243     BlockDriver *drv = bs->drv;
3244     const char *device_name;
3245
3246     if (drv && drv->bdrv_eject) {
3247         drv->bdrv_eject(bs, eject_flag);
3248     }
3249
3250     device_name = bdrv_get_device_name(bs);
3251     if (device_name[0] != '\0') {
3252         qapi_event_send_device_tray_moved(device_name,
3253                                           eject_flag, &error_abort);
3254     }
3255 }
3256
3257 /**
3258  * Lock or unlock the media (if it is locked, the user won't be able
3259  * to eject it manually).
3260  */
3261 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3262 {
3263     BlockDriver *drv = bs->drv;
3264
3265     trace_bdrv_lock_medium(bs, locked);
3266
3267     if (drv && drv->bdrv_lock_medium) {
3268         drv->bdrv_lock_medium(bs, locked);
3269     }
3270 }
3271
3272 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3273 {
3274     bs->guest_block_size = align;
3275 }
3276
3277 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3278 {
3279     BdrvDirtyBitmap *bm;
3280
3281     assert(name);
3282     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3283         if (bm->name && !strcmp(name, bm->name)) {
3284             return bm;
3285         }
3286     }
3287     return NULL;
3288 }
3289
3290 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3291 {
3292     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3293     g_free(bitmap->name);
3294     bitmap->name = NULL;
3295 }
3296
3297 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3298                                           uint32_t granularity,
3299                                           const char *name,
3300                                           Error **errp)
3301 {
3302     int64_t bitmap_size;
3303     BdrvDirtyBitmap *bitmap;
3304     uint32_t sector_granularity;
3305
3306     assert((granularity & (granularity - 1)) == 0);
3307
3308     if (name && bdrv_find_dirty_bitmap(bs, name)) {
3309         error_setg(errp, "Bitmap already exists: %s", name);
3310         return NULL;
3311     }
3312     sector_granularity = granularity >> BDRV_SECTOR_BITS;
3313     assert(sector_granularity);
3314     bitmap_size = bdrv_nb_sectors(bs);
3315     if (bitmap_size < 0) {
3316         error_setg_errno(errp, -bitmap_size, "could not get length of device");
3317         errno = -bitmap_size;
3318         return NULL;
3319     }
3320     bitmap = g_new0(BdrvDirtyBitmap, 1);
3321     bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3322     bitmap->size = bitmap_size;
3323     bitmap->name = g_strdup(name);
3324     bitmap->disabled = false;
3325     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3326     return bitmap;
3327 }
3328
3329 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3330 {
3331     return bitmap->successor;
3332 }
3333
3334 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3335 {
3336     return !(bitmap->disabled || bitmap->successor);
3337 }
3338
3339 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3340 {
3341     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3342         return DIRTY_BITMAP_STATUS_FROZEN;
3343     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3344         return DIRTY_BITMAP_STATUS_DISABLED;
3345     } else {
3346         return DIRTY_BITMAP_STATUS_ACTIVE;
3347     }
3348 }
3349
3350 /**
3351  * Create a successor bitmap destined to replace this bitmap after an operation.
3352  * Requires that the bitmap is not frozen and has no successor.
3353  */
3354 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3355                                        BdrvDirtyBitmap *bitmap, Error **errp)
3356 {
3357     uint64_t granularity;
3358     BdrvDirtyBitmap *child;
3359
3360     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3361         error_setg(errp, "Cannot create a successor for a bitmap that is "
3362                    "currently frozen");
3363         return -1;
3364     }
3365     assert(!bitmap->successor);
3366
3367     /* Create an anonymous successor */
3368     granularity = bdrv_dirty_bitmap_granularity(bitmap);
3369     child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3370     if (!child) {
3371         return -1;
3372     }
3373
3374     /* Successor will be on or off based on our current state. */
3375     child->disabled = bitmap->disabled;
3376
3377     /* Install the successor and freeze the parent */
3378     bitmap->successor = child;
3379     return 0;
3380 }
3381
3382 /**
3383  * For a bitmap with a successor, yield our name to the successor,
3384  * delete the old bitmap, and return a handle to the new bitmap.
3385  */
3386 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3387                                             BdrvDirtyBitmap *bitmap,
3388                                             Error **errp)
3389 {
3390     char *name;
3391     BdrvDirtyBitmap *successor = bitmap->successor;
3392
3393     if (successor == NULL) {
3394         error_setg(errp, "Cannot relinquish control if "
3395                    "there's no successor present");
3396         return NULL;
3397     }
3398
3399     name = bitmap->name;
3400     bitmap->name = NULL;
3401     successor->name = name;
3402     bitmap->successor = NULL;
3403     bdrv_release_dirty_bitmap(bs, bitmap);
3404
3405     return successor;
3406 }
3407
3408 /**
3409  * In cases of failure where we can no longer safely delete the parent,
3410  * we may wish to re-join the parent and child/successor.
3411  * The merged parent will be un-frozen, but not explicitly re-enabled.
3412  */
3413 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3414                                            BdrvDirtyBitmap *parent,
3415                                            Error **errp)
3416 {
3417     BdrvDirtyBitmap *successor = parent->successor;
3418
3419     if (!successor) {
3420         error_setg(errp, "Cannot reclaim a successor when none is present");
3421         return NULL;
3422     }
3423
3424     if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3425         error_setg(errp, "Merging of parent and successor bitmap failed");
3426         return NULL;
3427     }
3428     bdrv_release_dirty_bitmap(bs, successor);
3429     parent->successor = NULL;
3430
3431     return parent;
3432 }
3433
3434 /**
3435  * Truncates _all_ bitmaps attached to a BDS.
3436  */
3437 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3438 {
3439     BdrvDirtyBitmap *bitmap;
3440     uint64_t size = bdrv_nb_sectors(bs);
3441
3442     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3443         assert(!bdrv_dirty_bitmap_frozen(bitmap));
3444         hbitmap_truncate(bitmap->bitmap, size);
3445         bitmap->size = size;
3446     }
3447 }
3448
3449 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3450 {
3451     BdrvDirtyBitmap *bm, *next;
3452     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3453         if (bm == bitmap) {
3454             assert(!bdrv_dirty_bitmap_frozen(bm));
3455             QLIST_REMOVE(bitmap, list);
3456             hbitmap_free(bitmap->bitmap);
3457             g_free(bitmap->name);
3458             g_free(bitmap);
3459             return;
3460         }
3461     }
3462 }
3463
3464 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3465 {
3466     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3467     bitmap->disabled = true;
3468 }
3469
3470 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3471 {
3472     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3473     bitmap->disabled = false;
3474 }
3475
3476 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3477 {
3478     BdrvDirtyBitmap *bm;
3479     BlockDirtyInfoList *list = NULL;
3480     BlockDirtyInfoList **plist = &list;
3481
3482     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3483         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3484         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3485         info->count = bdrv_get_dirty_count(bm);
3486         info->granularity = bdrv_dirty_bitmap_granularity(bm);
3487         info->has_name = !!bm->name;
3488         info->name = g_strdup(bm->name);
3489         info->status = bdrv_dirty_bitmap_status(bm);
3490         entry->value = info;
3491         *plist = entry;
3492         plist = &entry->next;
3493     }
3494
3495     return list;
3496 }
3497
3498 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3499 {
3500     if (bitmap) {
3501         return hbitmap_get(bitmap->bitmap, sector);
3502     } else {
3503         return 0;
3504     }
3505 }
3506
3507 /**
3508  * Chooses a default granularity based on the existing cluster size,
3509  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3510  * is no cluster size information available.
3511  */
3512 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3513 {
3514     BlockDriverInfo bdi;
3515     uint32_t granularity;
3516
3517     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3518         granularity = MAX(4096, bdi.cluster_size);
3519         granularity = MIN(65536, granularity);
3520     } else {
3521         granularity = 65536;
3522     }
3523
3524     return granularity;
3525 }
3526
3527 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3528 {
3529     return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3530 }
3531
3532 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3533 {
3534     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3535 }
3536
3537 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3538                            int64_t cur_sector, int nr_sectors)
3539 {
3540     assert(bdrv_dirty_bitmap_enabled(bitmap));
3541     hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3542 }
3543
3544 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3545                              int64_t cur_sector, int nr_sectors)
3546 {
3547     assert(bdrv_dirty_bitmap_enabled(bitmap));
3548     hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3549 }
3550
3551 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3552 {
3553     assert(bdrv_dirty_bitmap_enabled(bitmap));
3554     hbitmap_reset_all(bitmap->bitmap);
3555 }
3556
3557 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3558                     int nr_sectors)
3559 {
3560     BdrvDirtyBitmap *bitmap;
3561     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3562         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3563             continue;
3564         }
3565         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3566     }
3567 }
3568
3569 /**
3570  * Advance an HBitmapIter to an arbitrary offset.
3571  */
3572 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3573 {
3574     assert(hbi->hb);
3575     hbitmap_iter_init(hbi, hbi->hb, offset);
3576 }
3577
3578 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3579 {
3580     return hbitmap_count(bitmap->bitmap);
3581 }
3582
3583 /* Get a reference to bs */
3584 void bdrv_ref(BlockDriverState *bs)
3585 {
3586     bs->refcnt++;
3587 }
3588
3589 /* Release a previously grabbed reference to bs.
3590  * If after releasing, reference count is zero, the BlockDriverState is
3591  * deleted. */
3592 void bdrv_unref(BlockDriverState *bs)
3593 {
3594     if (!bs) {
3595         return;
3596     }
3597     assert(bs->refcnt > 0);
3598     if (--bs->refcnt == 0) {
3599         bdrv_delete(bs);
3600     }
3601 }
3602
3603 struct BdrvOpBlocker {
3604     Error *reason;
3605     QLIST_ENTRY(BdrvOpBlocker) list;
3606 };
3607
3608 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3609 {
3610     BdrvOpBlocker *blocker;
3611     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3612     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3613         blocker = QLIST_FIRST(&bs->op_blockers[op]);
3614         if (errp) {
3615             error_setg(errp, "Node '%s' is busy: %s",
3616                        bdrv_get_device_or_node_name(bs),
3617                        error_get_pretty(blocker->reason));
3618         }
3619         return true;
3620     }
3621     return false;
3622 }
3623
3624 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3625 {
3626     BdrvOpBlocker *blocker;
3627     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3628
3629     blocker = g_new0(BdrvOpBlocker, 1);
3630     blocker->reason = reason;
3631     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3632 }
3633
3634 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3635 {
3636     BdrvOpBlocker *blocker, *next;
3637     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3638     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3639         if (blocker->reason == reason) {
3640             QLIST_REMOVE(blocker, list);
3641             g_free(blocker);
3642         }
3643     }
3644 }
3645
3646 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3647 {
3648     int i;
3649     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3650         bdrv_op_block(bs, i, reason);
3651     }
3652 }
3653
3654 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3655 {
3656     int i;
3657     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3658         bdrv_op_unblock(bs, i, reason);
3659     }
3660 }
3661
3662 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3663 {
3664     int i;
3665
3666     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3667         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3668             return false;
3669         }
3670     }
3671     return true;
3672 }
3673
3674 void bdrv_iostatus_enable(BlockDriverState *bs)
3675 {
3676     bs->iostatus_enabled = true;
3677     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3678 }
3679
3680 /* The I/O status is only enabled if the drive explicitly
3681  * enables it _and_ the VM is configured to stop on errors */
3682 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3683 {
3684     return (bs->iostatus_enabled &&
3685            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3686             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
3687             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3688 }
3689
3690 void bdrv_iostatus_disable(BlockDriverState *bs)
3691 {
3692     bs->iostatus_enabled = false;
3693 }
3694
3695 void bdrv_iostatus_reset(BlockDriverState *bs)
3696 {
3697     if (bdrv_iostatus_is_enabled(bs)) {
3698         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3699         if (bs->job) {
3700             block_job_iostatus_reset(bs->job);
3701         }
3702     }
3703 }
3704
3705 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3706 {
3707     assert(bdrv_iostatus_is_enabled(bs));
3708     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3709         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3710                                          BLOCK_DEVICE_IO_STATUS_FAILED;
3711     }
3712 }
3713
3714 void bdrv_img_create(const char *filename, const char *fmt,
3715                      const char *base_filename, const char *base_fmt,
3716                      char *options, uint64_t img_size, int flags,
3717                      Error **errp, bool quiet)
3718 {
3719     QemuOptsList *create_opts = NULL;
3720     QemuOpts *opts = NULL;
3721     const char *backing_fmt, *backing_file;
3722     int64_t size;
3723     BlockDriver *drv, *proto_drv;
3724     Error *local_err = NULL;
3725     int ret = 0;
3726
3727     /* Find driver and parse its options */
3728     drv = bdrv_find_format(fmt);
3729     if (!drv) {
3730         error_setg(errp, "Unknown file format '%s'", fmt);
3731         return;
3732     }
3733
3734     proto_drv = bdrv_find_protocol(filename, true, errp);
3735     if (!proto_drv) {
3736         return;
3737     }
3738
3739     if (!drv->create_opts) {
3740         error_setg(errp, "Format driver '%s' does not support image creation",
3741                    drv->format_name);
3742         return;
3743     }
3744
3745     if (!proto_drv->create_opts) {
3746         error_setg(errp, "Protocol driver '%s' does not support image creation",
3747                    proto_drv->format_name);
3748         return;
3749     }
3750
3751     create_opts = qemu_opts_append(create_opts, drv->create_opts);
3752     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3753
3754     /* Create parameter list with default values */
3755     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3756     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3757
3758     /* Parse -o options */
3759     if (options) {
3760         qemu_opts_do_parse(opts, options, NULL, &local_err);
3761         if (local_err) {
3762             error_report_err(local_err);
3763             local_err = NULL;
3764             error_setg(errp, "Invalid options for file format '%s'", fmt);
3765             goto out;
3766         }
3767     }
3768
3769     if (base_filename) {
3770         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3771         if (local_err) {
3772             error_setg(errp, "Backing file not supported for file format '%s'",
3773                        fmt);
3774             goto out;
3775         }
3776     }
3777
3778     if (base_fmt) {
3779         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3780         if (local_err) {
3781             error_setg(errp, "Backing file format not supported for file "
3782                              "format '%s'", fmt);
3783             goto out;
3784         }
3785     }
3786
3787     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3788     if (backing_file) {
3789         if (!strcmp(filename, backing_file)) {
3790             error_setg(errp, "Error: Trying to create an image with the "
3791                              "same filename as the backing file");
3792             goto out;
3793         }
3794     }
3795
3796     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3797
3798     // The size for the image must always be specified, with one exception:
3799     // If we are using a backing file, we can obtain the size from there
3800     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3801     if (size == -1) {
3802         if (backing_file) {
3803             BlockDriverState *bs;
3804             char *full_backing = g_new0(char, PATH_MAX);
3805             int64_t size;
3806             int back_flags;
3807             QDict *backing_options = NULL;
3808
3809             bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3810                                                          full_backing, PATH_MAX,
3811                                                          &local_err);
3812             if (local_err) {
3813                 g_free(full_backing);
3814                 goto out;
3815             }
3816
3817             /* backing files always opened read-only */
3818             back_flags =
3819                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3820
3821             if (backing_fmt) {
3822                 backing_options = qdict_new();
3823                 qdict_put(backing_options, "driver",
3824                           qstring_from_str(backing_fmt));
3825             }
3826
3827             bs = NULL;
3828             ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3829                             back_flags, &local_err);
3830             g_free(full_backing);
3831             if (ret < 0) {
3832                 goto out;
3833             }
3834             size = bdrv_getlength(bs);
3835             if (size < 0) {
3836                 error_setg_errno(errp, -size, "Could not get size of '%s'",
3837                                  backing_file);
3838                 bdrv_unref(bs);
3839                 goto out;
3840             }
3841
3842             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3843
3844             bdrv_unref(bs);
3845         } else {
3846             error_setg(errp, "Image creation needs a size parameter");
3847             goto out;
3848         }
3849     }
3850
3851     if (!quiet) {
3852         printf("Formatting '%s', fmt=%s ", filename, fmt);
3853         qemu_opts_print(opts, " ");
3854         puts("");
3855     }
3856
3857     ret = bdrv_create(drv, filename, opts, &local_err);
3858
3859     if (ret == -EFBIG) {
3860         /* This is generally a better message than whatever the driver would
3861          * deliver (especially because of the cluster_size_hint), since that
3862          * is most probably not much different from "image too large". */
3863         const char *cluster_size_hint = "";
3864         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3865             cluster_size_hint = " (try using a larger cluster size)";
3866         }
3867         error_setg(errp, "The image size is too large for file format '%s'"
3868                    "%s", fmt, cluster_size_hint);
3869         error_free(local_err);
3870         local_err = NULL;
3871     }
3872
3873 out:
3874     qemu_opts_del(opts);
3875     qemu_opts_free(create_opts);
3876     if (local_err) {
3877         error_propagate(errp, local_err);
3878     }
3879 }
3880
3881 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3882 {
3883     return bs->aio_context;
3884 }
3885
3886 void bdrv_detach_aio_context(BlockDriverState *bs)
3887 {
3888     BdrvAioNotifier *baf;
3889
3890     if (!bs->drv) {
3891         return;
3892     }
3893
3894     QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3895         baf->detach_aio_context(baf->opaque);
3896     }
3897
3898     if (bs->io_limits_enabled) {
3899         throttle_timers_detach_aio_context(&bs->throttle_timers);
3900     }
3901     if (bs->drv->bdrv_detach_aio_context) {
3902         bs->drv->bdrv_detach_aio_context(bs);
3903     }
3904     if (bs->file) {
3905         bdrv_detach_aio_context(bs->file->bs);
3906     }
3907     if (bs->backing) {
3908         bdrv_detach_aio_context(bs->backing->bs);
3909     }
3910
3911     bs->aio_context = NULL;
3912 }
3913
3914 void bdrv_attach_aio_context(BlockDriverState *bs,
3915                              AioContext *new_context)
3916 {
3917     BdrvAioNotifier *ban;
3918
3919     if (!bs->drv) {
3920         return;
3921     }
3922
3923     bs->aio_context = new_context;
3924
3925     if (bs->backing) {
3926         bdrv_attach_aio_context(bs->backing->bs, new_context);
3927     }
3928     if (bs->file) {
3929         bdrv_attach_aio_context(bs->file->bs, new_context);
3930     }
3931     if (bs->drv->bdrv_attach_aio_context) {
3932         bs->drv->bdrv_attach_aio_context(bs, new_context);
3933     }
3934     if (bs->io_limits_enabled) {
3935         throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3936     }
3937
3938     QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3939         ban->attached_aio_context(new_context, ban->opaque);
3940     }
3941 }
3942
3943 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3944 {
3945     bdrv_drain(bs); /* ensure there are no in-flight requests */
3946
3947     bdrv_detach_aio_context(bs);
3948
3949     /* This function executes in the old AioContext so acquire the new one in
3950      * case it runs in a different thread.
3951      */
3952     aio_context_acquire(new_context);
3953     bdrv_attach_aio_context(bs, new_context);
3954     aio_context_release(new_context);
3955 }
3956
3957 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3958         void (*attached_aio_context)(AioContext *new_context, void *opaque),
3959         void (*detach_aio_context)(void *opaque), void *opaque)
3960 {
3961     BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3962     *ban = (BdrvAioNotifier){
3963         .attached_aio_context = attached_aio_context,
3964         .detach_aio_context   = detach_aio_context,
3965         .opaque               = opaque
3966     };
3967
3968     QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3969 }
3970
3971 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3972                                       void (*attached_aio_context)(AioContext *,
3973                                                                    void *),
3974                                       void (*detach_aio_context)(void *),
3975                                       void *opaque)
3976 {
3977     BdrvAioNotifier *ban, *ban_next;
3978
3979     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3980         if (ban->attached_aio_context == attached_aio_context &&
3981             ban->detach_aio_context   == detach_aio_context   &&
3982             ban->opaque               == opaque)
3983         {
3984             QLIST_REMOVE(ban, list);
3985             g_free(ban);
3986
3987             return;
3988         }
3989     }
3990
3991     abort();
3992 }
3993
3994 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3995                        BlockDriverAmendStatusCB *status_cb)
3996 {
3997     if (!bs->drv->bdrv_amend_options) {
3998         return -ENOTSUP;
3999     }
4000     return bs->drv->bdrv_amend_options(bs, opts, status_cb);
4001 }
4002
4003 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4004  * of block filter and by bdrv_is_first_non_filter.
4005  * It is used to test if the given bs is the candidate or recurse more in the
4006  * node graph.
4007  */
4008 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4009                                       BlockDriverState *candidate)
4010 {
4011     /* return false if basic checks fails */
4012     if (!bs || !bs->drv) {
4013         return false;
4014     }
4015
4016     /* the code reached a non block filter driver -> check if the bs is
4017      * the same as the candidate. It's the recursion termination condition.
4018      */
4019     if (!bs->drv->is_filter) {
4020         return bs == candidate;
4021     }
4022     /* Down this path the driver is a block filter driver */
4023
4024     /* If the block filter recursion method is defined use it to recurse down
4025      * the node graph.
4026      */
4027     if (bs->drv->bdrv_recurse_is_first_non_filter) {
4028         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4029     }
4030
4031     /* the driver is a block filter but don't allow to recurse -> return false
4032      */
4033     return false;
4034 }
4035
4036 /* This function checks if the candidate is the first non filter bs down it's
4037  * bs chain. Since we don't have pointers to parents it explore all bs chains
4038  * from the top. Some filters can choose not to pass down the recursion.
4039  */
4040 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4041 {
4042     BlockDriverState *bs;
4043
4044     /* walk down the bs forest recursively */
4045     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4046         bool perm;
4047
4048         /* try to recurse in this top level bs */
4049         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4050
4051         /* candidate is the first non filter */
4052         if (perm) {
4053             return true;
4054         }
4055     }
4056
4057     return false;
4058 }
4059
4060 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4061                                         const char *node_name, Error **errp)
4062 {
4063     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4064     AioContext *aio_context;
4065
4066     if (!to_replace_bs) {
4067         error_setg(errp, "Node name '%s' not found", node_name);
4068         return NULL;
4069     }
4070
4071     aio_context = bdrv_get_aio_context(to_replace_bs);
4072     aio_context_acquire(aio_context);
4073
4074     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4075         to_replace_bs = NULL;
4076         goto out;
4077     }
4078
4079     /* We don't want arbitrary node of the BDS chain to be replaced only the top
4080      * most non filter in order to prevent data corruption.
4081      * Another benefit is that this tests exclude backing files which are
4082      * blocked by the backing blockers.
4083      */
4084     if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4085         error_setg(errp, "Only top most non filter can be replaced");
4086         to_replace_bs = NULL;
4087         goto out;
4088     }
4089
4090 out:
4091     aio_context_release(aio_context);
4092     return to_replace_bs;
4093 }
4094
4095 static bool append_open_options(QDict *d, BlockDriverState *bs)
4096 {
4097     const QDictEntry *entry;
4098     bool found_any = false;
4099
4100     for (entry = qdict_first(bs->options); entry;
4101          entry = qdict_next(bs->options, entry))
4102     {
4103         /* Only take options for this level and exclude all non-driver-specific
4104          * options */
4105         if (!strchr(qdict_entry_key(entry), '.') &&
4106             strcmp(qdict_entry_key(entry), "node-name"))
4107         {
4108             qobject_incref(qdict_entry_value(entry));
4109             qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4110             found_any = true;
4111         }
4112     }
4113
4114     return found_any;
4115 }
4116
4117 /* Updates the following BDS fields:
4118  *  - exact_filename: A filename which may be used for opening a block device
4119  *                    which (mostly) equals the given BDS (even without any
4120  *                    other options; so reading and writing must return the same
4121  *                    results, but caching etc. may be different)
4122  *  - full_open_options: Options which, when given when opening a block device
4123  *                       (without a filename), result in a BDS (mostly)
4124  *                       equalling the given one
4125  *  - filename: If exact_filename is set, it is copied here. Otherwise,
4126  *              full_open_options is converted to a JSON object, prefixed with
4127  *              "json:" (for use through the JSON pseudo protocol) and put here.
4128  */
4129 void bdrv_refresh_filename(BlockDriverState *bs)
4130 {
4131     BlockDriver *drv = bs->drv;
4132     QDict *opts;
4133
4134     if (!drv) {
4135         return;
4136     }
4137
4138     /* This BDS's file name will most probably depend on its file's name, so
4139      * refresh that first */
4140     if (bs->file) {
4141         bdrv_refresh_filename(bs->file->bs);
4142     }
4143
4144     if (drv->bdrv_refresh_filename) {
4145         /* Obsolete information is of no use here, so drop the old file name
4146          * information before refreshing it */
4147         bs->exact_filename[0] = '\0';
4148         if (bs->full_open_options) {
4149             QDECREF(bs->full_open_options);
4150             bs->full_open_options = NULL;
4151         }
4152
4153         drv->bdrv_refresh_filename(bs);
4154     } else if (bs->file) {
4155         /* Try to reconstruct valid information from the underlying file */
4156         bool has_open_options;
4157
4158         bs->exact_filename[0] = '\0';
4159         if (bs->full_open_options) {
4160             QDECREF(bs->full_open_options);
4161             bs->full_open_options = NULL;
4162         }
4163
4164         opts = qdict_new();
4165         has_open_options = append_open_options(opts, bs);
4166
4167         /* If no specific options have been given for this BDS, the filename of
4168          * the underlying file should suffice for this one as well */
4169         if (bs->file->bs->exact_filename[0] && !has_open_options) {
4170             strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4171         }
4172         /* Reconstructing the full options QDict is simple for most format block
4173          * drivers, as long as the full options are known for the underlying
4174          * file BDS. The full options QDict of that file BDS should somehow
4175          * contain a representation of the filename, therefore the following
4176          * suffices without querying the (exact_)filename of this BDS. */
4177         if (bs->file->bs->full_open_options) {
4178             qdict_put_obj(opts, "driver",
4179                           QOBJECT(qstring_from_str(drv->format_name)));
4180             QINCREF(bs->file->bs->full_open_options);
4181             qdict_put_obj(opts, "file",
4182                           QOBJECT(bs->file->bs->full_open_options));
4183
4184             bs->full_open_options = opts;
4185         } else {
4186             QDECREF(opts);
4187         }
4188     } else if (!bs->full_open_options && qdict_size(bs->options)) {
4189         /* There is no underlying file BDS (at least referenced by BDS.file),
4190          * so the full options QDict should be equal to the options given
4191          * specifically for this block device when it was opened (plus the
4192          * driver specification).
4193          * Because those options don't change, there is no need to update
4194          * full_open_options when it's already set. */
4195
4196         opts = qdict_new();
4197         append_open_options(opts, bs);
4198         qdict_put_obj(opts, "driver",
4199                       QOBJECT(qstring_from_str(drv->format_name)));
4200
4201         if (bs->exact_filename[0]) {
4202             /* This may not work for all block protocol drivers (some may
4203              * require this filename to be parsed), but we have to find some
4204              * default solution here, so just include it. If some block driver
4205              * does not support pure options without any filename at all or
4206              * needs some special format of the options QDict, it needs to
4207              * implement the driver-specific bdrv_refresh_filename() function.
4208              */
4209             qdict_put_obj(opts, "filename",
4210                           QOBJECT(qstring_from_str(bs->exact_filename)));
4211         }
4212
4213         bs->full_open_options = opts;
4214     }
4215
4216     if (bs->exact_filename[0]) {
4217         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4218     } else if (bs->full_open_options) {
4219         QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4220         snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4221                  qstring_get_str(json));
4222         QDECREF(json);
4223     }
4224 }
4225
4226 /* This accessor function purpose is to allow the device models to access the
4227  * BlockAcctStats structure embedded inside a BlockDriverState without being
4228  * aware of the BlockDriverState structure layout.
4229  * It will go away when the BlockAcctStats structure will be moved inside
4230  * the device models.
4231  */
4232 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4233 {
4234     return &bs->stats;
4235 }