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