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 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1106 {
1107
1108     if (bs->backing_hd) {
1109         assert(bs->backing_blocker);
1110         bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1111     } else if (backing_hd) {
1112         error_setg(&bs->backing_blocker,
1113                    "node is used as backing hd of '%s'",
1114                    bdrv_get_device_or_node_name(bs));
1115     }
1116
1117     bs->backing_hd = backing_hd;
1118     if (!backing_hd) {
1119         error_free(bs->backing_blocker);
1120         bs->backing_blocker = NULL;
1121         goto out;
1122     }
1123     bs->open_flags &= ~BDRV_O_NO_BACKING;
1124     pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1125     pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1126             backing_hd->drv ? backing_hd->drv->format_name : "");
1127
1128     bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1129     /* Otherwise we won't be able to commit due to check in bdrv_commit */
1130     bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1131                     bs->backing_blocker);
1132 out:
1133     bdrv_refresh_limits(bs, NULL);
1134 }
1135
1136 /*
1137  * Opens the backing file for a BlockDriverState if not yet open
1138  *
1139  * options is a QDict of options to pass to the block drivers, or NULL for an
1140  * empty set of options. The reference to the QDict is transferred to this
1141  * function (even on failure), so if the caller intends to reuse the dictionary,
1142  * it needs to use QINCREF() before calling bdrv_file_open.
1143  */
1144 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1145 {
1146     char *backing_filename = g_malloc0(PATH_MAX);
1147     int ret = 0;
1148     BlockDriverState *backing_hd;
1149     Error *local_err = NULL;
1150
1151     if (bs->backing_hd != NULL) {
1152         QDECREF(options);
1153         goto free_exit;
1154     }
1155
1156     /* NULL means an empty set of options */
1157     if (options == NULL) {
1158         options = qdict_new();
1159     }
1160
1161     bs->open_flags &= ~BDRV_O_NO_BACKING;
1162     if (qdict_haskey(options, "file.filename")) {
1163         backing_filename[0] = '\0';
1164     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1165         QDECREF(options);
1166         goto free_exit;
1167     } else {
1168         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1169                                        &local_err);
1170         if (local_err) {
1171             ret = -EINVAL;
1172             error_propagate(errp, local_err);
1173             QDECREF(options);
1174             goto free_exit;
1175         }
1176     }
1177
1178     if (!bs->drv || !bs->drv->supports_backing) {
1179         ret = -EINVAL;
1180         error_setg(errp, "Driver doesn't support backing files");
1181         QDECREF(options);
1182         goto free_exit;
1183     }
1184
1185     backing_hd = bdrv_new();
1186
1187     if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1188         qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1189     }
1190
1191     assert(bs->backing_hd == NULL);
1192     ret = bdrv_open_inherit(&backing_hd,
1193                             *backing_filename ? backing_filename : NULL,
1194                             NULL, options, 0, bs, &child_backing,
1195                             NULL, &local_err);
1196     if (ret < 0) {
1197         bdrv_unref(backing_hd);
1198         backing_hd = NULL;
1199         bs->open_flags |= BDRV_O_NO_BACKING;
1200         error_setg(errp, "Could not open backing file: %s",
1201                    error_get_pretty(local_err));
1202         error_free(local_err);
1203         goto free_exit;
1204     }
1205     bdrv_set_backing_hd(bs, backing_hd);
1206
1207 free_exit:
1208     g_free(backing_filename);
1209     return ret;
1210 }
1211
1212 /*
1213  * Opens a disk image whose options are given as BlockdevRef in another block
1214  * device's options.
1215  *
1216  * If allow_none is true, no image will be opened if filename is false and no
1217  * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1218  *
1219  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1220  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1221  * itself, all options starting with "${bdref_key}." are considered part of the
1222  * BlockdevRef.
1223  *
1224  * The BlockdevRef will be removed from the options QDict.
1225  *
1226  * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1227  */
1228 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1229                     QDict *options, const char *bdref_key,
1230                     BlockDriverState* parent, const BdrvChildRole *child_role,
1231                     bool allow_none, Error **errp)
1232 {
1233     QDict *image_options;
1234     int ret;
1235     char *bdref_key_dot;
1236     const char *reference;
1237
1238     assert(pbs);
1239     assert(*pbs == NULL);
1240
1241     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1242     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1243     g_free(bdref_key_dot);
1244
1245     reference = qdict_get_try_str(options, bdref_key);
1246     if (!filename && !reference && !qdict_size(image_options)) {
1247         if (allow_none) {
1248             ret = 0;
1249         } else {
1250             error_setg(errp, "A block device must be specified for \"%s\"",
1251                        bdref_key);
1252             ret = -EINVAL;
1253         }
1254         QDECREF(image_options);
1255         goto done;
1256     }
1257
1258     ret = bdrv_open_inherit(pbs, filename, reference, image_options, 0,
1259                             parent, child_role, NULL, errp);
1260
1261 done:
1262     qdict_del(options, bdref_key);
1263     return ret;
1264 }
1265
1266 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1267 {
1268     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1269     char *tmp_filename = g_malloc0(PATH_MAX + 1);
1270     int64_t total_size;
1271     QemuOpts *opts = NULL;
1272     QDict *snapshot_options;
1273     BlockDriverState *bs_snapshot;
1274     Error *local_err = NULL;
1275     int ret;
1276
1277     /* if snapshot, we create a temporary backing file and open it
1278        instead of opening 'filename' directly */
1279
1280     /* Get the required size from the image */
1281     total_size = bdrv_getlength(bs);
1282     if (total_size < 0) {
1283         ret = total_size;
1284         error_setg_errno(errp, -total_size, "Could not get image size");
1285         goto out;
1286     }
1287
1288     /* Create the temporary image */
1289     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1290     if (ret < 0) {
1291         error_setg_errno(errp, -ret, "Could not get temporary filename");
1292         goto out;
1293     }
1294
1295     opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1296                             &error_abort);
1297     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1298     ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1299     qemu_opts_del(opts);
1300     if (ret < 0) {
1301         error_setg_errno(errp, -ret, "Could not create temporary overlay "
1302                          "'%s': %s", tmp_filename,
1303                          error_get_pretty(local_err));
1304         error_free(local_err);
1305         goto out;
1306     }
1307
1308     /* Prepare a new options QDict for the temporary file */
1309     snapshot_options = qdict_new();
1310     qdict_put(snapshot_options, "file.driver",
1311               qstring_from_str("file"));
1312     qdict_put(snapshot_options, "file.filename",
1313               qstring_from_str(tmp_filename));
1314
1315     bs_snapshot = bdrv_new();
1316
1317     ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1318                     flags, &bdrv_qcow2, &local_err);
1319     if (ret < 0) {
1320         error_propagate(errp, local_err);
1321         goto out;
1322     }
1323
1324     bdrv_append(bs_snapshot, bs);
1325
1326 out:
1327     g_free(tmp_filename);
1328     return ret;
1329 }
1330
1331 static void bdrv_attach_child(BlockDriverState *parent_bs,
1332                               BlockDriverState *child_bs,
1333                               const BdrvChildRole *child_role)
1334 {
1335     BdrvChild *child = g_new(BdrvChild, 1);
1336     *child = (BdrvChild) {
1337         .bs     = child_bs,
1338         .role   = child_role,
1339     };
1340
1341     QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1342 }
1343
1344 /*
1345  * Opens a disk image (raw, qcow2, vmdk, ...)
1346  *
1347  * options is a QDict of options to pass to the block drivers, or NULL for an
1348  * empty set of options. The reference to the QDict belongs to the block layer
1349  * after the call (even on failure), so if the caller intends to reuse the
1350  * dictionary, it needs to use QINCREF() before calling bdrv_open.
1351  *
1352  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1353  * If it is not NULL, the referenced BDS will be reused.
1354  *
1355  * The reference parameter may be used to specify an existing block device which
1356  * should be opened. If specified, neither options nor a filename may be given,
1357  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1358  */
1359 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1360                              const char *reference, QDict *options, int flags,
1361                              BlockDriverState *parent,
1362                              const BdrvChildRole *child_role,
1363                              BlockDriver *drv, Error **errp)
1364 {
1365     int ret;
1366     BlockDriverState *file = NULL, *bs;
1367     const char *drvname;
1368     Error *local_err = NULL;
1369     int snapshot_flags = 0;
1370
1371     assert(pbs);
1372     assert(!child_role || !flags);
1373     assert(!child_role == !parent);
1374
1375     if (reference) {
1376         bool options_non_empty = options ? qdict_size(options) : false;
1377         QDECREF(options);
1378
1379         if (*pbs) {
1380             error_setg(errp, "Cannot reuse an existing BDS when referencing "
1381                        "another block device");
1382             return -EINVAL;
1383         }
1384
1385         if (filename || options_non_empty) {
1386             error_setg(errp, "Cannot reference an existing block device with "
1387                        "additional options or a new filename");
1388             return -EINVAL;
1389         }
1390
1391         bs = bdrv_lookup_bs(reference, reference, errp);
1392         if (!bs) {
1393             return -ENODEV;
1394         }
1395         bdrv_ref(bs);
1396         if (child_role) {
1397             bdrv_attach_child(parent, bs, child_role);
1398         }
1399         *pbs = bs;
1400         return 0;
1401     }
1402
1403     if (*pbs) {
1404         bs = *pbs;
1405     } else {
1406         bs = bdrv_new();
1407     }
1408
1409     /* NULL means an empty set of options */
1410     if (options == NULL) {
1411         options = qdict_new();
1412     }
1413
1414     if (child_role) {
1415         bs->inherits_from = parent;
1416         flags = child_role->inherit_flags(parent->open_flags);
1417     }
1418
1419     ret = bdrv_fill_options(&options, &filename, &flags, drv, &local_err);
1420     if (local_err) {
1421         goto fail;
1422     }
1423
1424     /* Find the right image format driver */
1425     drv = NULL;
1426     drvname = qdict_get_try_str(options, "driver");
1427     if (drvname) {
1428         drv = bdrv_find_format(drvname);
1429         qdict_del(options, "driver");
1430         if (!drv) {
1431             error_setg(errp, "Unknown driver: '%s'", drvname);
1432             ret = -EINVAL;
1433             goto fail;
1434         }
1435     }
1436
1437     assert(drvname || !(flags & BDRV_O_PROTOCOL));
1438
1439     bs->open_flags = flags;
1440     bs->options = options;
1441     options = qdict_clone_shallow(options);
1442
1443     /* Open image file without format layer */
1444     if ((flags & BDRV_O_PROTOCOL) == 0) {
1445         if (flags & BDRV_O_RDWR) {
1446             flags |= BDRV_O_ALLOW_RDWR;
1447         }
1448         if (flags & BDRV_O_SNAPSHOT) {
1449             snapshot_flags = bdrv_temp_snapshot_flags(flags);
1450             flags = bdrv_backing_flags(flags);
1451         }
1452
1453         assert(file == NULL);
1454         bs->open_flags = flags;
1455         ret = bdrv_open_image(&file, filename, options, "file",
1456                               bs, &child_file, true, &local_err);
1457         if (ret < 0) {
1458             goto fail;
1459         }
1460     }
1461
1462     /* Image format probing */
1463     bs->probed = !drv;
1464     if (!drv && file) {
1465         ret = find_image_format(file, filename, &drv, &local_err);
1466         if (ret < 0) {
1467             goto fail;
1468         }
1469     } else if (!drv) {
1470         error_setg(errp, "Must specify either driver or file");
1471         ret = -EINVAL;
1472         goto fail;
1473     }
1474
1475     /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1476     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1477     /* file must be NULL if a protocol BDS is about to be created
1478      * (the inverse results in an error message from bdrv_open_common()) */
1479     assert(!(flags & BDRV_O_PROTOCOL) || !file);
1480
1481     /* Open the image */
1482     ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1483     if (ret < 0) {
1484         goto fail;
1485     }
1486
1487     if (file && (bs->file != file)) {
1488         bdrv_unref(file);
1489         file = NULL;
1490     }
1491
1492     /* If there is a backing file, use it */
1493     if ((flags & BDRV_O_NO_BACKING) == 0) {
1494         QDict *backing_options;
1495
1496         qdict_extract_subqdict(options, &backing_options, "backing.");
1497         ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1498         if (ret < 0) {
1499             goto close_and_fail;
1500         }
1501     }
1502
1503     bdrv_refresh_filename(bs);
1504
1505     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1506      * temporary snapshot afterwards. */
1507     if (snapshot_flags) {
1508         ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1509         if (local_err) {
1510             goto close_and_fail;
1511         }
1512     }
1513
1514     /* Check if any unknown options were used */
1515     if (options && (qdict_size(options) != 0)) {
1516         const QDictEntry *entry = qdict_first(options);
1517         if (flags & BDRV_O_PROTOCOL) {
1518             error_setg(errp, "Block protocol '%s' doesn't support the option "
1519                        "'%s'", drv->format_name, entry->key);
1520         } else {
1521             error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1522                        "support the option '%s'", drv->format_name,
1523                        bdrv_get_device_name(bs), entry->key);
1524         }
1525
1526         ret = -EINVAL;
1527         goto close_and_fail;
1528     }
1529
1530     if (!bdrv_key_required(bs)) {
1531         if (bs->blk) {
1532             blk_dev_change_media_cb(bs->blk, true);
1533         }
1534     } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1535                && !runstate_check(RUN_STATE_INMIGRATE)
1536                && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1537         error_setg(errp,
1538                    "Guest must be stopped for opening of encrypted image");
1539         ret = -EBUSY;
1540         goto close_and_fail;
1541     }
1542
1543     if (child_role) {
1544         bdrv_attach_child(parent, bs, child_role);
1545     }
1546
1547     QDECREF(options);
1548     *pbs = bs;
1549     return 0;
1550
1551 fail:
1552     if (file != NULL) {
1553         bdrv_unref(file);
1554     }
1555     QDECREF(bs->options);
1556     QDECREF(options);
1557     bs->options = NULL;
1558     if (!*pbs) {
1559         /* If *pbs is NULL, a new BDS has been created in this function and
1560            needs to be freed now. Otherwise, it does not need to be closed,
1561            since it has not really been opened yet. */
1562         bdrv_unref(bs);
1563     }
1564     if (local_err) {
1565         error_propagate(errp, local_err);
1566     }
1567     return ret;
1568
1569 close_and_fail:
1570     /* See fail path, but now the BDS has to be always closed */
1571     if (*pbs) {
1572         bdrv_close(bs);
1573     } else {
1574         bdrv_unref(bs);
1575     }
1576     QDECREF(options);
1577     if (local_err) {
1578         error_propagate(errp, local_err);
1579     }
1580     return ret;
1581 }
1582
1583 int bdrv_open(BlockDriverState **pbs, const char *filename,
1584               const char *reference, QDict *options, int flags,
1585               BlockDriver *drv, Error **errp)
1586 {
1587     return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1588                              NULL, drv, errp);
1589 }
1590
1591 typedef struct BlockReopenQueueEntry {
1592      bool prepared;
1593      BDRVReopenState state;
1594      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1595 } BlockReopenQueueEntry;
1596
1597 /*
1598  * Adds a BlockDriverState to a simple queue for an atomic, transactional
1599  * reopen of multiple devices.
1600  *
1601  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1602  * already performed, or alternatively may be NULL a new BlockReopenQueue will
1603  * be created and initialized. This newly created BlockReopenQueue should be
1604  * passed back in for subsequent calls that are intended to be of the same
1605  * atomic 'set'.
1606  *
1607  * bs is the BlockDriverState to add to the reopen queue.
1608  *
1609  * flags contains the open flags for the associated bs
1610  *
1611  * returns a pointer to bs_queue, which is either the newly allocated
1612  * bs_queue, or the existing bs_queue being used.
1613  *
1614  */
1615 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1616                                     BlockDriverState *bs, int flags)
1617 {
1618     assert(bs != NULL);
1619
1620     BlockReopenQueueEntry *bs_entry;
1621     BdrvChild *child;
1622
1623     if (bs_queue == NULL) {
1624         bs_queue = g_new0(BlockReopenQueue, 1);
1625         QSIMPLEQ_INIT(bs_queue);
1626     }
1627
1628     /* bdrv_open() masks this flag out */
1629     flags &= ~BDRV_O_PROTOCOL;
1630
1631     QLIST_FOREACH(child, &bs->children, next) {
1632         int child_flags;
1633
1634         if (child->bs->inherits_from != bs) {
1635             continue;
1636         }
1637
1638         child_flags = child->role->inherit_flags(flags);
1639         bdrv_reopen_queue(bs_queue, child->bs, child_flags);
1640     }
1641
1642     bs_entry = g_new0(BlockReopenQueueEntry, 1);
1643     QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1644
1645     bs_entry->state.bs = bs;
1646     bs_entry->state.flags = flags;
1647
1648     return bs_queue;
1649 }
1650
1651 /*
1652  * Reopen multiple BlockDriverStates atomically & transactionally.
1653  *
1654  * The queue passed in (bs_queue) must have been built up previous
1655  * via bdrv_reopen_queue().
1656  *
1657  * Reopens all BDS specified in the queue, with the appropriate
1658  * flags.  All devices are prepared for reopen, and failure of any
1659  * device will cause all device changes to be abandonded, and intermediate
1660  * data cleaned up.
1661  *
1662  * If all devices prepare successfully, then the changes are committed
1663  * to all devices.
1664  *
1665  */
1666 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1667 {
1668     int ret = -1;
1669     BlockReopenQueueEntry *bs_entry, *next;
1670     Error *local_err = NULL;
1671
1672     assert(bs_queue != NULL);
1673
1674     bdrv_drain_all();
1675
1676     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1677         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1678             error_propagate(errp, local_err);
1679             goto cleanup;
1680         }
1681         bs_entry->prepared = true;
1682     }
1683
1684     /* If we reach this point, we have success and just need to apply the
1685      * changes
1686      */
1687     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1688         bdrv_reopen_commit(&bs_entry->state);
1689     }
1690
1691     ret = 0;
1692
1693 cleanup:
1694     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1695         if (ret && bs_entry->prepared) {
1696             bdrv_reopen_abort(&bs_entry->state);
1697         }
1698         g_free(bs_entry);
1699     }
1700     g_free(bs_queue);
1701     return ret;
1702 }
1703
1704
1705 /* Reopen a single BlockDriverState with the specified flags. */
1706 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1707 {
1708     int ret = -1;
1709     Error *local_err = NULL;
1710     BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1711
1712     ret = bdrv_reopen_multiple(queue, &local_err);
1713     if (local_err != NULL) {
1714         error_propagate(errp, local_err);
1715     }
1716     return ret;
1717 }
1718
1719
1720 /*
1721  * Prepares a BlockDriverState for reopen. All changes are staged in the
1722  * 'opaque' field of the BDRVReopenState, which is used and allocated by
1723  * the block driver layer .bdrv_reopen_prepare()
1724  *
1725  * bs is the BlockDriverState to reopen
1726  * flags are the new open flags
1727  * queue is the reopen queue
1728  *
1729  * Returns 0 on success, non-zero on error.  On error errp will be set
1730  * as well.
1731  *
1732  * On failure, bdrv_reopen_abort() will be called to clean up any data.
1733  * It is the responsibility of the caller to then call the abort() or
1734  * commit() for any other BDS that have been left in a prepare() state
1735  *
1736  */
1737 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1738                         Error **errp)
1739 {
1740     int ret = -1;
1741     Error *local_err = NULL;
1742     BlockDriver *drv;
1743
1744     assert(reopen_state != NULL);
1745     assert(reopen_state->bs->drv != NULL);
1746     drv = reopen_state->bs->drv;
1747
1748     /* if we are to stay read-only, do not allow permission change
1749      * to r/w */
1750     if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1751         reopen_state->flags & BDRV_O_RDWR) {
1752         error_setg(errp, "Node '%s' is read only",
1753                    bdrv_get_device_or_node_name(reopen_state->bs));
1754         goto error;
1755     }
1756
1757
1758     ret = bdrv_flush(reopen_state->bs);
1759     if (ret) {
1760         error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1761                   strerror(-ret));
1762         goto error;
1763     }
1764
1765     if (drv->bdrv_reopen_prepare) {
1766         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1767         if (ret) {
1768             if (local_err != NULL) {
1769                 error_propagate(errp, local_err);
1770             } else {
1771                 error_setg(errp, "failed while preparing to reopen image '%s'",
1772                            reopen_state->bs->filename);
1773             }
1774             goto error;
1775         }
1776     } else {
1777         /* It is currently mandatory to have a bdrv_reopen_prepare()
1778          * handler for each supported drv. */
1779         error_setg(errp, "Block format '%s' used by node '%s' "
1780                    "does not support reopening files", drv->format_name,
1781                    bdrv_get_device_or_node_name(reopen_state->bs));
1782         ret = -1;
1783         goto error;
1784     }
1785
1786     ret = 0;
1787
1788 error:
1789     return ret;
1790 }
1791
1792 /*
1793  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1794  * makes them final by swapping the staging BlockDriverState contents into
1795  * the active BlockDriverState contents.
1796  */
1797 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1798 {
1799     BlockDriver *drv;
1800
1801     assert(reopen_state != NULL);
1802     drv = reopen_state->bs->drv;
1803     assert(drv != NULL);
1804
1805     /* If there are any driver level actions to take */
1806     if (drv->bdrv_reopen_commit) {
1807         drv->bdrv_reopen_commit(reopen_state);
1808     }
1809
1810     /* set BDS specific flags now */
1811     reopen_state->bs->open_flags         = reopen_state->flags;
1812     reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1813                                               BDRV_O_CACHE_WB);
1814     reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1815
1816     bdrv_refresh_limits(reopen_state->bs, NULL);
1817 }
1818
1819 /*
1820  * Abort the reopen, and delete and free the staged changes in
1821  * reopen_state
1822  */
1823 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1824 {
1825     BlockDriver *drv;
1826
1827     assert(reopen_state != NULL);
1828     drv = reopen_state->bs->drv;
1829     assert(drv != NULL);
1830
1831     if (drv->bdrv_reopen_abort) {
1832         drv->bdrv_reopen_abort(reopen_state);
1833     }
1834 }
1835
1836
1837 void bdrv_close(BlockDriverState *bs)
1838 {
1839     BdrvAioNotifier *ban, *ban_next;
1840
1841     if (bs->job) {
1842         block_job_cancel_sync(bs->job);
1843     }
1844     bdrv_drain(bs); /* complete I/O */
1845     bdrv_flush(bs);
1846     bdrv_drain(bs); /* in case flush left pending I/O */
1847     notifier_list_notify(&bs->close_notifiers, bs);
1848
1849     if (bs->drv) {
1850         BdrvChild *child, *next;
1851
1852         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1853             if (child->bs->inherits_from == bs) {
1854                 child->bs->inherits_from = NULL;
1855             }
1856             QLIST_REMOVE(child, next);
1857             g_free(child);
1858         }
1859
1860         if (bs->backing_hd) {
1861             BlockDriverState *backing_hd = bs->backing_hd;
1862             bdrv_set_backing_hd(bs, NULL);
1863             bdrv_unref(backing_hd);
1864         }
1865         bs->drv->bdrv_close(bs);
1866         g_free(bs->opaque);
1867         bs->opaque = NULL;
1868         bs->drv = NULL;
1869         bs->copy_on_read = 0;
1870         bs->backing_file[0] = '\0';
1871         bs->backing_format[0] = '\0';
1872         bs->total_sectors = 0;
1873         bs->encrypted = 0;
1874         bs->valid_key = 0;
1875         bs->sg = 0;
1876         bs->zero_beyond_eof = false;
1877         QDECREF(bs->options);
1878         bs->options = NULL;
1879         QDECREF(bs->full_open_options);
1880         bs->full_open_options = NULL;
1881
1882         if (bs->file != NULL) {
1883             bdrv_unref(bs->file);
1884             bs->file = NULL;
1885         }
1886     }
1887
1888     if (bs->blk) {
1889         blk_dev_change_media_cb(bs->blk, false);
1890     }
1891
1892     /*throttling disk I/O limits*/
1893     if (bs->io_limits_enabled) {
1894         bdrv_io_limits_disable(bs);
1895     }
1896
1897     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1898         g_free(ban);
1899     }
1900     QLIST_INIT(&bs->aio_notifiers);
1901 }
1902
1903 void bdrv_close_all(void)
1904 {
1905     BlockDriverState *bs;
1906
1907     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1908         AioContext *aio_context = bdrv_get_aio_context(bs);
1909
1910         aio_context_acquire(aio_context);
1911         bdrv_close(bs);
1912         aio_context_release(aio_context);
1913     }
1914 }
1915
1916 /* make a BlockDriverState anonymous by removing from bdrv_state and
1917  * graph_bdrv_state list.
1918    Also, NULL terminate the device_name to prevent double remove */
1919 void bdrv_make_anon(BlockDriverState *bs)
1920 {
1921     /*
1922      * Take care to remove bs from bdrv_states only when it's actually
1923      * in it.  Note that bs->device_list.tqe_prev is initially null,
1924      * and gets set to non-null by QTAILQ_INSERT_TAIL().  Establish
1925      * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1926      * resetting it to null on remove.
1927      */
1928     if (bs->device_list.tqe_prev) {
1929         QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1930         bs->device_list.tqe_prev = NULL;
1931     }
1932     if (bs->node_name[0] != '\0') {
1933         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1934     }
1935     bs->node_name[0] = '\0';
1936 }
1937
1938 static void bdrv_rebind(BlockDriverState *bs)
1939 {
1940     if (bs->drv && bs->drv->bdrv_rebind) {
1941         bs->drv->bdrv_rebind(bs);
1942     }
1943 }
1944
1945 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1946                                      BlockDriverState *bs_src)
1947 {
1948     /* move some fields that need to stay attached to the device */
1949
1950     /* dev info */
1951     bs_dest->guest_block_size   = bs_src->guest_block_size;
1952     bs_dest->copy_on_read       = bs_src->copy_on_read;
1953
1954     bs_dest->enable_write_cache = bs_src->enable_write_cache;
1955
1956     /* i/o throttled req */
1957     bs_dest->throttle_state     = bs_src->throttle_state,
1958     bs_dest->io_limits_enabled  = bs_src->io_limits_enabled;
1959     bs_dest->pending_reqs[0]    = bs_src->pending_reqs[0];
1960     bs_dest->pending_reqs[1]    = bs_src->pending_reqs[1];
1961     bs_dest->throttled_reqs[0]  = bs_src->throttled_reqs[0];
1962     bs_dest->throttled_reqs[1]  = bs_src->throttled_reqs[1];
1963     memcpy(&bs_dest->round_robin,
1964            &bs_src->round_robin,
1965            sizeof(bs_dest->round_robin));
1966     memcpy(&bs_dest->throttle_timers,
1967            &bs_src->throttle_timers,
1968            sizeof(ThrottleTimers));
1969
1970     /* r/w error */
1971     bs_dest->on_read_error      = bs_src->on_read_error;
1972     bs_dest->on_write_error     = bs_src->on_write_error;
1973
1974     /* i/o status */
1975     bs_dest->iostatus_enabled   = bs_src->iostatus_enabled;
1976     bs_dest->iostatus           = bs_src->iostatus;
1977
1978     /* dirty bitmap */
1979     bs_dest->dirty_bitmaps      = bs_src->dirty_bitmaps;
1980
1981     /* reference count */
1982     bs_dest->refcnt             = bs_src->refcnt;
1983
1984     /* job */
1985     bs_dest->job                = bs_src->job;
1986
1987     /* keep the same entry in bdrv_states */
1988     bs_dest->device_list = bs_src->device_list;
1989     bs_dest->blk = bs_src->blk;
1990
1991     memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1992            sizeof(bs_dest->op_blockers));
1993 }
1994
1995 /*
1996  * Swap bs contents for two image chains while they are live,
1997  * while keeping required fields on the BlockDriverState that is
1998  * actually attached to a device.
1999  *
2000  * This will modify the BlockDriverState fields, and swap contents
2001  * between bs_new and bs_old. Both bs_new and bs_old are modified.
2002  *
2003  * bs_new must not be attached to a BlockBackend.
2004  *
2005  * This function does not create any image files.
2006  */
2007 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2008 {
2009     BlockDriverState tmp;
2010     BdrvChild *child;
2011
2012     bdrv_drain(bs_new);
2013     bdrv_drain(bs_old);
2014
2015     /* The code needs to swap the node_name but simply swapping node_list won't
2016      * work so first remove the nodes from the graph list, do the swap then
2017      * insert them back if needed.
2018      */
2019     if (bs_new->node_name[0] != '\0') {
2020         QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2021     }
2022     if (bs_old->node_name[0] != '\0') {
2023         QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2024     }
2025
2026     /* If the BlockDriverState is part of a throttling group acquire
2027      * its lock since we're going to mess with the protected fields.
2028      * Otherwise there's no need to worry since no one else can touch
2029      * them. */
2030     if (bs_old->throttle_state) {
2031         throttle_group_lock(bs_old);
2032     }
2033
2034     /* bs_new must be unattached and shouldn't have anything fancy enabled */
2035     assert(!bs_new->blk);
2036     assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2037     assert(bs_new->job == NULL);
2038     assert(bs_new->io_limits_enabled == false);
2039     assert(bs_new->throttle_state == NULL);
2040     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2041
2042     tmp = *bs_new;
2043     *bs_new = *bs_old;
2044     *bs_old = tmp;
2045
2046     /* there are some fields that should not be swapped, move them back */
2047     bdrv_move_feature_fields(&tmp, bs_old);
2048     bdrv_move_feature_fields(bs_old, bs_new);
2049     bdrv_move_feature_fields(bs_new, &tmp);
2050
2051     /* bs_new must remain unattached */
2052     assert(!bs_new->blk);
2053
2054     /* Check a few fields that should remain attached to the device */
2055     assert(bs_new->job == NULL);
2056     assert(bs_new->io_limits_enabled == false);
2057     assert(bs_new->throttle_state == NULL);
2058     assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2059
2060     /* Release the ThrottleGroup lock */
2061     if (bs_old->throttle_state) {
2062         throttle_group_unlock(bs_old);
2063     }
2064
2065     /* insert the nodes back into the graph node list if needed */
2066     if (bs_new->node_name[0] != '\0') {
2067         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2068     }
2069     if (bs_old->node_name[0] != '\0') {
2070         QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2071     }
2072
2073     /*
2074      * Update lh_first.le_prev for non-empty lists.
2075      *
2076      * The head of the op blocker list doesn't change because it is moved back
2077      * in bdrv_move_feature_fields().
2078      */
2079     assert(QLIST_EMPTY(&bs_old->tracked_requests));
2080     assert(QLIST_EMPTY(&bs_new->tracked_requests));
2081
2082     QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2083     QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2084
2085     /* Update references in bs->opaque and children */
2086     QLIST_FOREACH(child, &bs_old->children, next) {
2087         if (child->bs->inherits_from == bs_new) {
2088             child->bs->inherits_from = bs_old;
2089         }
2090     }
2091     QLIST_FOREACH(child, &bs_new->children, next) {
2092         if (child->bs->inherits_from == bs_old) {
2093             child->bs->inherits_from = bs_new;
2094         }
2095     }
2096
2097     bdrv_rebind(bs_new);
2098     bdrv_rebind(bs_old);
2099 }
2100
2101 /*
2102  * Add new bs contents at the top of an image chain while the chain is
2103  * live, while keeping required fields on the top layer.
2104  *
2105  * This will modify the BlockDriverState fields, and swap contents
2106  * between bs_new and bs_top. Both bs_new and bs_top are modified.
2107  *
2108  * bs_new must not be attached to a BlockBackend.
2109  *
2110  * This function does not create any image files.
2111  */
2112 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2113 {
2114     bdrv_swap(bs_new, bs_top);
2115
2116     /* The contents of 'tmp' will become bs_top, as we are
2117      * swapping bs_new and bs_top contents. */
2118     bdrv_set_backing_hd(bs_top, bs_new);
2119     bdrv_attach_child(bs_top, bs_new, &child_backing);
2120 }
2121
2122 static void bdrv_delete(BlockDriverState *bs)
2123 {
2124     assert(!bs->job);
2125     assert(bdrv_op_blocker_is_empty(bs));
2126     assert(!bs->refcnt);
2127     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2128
2129     bdrv_close(bs);
2130
2131     /* remove from list, if necessary */
2132     bdrv_make_anon(bs);
2133
2134     g_free(bs);
2135 }
2136
2137 /*
2138  * Run consistency checks on an image
2139  *
2140  * Returns 0 if the check could be completed (it doesn't mean that the image is
2141  * free of errors) or -errno when an internal error occurred. The results of the
2142  * check are stored in res.
2143  */
2144 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2145 {
2146     if (bs->drv == NULL) {
2147         return -ENOMEDIUM;
2148     }
2149     if (bs->drv->bdrv_check == NULL) {
2150         return -ENOTSUP;
2151     }
2152
2153     memset(res, 0, sizeof(*res));
2154     return bs->drv->bdrv_check(bs, res, fix);
2155 }
2156
2157 #define COMMIT_BUF_SECTORS 2048
2158
2159 /* commit COW file into the raw image */
2160 int bdrv_commit(BlockDriverState *bs)
2161 {
2162     BlockDriver *drv = bs->drv;
2163     int64_t sector, total_sectors, length, backing_length;
2164     int n, ro, open_flags;
2165     int ret = 0;
2166     uint8_t *buf = NULL;
2167
2168     if (!drv)
2169         return -ENOMEDIUM;
2170
2171     if (!bs->backing_hd) {
2172         return -ENOTSUP;
2173     }
2174
2175     if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2176         bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2177         return -EBUSY;
2178     }
2179
2180     ro = bs->backing_hd->read_only;
2181     open_flags =  bs->backing_hd->open_flags;
2182
2183     if (ro) {
2184         if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2185             return -EACCES;
2186         }
2187     }
2188
2189     length = bdrv_getlength(bs);
2190     if (length < 0) {
2191         ret = length;
2192         goto ro_cleanup;
2193     }
2194
2195     backing_length = bdrv_getlength(bs->backing_hd);
2196     if (backing_length < 0) {
2197         ret = backing_length;
2198         goto ro_cleanup;
2199     }
2200
2201     /* If our top snapshot is larger than the backing file image,
2202      * grow the backing file image if possible.  If not possible,
2203      * we must return an error */
2204     if (length > backing_length) {
2205         ret = bdrv_truncate(bs->backing_hd, length);
2206         if (ret < 0) {
2207             goto ro_cleanup;
2208         }
2209     }
2210
2211     total_sectors = length >> BDRV_SECTOR_BITS;
2212
2213     /* qemu_try_blockalign() for bs will choose an alignment that works for
2214      * bs->backing_hd as well, so no need to compare the alignment manually. */
2215     buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2216     if (buf == NULL) {
2217         ret = -ENOMEM;
2218         goto ro_cleanup;
2219     }
2220
2221     for (sector = 0; sector < total_sectors; sector += n) {
2222         ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2223         if (ret < 0) {
2224             goto ro_cleanup;
2225         }
2226         if (ret) {
2227             ret = bdrv_read(bs, sector, buf, n);
2228             if (ret < 0) {
2229                 goto ro_cleanup;
2230             }
2231
2232             ret = bdrv_write(bs->backing_hd, sector, buf, n);
2233             if (ret < 0) {
2234                 goto ro_cleanup;
2235             }
2236         }
2237     }
2238
2239     if (drv->bdrv_make_empty) {
2240         ret = drv->bdrv_make_empty(bs);
2241         if (ret < 0) {
2242             goto ro_cleanup;
2243         }
2244         bdrv_flush(bs);
2245     }
2246
2247     /*
2248      * Make sure all data we wrote to the backing device is actually
2249      * stable on disk.
2250      */
2251     if (bs->backing_hd) {
2252         bdrv_flush(bs->backing_hd);
2253     }
2254
2255     ret = 0;
2256 ro_cleanup:
2257     qemu_vfree(buf);
2258
2259     if (ro) {
2260         /* ignoring error return here */
2261         bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2262     }
2263
2264     return ret;
2265 }
2266
2267 int bdrv_commit_all(void)
2268 {
2269     BlockDriverState *bs;
2270
2271     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2272         AioContext *aio_context = bdrv_get_aio_context(bs);
2273
2274         aio_context_acquire(aio_context);
2275         if (bs->drv && bs->backing_hd) {
2276             int ret = bdrv_commit(bs);
2277             if (ret < 0) {
2278                 aio_context_release(aio_context);
2279                 return ret;
2280             }
2281         }
2282         aio_context_release(aio_context);
2283     }
2284     return 0;
2285 }
2286
2287 /*
2288  * Return values:
2289  * 0        - success
2290  * -EINVAL  - backing format specified, but no file
2291  * -ENOSPC  - can't update the backing file because no space is left in the
2292  *            image file header
2293  * -ENOTSUP - format driver doesn't support changing the backing file
2294  */
2295 int bdrv_change_backing_file(BlockDriverState *bs,
2296     const char *backing_file, const char *backing_fmt)
2297 {
2298     BlockDriver *drv = bs->drv;
2299     int ret;
2300
2301     /* Backing file format doesn't make sense without a backing file */
2302     if (backing_fmt && !backing_file) {
2303         return -EINVAL;
2304     }
2305
2306     if (drv->bdrv_change_backing_file != NULL) {
2307         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2308     } else {
2309         ret = -ENOTSUP;
2310     }
2311
2312     if (ret == 0) {
2313         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2314         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2315     }
2316     return ret;
2317 }
2318
2319 /*
2320  * Finds the image layer in the chain that has 'bs' as its backing file.
2321  *
2322  * active is the current topmost image.
2323  *
2324  * Returns NULL if bs is not found in active's image chain,
2325  * or if active == bs.
2326  *
2327  * Returns the bottommost base image if bs == NULL.
2328  */
2329 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2330                                     BlockDriverState *bs)
2331 {
2332     while (active && bs != active->backing_hd) {
2333         active = active->backing_hd;
2334     }
2335
2336     return active;
2337 }
2338
2339 /* Given a BDS, searches for the base layer. */
2340 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2341 {
2342     return bdrv_find_overlay(bs, NULL);
2343 }
2344
2345 typedef struct BlkIntermediateStates {
2346     BlockDriverState *bs;
2347     QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2348 } BlkIntermediateStates;
2349
2350
2351 /*
2352  * Drops images above 'base' up to and including 'top', and sets the image
2353  * above 'top' to have base as its backing file.
2354  *
2355  * Requires that the overlay to 'top' is opened r/w, so that the backing file
2356  * information in 'bs' can be properly updated.
2357  *
2358  * E.g., this will convert the following chain:
2359  * bottom <- base <- intermediate <- top <- active
2360  *
2361  * to
2362  *
2363  * bottom <- base <- active
2364  *
2365  * It is allowed for bottom==base, in which case it converts:
2366  *
2367  * base <- intermediate <- top <- active
2368  *
2369  * to
2370  *
2371  * base <- active
2372  *
2373  * If backing_file_str is non-NULL, it will be used when modifying top's
2374  * overlay image metadata.
2375  *
2376  * Error conditions:
2377  *  if active == top, that is considered an error
2378  *
2379  */
2380 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2381                            BlockDriverState *base, const char *backing_file_str)
2382 {
2383     BlockDriverState *intermediate;
2384     BlockDriverState *base_bs = NULL;
2385     BlockDriverState *new_top_bs = NULL;
2386     BlkIntermediateStates *intermediate_state, *next;
2387     int ret = -EIO;
2388
2389     QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2390     QSIMPLEQ_INIT(&states_to_delete);
2391
2392     if (!top->drv || !base->drv) {
2393         goto exit;
2394     }
2395
2396     new_top_bs = bdrv_find_overlay(active, top);
2397
2398     if (new_top_bs == NULL) {
2399         /* we could not find the image above 'top', this is an error */
2400         goto exit;
2401     }
2402
2403     /* special case of new_top_bs->backing_hd already pointing to base - nothing
2404      * to do, no intermediate images */
2405     if (new_top_bs->backing_hd == base) {
2406         ret = 0;
2407         goto exit;
2408     }
2409
2410     intermediate = top;
2411
2412     /* now we will go down through the list, and add each BDS we find
2413      * into our deletion queue, until we hit the 'base'
2414      */
2415     while (intermediate) {
2416         intermediate_state = g_new0(BlkIntermediateStates, 1);
2417         intermediate_state->bs = intermediate;
2418         QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2419
2420         if (intermediate->backing_hd == base) {
2421             base_bs = intermediate->backing_hd;
2422             break;
2423         }
2424         intermediate = intermediate->backing_hd;
2425     }
2426     if (base_bs == NULL) {
2427         /* something went wrong, we did not end at the base. safely
2428          * unravel everything, and exit with error */
2429         goto exit;
2430     }
2431
2432     /* success - we can delete the intermediate states, and link top->base */
2433     backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2434     ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2435                                    base_bs->drv ? base_bs->drv->format_name : "");
2436     if (ret) {
2437         goto exit;
2438     }
2439     bdrv_set_backing_hd(new_top_bs, base_bs);
2440
2441     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2442         /* so that bdrv_close() does not recursively close the chain */
2443         bdrv_set_backing_hd(intermediate_state->bs, NULL);
2444         bdrv_unref(intermediate_state->bs);
2445     }
2446     ret = 0;
2447
2448 exit:
2449     QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2450         g_free(intermediate_state);
2451     }
2452     return ret;
2453 }
2454
2455 /**
2456  * Truncate file to 'offset' bytes (needed only for file protocols)
2457  */
2458 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2459 {
2460     BlockDriver *drv = bs->drv;
2461     int ret;
2462     if (!drv)
2463         return -ENOMEDIUM;
2464     if (!drv->bdrv_truncate)
2465         return -ENOTSUP;
2466     if (bs->read_only)
2467         return -EACCES;
2468
2469     ret = drv->bdrv_truncate(bs, offset);
2470     if (ret == 0) {
2471         ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2472         bdrv_dirty_bitmap_truncate(bs);
2473         if (bs->blk) {
2474             blk_dev_resize_cb(bs->blk);
2475         }
2476     }
2477     return ret;
2478 }
2479
2480 /**
2481  * Length of a allocated file in bytes. Sparse files are counted by actual
2482  * allocated space. Return < 0 if error or unknown.
2483  */
2484 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2485 {
2486     BlockDriver *drv = bs->drv;
2487     if (!drv) {
2488         return -ENOMEDIUM;
2489     }
2490     if (drv->bdrv_get_allocated_file_size) {
2491         return drv->bdrv_get_allocated_file_size(bs);
2492     }
2493     if (bs->file) {
2494         return bdrv_get_allocated_file_size(bs->file);
2495     }
2496     return -ENOTSUP;
2497 }
2498
2499 /**
2500  * Return number of sectors on success, -errno on error.
2501  */
2502 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2503 {
2504     BlockDriver *drv = bs->drv;
2505
2506     if (!drv)
2507         return -ENOMEDIUM;
2508
2509     if (drv->has_variable_length) {
2510         int ret = refresh_total_sectors(bs, bs->total_sectors);
2511         if (ret < 0) {
2512             return ret;
2513         }
2514     }
2515     return bs->total_sectors;
2516 }
2517
2518 /**
2519  * Return length in bytes on success, -errno on error.
2520  * The length is always a multiple of BDRV_SECTOR_SIZE.
2521  */
2522 int64_t bdrv_getlength(BlockDriverState *bs)
2523 {
2524     int64_t ret = bdrv_nb_sectors(bs);
2525
2526     ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2527     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2528 }
2529
2530 /* return 0 as number of sectors if no device present or error */
2531 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2532 {
2533     int64_t nb_sectors = bdrv_nb_sectors(bs);
2534
2535     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2536 }
2537
2538 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2539                        BlockdevOnError on_write_error)
2540 {
2541     bs->on_read_error = on_read_error;
2542     bs->on_write_error = on_write_error;
2543 }
2544
2545 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2546 {
2547     return is_read ? bs->on_read_error : bs->on_write_error;
2548 }
2549
2550 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2551 {
2552     BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2553
2554     switch (on_err) {
2555     case BLOCKDEV_ON_ERROR_ENOSPC:
2556         return (error == ENOSPC) ?
2557                BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2558     case BLOCKDEV_ON_ERROR_STOP:
2559         return BLOCK_ERROR_ACTION_STOP;
2560     case BLOCKDEV_ON_ERROR_REPORT:
2561         return BLOCK_ERROR_ACTION_REPORT;
2562     case BLOCKDEV_ON_ERROR_IGNORE:
2563         return BLOCK_ERROR_ACTION_IGNORE;
2564     default:
2565         abort();
2566     }
2567 }
2568
2569 static void send_qmp_error_event(BlockDriverState *bs,
2570                                  BlockErrorAction action,
2571                                  bool is_read, int error)
2572 {
2573     IoOperationType optype;
2574
2575     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2576     qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2577                                    bdrv_iostatus_is_enabled(bs),
2578                                    error == ENOSPC, strerror(error),
2579                                    &error_abort);
2580 }
2581
2582 /* This is done by device models because, while the block layer knows
2583  * about the error, it does not know whether an operation comes from
2584  * the device or the block layer (from a job, for example).
2585  */
2586 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2587                        bool is_read, int error)
2588 {
2589     assert(error >= 0);
2590
2591     if (action == BLOCK_ERROR_ACTION_STOP) {
2592         /* First set the iostatus, so that "info block" returns an iostatus
2593          * that matches the events raised so far (an additional error iostatus
2594          * is fine, but not a lost one).
2595          */
2596         bdrv_iostatus_set_err(bs, error);
2597
2598         /* Then raise the request to stop the VM and the event.
2599          * qemu_system_vmstop_request_prepare has two effects.  First,
2600          * it ensures that the STOP event always comes after the
2601          * BLOCK_IO_ERROR event.  Second, it ensures that even if management
2602          * can observe the STOP event and do a "cont" before the STOP
2603          * event is issued, the VM will not stop.  In this case, vm_start()
2604          * also ensures that the STOP/RESUME pair of events is emitted.
2605          */
2606         qemu_system_vmstop_request_prepare();
2607         send_qmp_error_event(bs, action, is_read, error);
2608         qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2609     } else {
2610         send_qmp_error_event(bs, action, is_read, error);
2611     }
2612 }
2613
2614 int bdrv_is_read_only(BlockDriverState *bs)
2615 {
2616     return bs->read_only;
2617 }
2618
2619 int bdrv_is_sg(BlockDriverState *bs)
2620 {
2621     return bs->sg;
2622 }
2623
2624 int bdrv_enable_write_cache(BlockDriverState *bs)
2625 {
2626     return bs->enable_write_cache;
2627 }
2628
2629 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2630 {
2631     bs->enable_write_cache = wce;
2632
2633     /* so a reopen() will preserve wce */
2634     if (wce) {
2635         bs->open_flags |= BDRV_O_CACHE_WB;
2636     } else {
2637         bs->open_flags &= ~BDRV_O_CACHE_WB;
2638     }
2639 }
2640
2641 int bdrv_is_encrypted(BlockDriverState *bs)
2642 {
2643     if (bs->backing_hd && bs->backing_hd->encrypted)
2644         return 1;
2645     return bs->encrypted;
2646 }
2647
2648 int bdrv_key_required(BlockDriverState *bs)
2649 {
2650     BlockDriverState *backing_hd = bs->backing_hd;
2651
2652     if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2653         return 1;
2654     return (bs->encrypted && !bs->valid_key);
2655 }
2656
2657 int bdrv_set_key(BlockDriverState *bs, const char *key)
2658 {
2659     int ret;
2660     if (bs->backing_hd && bs->backing_hd->encrypted) {
2661         ret = bdrv_set_key(bs->backing_hd, key);
2662         if (ret < 0)
2663             return ret;
2664         if (!bs->encrypted)
2665             return 0;
2666     }
2667     if (!bs->encrypted) {
2668         return -EINVAL;
2669     } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2670         return -ENOMEDIUM;
2671     }
2672     ret = bs->drv->bdrv_set_key(bs, key);
2673     if (ret < 0) {
2674         bs->valid_key = 0;
2675     } else if (!bs->valid_key) {
2676         bs->valid_key = 1;
2677         if (bs->blk) {
2678             /* call the change callback now, we skipped it on open */
2679             blk_dev_change_media_cb(bs->blk, true);
2680         }
2681     }
2682     return ret;
2683 }
2684
2685 /*
2686  * Provide an encryption key for @bs.
2687  * If @key is non-null:
2688  *     If @bs is not encrypted, fail.
2689  *     Else if the key is invalid, fail.
2690  *     Else set @bs's key to @key, replacing the existing key, if any.
2691  * If @key is null:
2692  *     If @bs is encrypted and still lacks a key, fail.
2693  *     Else do nothing.
2694  * On failure, store an error object through @errp if non-null.
2695  */
2696 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2697 {
2698     if (key) {
2699         if (!bdrv_is_encrypted(bs)) {
2700             error_setg(errp, "Node '%s' is not encrypted",
2701                       bdrv_get_device_or_node_name(bs));
2702         } else if (bdrv_set_key(bs, key) < 0) {
2703             error_setg(errp, QERR_INVALID_PASSWORD);
2704         }
2705     } else {
2706         if (bdrv_key_required(bs)) {
2707             error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2708                       "'%s' (%s) is encrypted",
2709                       bdrv_get_device_or_node_name(bs),
2710                       bdrv_get_encrypted_filename(bs));
2711         }
2712     }
2713 }
2714
2715 const char *bdrv_get_format_name(BlockDriverState *bs)
2716 {
2717     return bs->drv ? bs->drv->format_name : NULL;
2718 }
2719
2720 static int qsort_strcmp(const void *a, const void *b)
2721 {
2722     return strcmp(a, b);
2723 }
2724
2725 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2726                          void *opaque)
2727 {
2728     BlockDriver *drv;
2729     int count = 0;
2730     int i;
2731     const char **formats = NULL;
2732
2733     QLIST_FOREACH(drv, &bdrv_drivers, list) {
2734         if (drv->format_name) {
2735             bool found = false;
2736             int i = count;
2737             while (formats && i && !found) {
2738                 found = !strcmp(formats[--i], drv->format_name);
2739             }
2740
2741             if (!found) {
2742                 formats = g_renew(const char *, formats, count + 1);
2743                 formats[count++] = drv->format_name;
2744             }
2745         }
2746     }
2747
2748     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2749
2750     for (i = 0; i < count; i++) {
2751         it(opaque, formats[i]);
2752     }
2753
2754     g_free(formats);
2755 }
2756
2757 /* This function is to find a node in the bs graph */
2758 BlockDriverState *bdrv_find_node(const char *node_name)
2759 {
2760     BlockDriverState *bs;
2761
2762     assert(node_name);
2763
2764     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2765         if (!strcmp(node_name, bs->node_name)) {
2766             return bs;
2767         }
2768     }
2769     return NULL;
2770 }
2771
2772 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2773 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2774 {
2775     BlockDeviceInfoList *list, *entry;
2776     BlockDriverState *bs;
2777
2778     list = NULL;
2779     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2780         BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2781         if (!info) {
2782             qapi_free_BlockDeviceInfoList(list);
2783             return NULL;
2784         }
2785         entry = g_malloc0(sizeof(*entry));
2786         entry->value = info;
2787         entry->next = list;
2788         list = entry;
2789     }
2790
2791     return list;
2792 }
2793
2794 BlockDriverState *bdrv_lookup_bs(const char *device,
2795                                  const char *node_name,
2796                                  Error **errp)
2797 {
2798     BlockBackend *blk;
2799     BlockDriverState *bs;
2800
2801     if (device) {
2802         blk = blk_by_name(device);
2803
2804         if (blk) {
2805             return blk_bs(blk);
2806         }
2807     }
2808
2809     if (node_name) {
2810         bs = bdrv_find_node(node_name);
2811
2812         if (bs) {
2813             return bs;
2814         }
2815     }
2816
2817     error_setg(errp, "Cannot find device=%s nor node_name=%s",
2818                      device ? device : "",
2819                      node_name ? node_name : "");
2820     return NULL;
2821 }
2822
2823 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2824  * return false.  If either argument is NULL, return false. */
2825 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2826 {
2827     while (top && top != base) {
2828         top = top->backing_hd;
2829     }
2830
2831     return top != NULL;
2832 }
2833
2834 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2835 {
2836     if (!bs) {
2837         return QTAILQ_FIRST(&graph_bdrv_states);
2838     }
2839     return QTAILQ_NEXT(bs, node_list);
2840 }
2841
2842 BlockDriverState *bdrv_next(BlockDriverState *bs)
2843 {
2844     if (!bs) {
2845         return QTAILQ_FIRST(&bdrv_states);
2846     }
2847     return QTAILQ_NEXT(bs, device_list);
2848 }
2849
2850 const char *bdrv_get_node_name(const BlockDriverState *bs)
2851 {
2852     return bs->node_name;
2853 }
2854
2855 /* TODO check what callers really want: bs->node_name or blk_name() */
2856 const char *bdrv_get_device_name(const BlockDriverState *bs)
2857 {
2858     return bs->blk ? blk_name(bs->blk) : "";
2859 }
2860
2861 /* This can be used to identify nodes that might not have a device
2862  * name associated. Since node and device names live in the same
2863  * namespace, the result is unambiguous. The exception is if both are
2864  * absent, then this returns an empty (non-null) string. */
2865 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2866 {
2867     return bs->blk ? blk_name(bs->blk) : bs->node_name;
2868 }
2869
2870 int bdrv_get_flags(BlockDriverState *bs)
2871 {
2872     return bs->open_flags;
2873 }
2874
2875 int bdrv_has_zero_init_1(BlockDriverState *bs)
2876 {
2877     return 1;
2878 }
2879
2880 int bdrv_has_zero_init(BlockDriverState *bs)
2881 {
2882     assert(bs->drv);
2883
2884     /* If BS is a copy on write image, it is initialized to
2885        the contents of the base image, which may not be zeroes.  */
2886     if (bs->backing_hd) {
2887         return 0;
2888     }
2889     if (bs->drv->bdrv_has_zero_init) {
2890         return bs->drv->bdrv_has_zero_init(bs);
2891     }
2892
2893     /* safe default */
2894     return 0;
2895 }
2896
2897 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2898 {
2899     BlockDriverInfo bdi;
2900
2901     if (bs->backing_hd) {
2902         return false;
2903     }
2904
2905     if (bdrv_get_info(bs, &bdi) == 0) {
2906         return bdi.unallocated_blocks_are_zero;
2907     }
2908
2909     return false;
2910 }
2911
2912 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2913 {
2914     BlockDriverInfo bdi;
2915
2916     if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
2917         return false;
2918     }
2919
2920     if (bdrv_get_info(bs, &bdi) == 0) {
2921         return bdi.can_write_zeroes_with_unmap;
2922     }
2923
2924     return false;
2925 }
2926
2927 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2928 {
2929     if (bs->backing_hd && bs->backing_hd->encrypted)
2930         return bs->backing_file;
2931     else if (bs->encrypted)
2932         return bs->filename;
2933     else
2934         return NULL;
2935 }
2936
2937 void bdrv_get_backing_filename(BlockDriverState *bs,
2938                                char *filename, int filename_size)
2939 {
2940     pstrcpy(filename, filename_size, bs->backing_file);
2941 }
2942
2943 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2944 {
2945     BlockDriver *drv = bs->drv;
2946     if (!drv)
2947         return -ENOMEDIUM;
2948     if (!drv->bdrv_get_info)
2949         return -ENOTSUP;
2950     memset(bdi, 0, sizeof(*bdi));
2951     return drv->bdrv_get_info(bs, bdi);
2952 }
2953
2954 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2955 {
2956     BlockDriver *drv = bs->drv;
2957     if (drv && drv->bdrv_get_specific_info) {
2958         return drv->bdrv_get_specific_info(bs);
2959     }
2960     return NULL;
2961 }
2962
2963 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2964 {
2965     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2966         return;
2967     }
2968
2969     bs->drv->bdrv_debug_event(bs, event);
2970 }
2971
2972 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
2973                           const char *tag)
2974 {
2975     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
2976         bs = bs->file;
2977     }
2978
2979     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
2980         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
2981     }
2982
2983     return -ENOTSUP;
2984 }
2985
2986 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
2987 {
2988     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
2989         bs = bs->file;
2990     }
2991
2992     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
2993         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
2994     }
2995
2996     return -ENOTSUP;
2997 }
2998
2999 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3000 {
3001     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3002         bs = bs->file;
3003     }
3004
3005     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3006         return bs->drv->bdrv_debug_resume(bs, tag);
3007     }
3008
3009     return -ENOTSUP;
3010 }
3011
3012 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3013 {
3014     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3015         bs = bs->file;
3016     }
3017
3018     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3019         return bs->drv->bdrv_debug_is_suspended(bs, tag);
3020     }
3021
3022     return false;
3023 }
3024
3025 int bdrv_is_snapshot(BlockDriverState *bs)
3026 {
3027     return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3028 }
3029
3030 /* backing_file can either be relative, or absolute, or a protocol.  If it is
3031  * relative, it must be relative to the chain.  So, passing in bs->filename
3032  * from a BDS as backing_file should not be done, as that may be relative to
3033  * the CWD rather than the chain. */
3034 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3035         const char *backing_file)
3036 {
3037     char *filename_full = NULL;
3038     char *backing_file_full = NULL;
3039     char *filename_tmp = NULL;
3040     int is_protocol = 0;
3041     BlockDriverState *curr_bs = NULL;
3042     BlockDriverState *retval = NULL;
3043
3044     if (!bs || !bs->drv || !backing_file) {
3045         return NULL;
3046     }
3047
3048     filename_full     = g_malloc(PATH_MAX);
3049     backing_file_full = g_malloc(PATH_MAX);
3050     filename_tmp      = g_malloc(PATH_MAX);
3051
3052     is_protocol = path_has_protocol(backing_file);
3053
3054     for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3055
3056         /* If either of the filename paths is actually a protocol, then
3057          * compare unmodified paths; otherwise make paths relative */
3058         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3059             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3060                 retval = curr_bs->backing_hd;
3061                 break;
3062             }
3063         } else {
3064             /* If not an absolute filename path, make it relative to the current
3065              * image's filename path */
3066             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3067                          backing_file);
3068
3069             /* We are going to compare absolute pathnames */
3070             if (!realpath(filename_tmp, filename_full)) {
3071                 continue;
3072             }
3073
3074             /* We need to make sure the backing filename we are comparing against
3075              * is relative to the current image filename (or absolute) */
3076             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3077                          curr_bs->backing_file);
3078
3079             if (!realpath(filename_tmp, backing_file_full)) {
3080                 continue;
3081             }
3082
3083             if (strcmp(backing_file_full, filename_full) == 0) {
3084                 retval = curr_bs->backing_hd;
3085                 break;
3086             }
3087         }
3088     }
3089
3090     g_free(filename_full);
3091     g_free(backing_file_full);
3092     g_free(filename_tmp);
3093     return retval;
3094 }
3095
3096 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3097 {
3098     if (!bs->drv) {
3099         return 0;
3100     }
3101
3102     if (!bs->backing_hd) {
3103         return 0;
3104     }
3105
3106     return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3107 }
3108
3109 void bdrv_init(void)
3110 {
3111     module_call_init(MODULE_INIT_BLOCK);
3112 }
3113
3114 void bdrv_init_with_whitelist(void)
3115 {
3116     use_bdrv_whitelist = 1;
3117     bdrv_init();
3118 }
3119
3120 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3121 {
3122     Error *local_err = NULL;
3123     int ret;
3124
3125     if (!bs->drv)  {
3126         return;
3127     }
3128
3129     if (!(bs->open_flags & BDRV_O_INCOMING)) {
3130         return;
3131     }
3132     bs->open_flags &= ~BDRV_O_INCOMING;
3133
3134     if (bs->drv->bdrv_invalidate_cache) {
3135         bs->drv->bdrv_invalidate_cache(bs, &local_err);
3136     } else if (bs->file) {
3137         bdrv_invalidate_cache(bs->file, &local_err);
3138     }
3139     if (local_err) {
3140         error_propagate(errp, local_err);
3141         return;
3142     }
3143
3144     ret = refresh_total_sectors(bs, bs->total_sectors);
3145     if (ret < 0) {
3146         error_setg_errno(errp, -ret, "Could not refresh total sector count");
3147         return;
3148     }
3149 }
3150
3151 void bdrv_invalidate_cache_all(Error **errp)
3152 {
3153     BlockDriverState *bs;
3154     Error *local_err = NULL;
3155
3156     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3157         AioContext *aio_context = bdrv_get_aio_context(bs);
3158
3159         aio_context_acquire(aio_context);
3160         bdrv_invalidate_cache(bs, &local_err);
3161         aio_context_release(aio_context);
3162         if (local_err) {
3163             error_propagate(errp, local_err);
3164             return;
3165         }
3166     }
3167 }
3168
3169 /**************************************************************/
3170 /* removable device support */
3171
3172 /**
3173  * Return TRUE if the media is present
3174  */
3175 int bdrv_is_inserted(BlockDriverState *bs)
3176 {
3177     BlockDriver *drv = bs->drv;
3178
3179     if (!drv)
3180         return 0;
3181     if (!drv->bdrv_is_inserted)
3182         return 1;
3183     return drv->bdrv_is_inserted(bs);
3184 }
3185
3186 /**
3187  * Return whether the media changed since the last call to this
3188  * function, or -ENOTSUP if we don't know.  Most drivers don't know.
3189  */
3190 int bdrv_media_changed(BlockDriverState *bs)
3191 {
3192     BlockDriver *drv = bs->drv;
3193
3194     if (drv && drv->bdrv_media_changed) {
3195         return drv->bdrv_media_changed(bs);
3196     }
3197     return -ENOTSUP;
3198 }
3199
3200 /**
3201  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3202  */
3203 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3204 {
3205     BlockDriver *drv = bs->drv;
3206     const char *device_name;
3207
3208     if (drv && drv->bdrv_eject) {
3209         drv->bdrv_eject(bs, eject_flag);
3210     }
3211
3212     device_name = bdrv_get_device_name(bs);
3213     if (device_name[0] != '\0') {
3214         qapi_event_send_device_tray_moved(device_name,
3215                                           eject_flag, &error_abort);
3216     }
3217 }
3218
3219 /**
3220  * Lock or unlock the media (if it is locked, the user won't be able
3221  * to eject it manually).
3222  */
3223 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3224 {
3225     BlockDriver *drv = bs->drv;
3226
3227     trace_bdrv_lock_medium(bs, locked);
3228
3229     if (drv && drv->bdrv_lock_medium) {
3230         drv->bdrv_lock_medium(bs, locked);
3231     }
3232 }
3233
3234 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3235 {
3236     bs->guest_block_size = align;
3237 }
3238
3239 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3240 {
3241     BdrvDirtyBitmap *bm;
3242
3243     assert(name);
3244     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3245         if (bm->name && !strcmp(name, bm->name)) {
3246             return bm;
3247         }
3248     }
3249     return NULL;
3250 }
3251
3252 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3253 {
3254     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3255     g_free(bitmap->name);
3256     bitmap->name = NULL;
3257 }
3258
3259 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3260                                           uint32_t granularity,
3261                                           const char *name,
3262                                           Error **errp)
3263 {
3264     int64_t bitmap_size;
3265     BdrvDirtyBitmap *bitmap;
3266     uint32_t sector_granularity;
3267
3268     assert((granularity & (granularity - 1)) == 0);
3269
3270     if (name && bdrv_find_dirty_bitmap(bs, name)) {
3271         error_setg(errp, "Bitmap already exists: %s", name);
3272         return NULL;
3273     }
3274     sector_granularity = granularity >> BDRV_SECTOR_BITS;
3275     assert(sector_granularity);
3276     bitmap_size = bdrv_nb_sectors(bs);
3277     if (bitmap_size < 0) {
3278         error_setg_errno(errp, -bitmap_size, "could not get length of device");
3279         errno = -bitmap_size;
3280         return NULL;
3281     }
3282     bitmap = g_new0(BdrvDirtyBitmap, 1);
3283     bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3284     bitmap->size = bitmap_size;
3285     bitmap->name = g_strdup(name);
3286     bitmap->disabled = false;
3287     QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3288     return bitmap;
3289 }
3290
3291 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3292 {
3293     return bitmap->successor;
3294 }
3295
3296 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3297 {
3298     return !(bitmap->disabled || bitmap->successor);
3299 }
3300
3301 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3302 {
3303     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3304         return DIRTY_BITMAP_STATUS_FROZEN;
3305     } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3306         return DIRTY_BITMAP_STATUS_DISABLED;
3307     } else {
3308         return DIRTY_BITMAP_STATUS_ACTIVE;
3309     }
3310 }
3311
3312 /**
3313  * Create a successor bitmap destined to replace this bitmap after an operation.
3314  * Requires that the bitmap is not frozen and has no successor.
3315  */
3316 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3317                                        BdrvDirtyBitmap *bitmap, Error **errp)
3318 {
3319     uint64_t granularity;
3320     BdrvDirtyBitmap *child;
3321
3322     if (bdrv_dirty_bitmap_frozen(bitmap)) {
3323         error_setg(errp, "Cannot create a successor for a bitmap that is "
3324                    "currently frozen");
3325         return -1;
3326     }
3327     assert(!bitmap->successor);
3328
3329     /* Create an anonymous successor */
3330     granularity = bdrv_dirty_bitmap_granularity(bitmap);
3331     child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3332     if (!child) {
3333         return -1;
3334     }
3335
3336     /* Successor will be on or off based on our current state. */
3337     child->disabled = bitmap->disabled;
3338
3339     /* Install the successor and freeze the parent */
3340     bitmap->successor = child;
3341     return 0;
3342 }
3343
3344 /**
3345  * For a bitmap with a successor, yield our name to the successor,
3346  * delete the old bitmap, and return a handle to the new bitmap.
3347  */
3348 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3349                                             BdrvDirtyBitmap *bitmap,
3350                                             Error **errp)
3351 {
3352     char *name;
3353     BdrvDirtyBitmap *successor = bitmap->successor;
3354
3355     if (successor == NULL) {
3356         error_setg(errp, "Cannot relinquish control if "
3357                    "there's no successor present");
3358         return NULL;
3359     }
3360
3361     name = bitmap->name;
3362     bitmap->name = NULL;
3363     successor->name = name;
3364     bitmap->successor = NULL;
3365     bdrv_release_dirty_bitmap(bs, bitmap);
3366
3367     return successor;
3368 }
3369
3370 /**
3371  * In cases of failure where we can no longer safely delete the parent,
3372  * we may wish to re-join the parent and child/successor.
3373  * The merged parent will be un-frozen, but not explicitly re-enabled.
3374  */
3375 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3376                                            BdrvDirtyBitmap *parent,
3377                                            Error **errp)
3378 {
3379     BdrvDirtyBitmap *successor = parent->successor;
3380
3381     if (!successor) {
3382         error_setg(errp, "Cannot reclaim a successor when none is present");
3383         return NULL;
3384     }
3385
3386     if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3387         error_setg(errp, "Merging of parent and successor bitmap failed");
3388         return NULL;
3389     }
3390     bdrv_release_dirty_bitmap(bs, successor);
3391     parent->successor = NULL;
3392
3393     return parent;
3394 }
3395
3396 /**
3397  * Truncates _all_ bitmaps attached to a BDS.
3398  */
3399 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3400 {
3401     BdrvDirtyBitmap *bitmap;
3402     uint64_t size = bdrv_nb_sectors(bs);
3403
3404     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3405         assert(!bdrv_dirty_bitmap_frozen(bitmap));
3406         hbitmap_truncate(bitmap->bitmap, size);
3407         bitmap->size = size;
3408     }
3409 }
3410
3411 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3412 {
3413     BdrvDirtyBitmap *bm, *next;
3414     QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3415         if (bm == bitmap) {
3416             assert(!bdrv_dirty_bitmap_frozen(bm));
3417             QLIST_REMOVE(bitmap, list);
3418             hbitmap_free(bitmap->bitmap);
3419             g_free(bitmap->name);
3420             g_free(bitmap);
3421             return;
3422         }
3423     }
3424 }
3425
3426 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3427 {
3428     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3429     bitmap->disabled = true;
3430 }
3431
3432 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3433 {
3434     assert(!bdrv_dirty_bitmap_frozen(bitmap));
3435     bitmap->disabled = false;
3436 }
3437
3438 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3439 {
3440     BdrvDirtyBitmap *bm;
3441     BlockDirtyInfoList *list = NULL;
3442     BlockDirtyInfoList **plist = &list;
3443
3444     QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3445         BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3446         BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3447         info->count = bdrv_get_dirty_count(bm);
3448         info->granularity = bdrv_dirty_bitmap_granularity(bm);
3449         info->has_name = !!bm->name;
3450         info->name = g_strdup(bm->name);
3451         info->status = bdrv_dirty_bitmap_status(bm);
3452         entry->value = info;
3453         *plist = entry;
3454         plist = &entry->next;
3455     }
3456
3457     return list;
3458 }
3459
3460 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3461 {
3462     if (bitmap) {
3463         return hbitmap_get(bitmap->bitmap, sector);
3464     } else {
3465         return 0;
3466     }
3467 }
3468
3469 /**
3470  * Chooses a default granularity based on the existing cluster size,
3471  * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3472  * is no cluster size information available.
3473  */
3474 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3475 {
3476     BlockDriverInfo bdi;
3477     uint32_t granularity;
3478
3479     if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3480         granularity = MAX(4096, bdi.cluster_size);
3481         granularity = MIN(65536, granularity);
3482     } else {
3483         granularity = 65536;
3484     }
3485
3486     return granularity;
3487 }
3488
3489 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3490 {
3491     return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3492 }
3493
3494 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3495 {
3496     hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3497 }
3498
3499 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3500                            int64_t cur_sector, int nr_sectors)
3501 {
3502     assert(bdrv_dirty_bitmap_enabled(bitmap));
3503     hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3504 }
3505
3506 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3507                              int64_t cur_sector, int nr_sectors)
3508 {
3509     assert(bdrv_dirty_bitmap_enabled(bitmap));
3510     hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3511 }
3512
3513 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3514 {
3515     assert(bdrv_dirty_bitmap_enabled(bitmap));
3516     hbitmap_reset_all(bitmap->bitmap);
3517 }
3518
3519 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3520                     int nr_sectors)
3521 {
3522     BdrvDirtyBitmap *bitmap;
3523     QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3524         if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3525             continue;
3526         }
3527         hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3528     }
3529 }
3530
3531 /**
3532  * Advance an HBitmapIter to an arbitrary offset.
3533  */
3534 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3535 {
3536     assert(hbi->hb);
3537     hbitmap_iter_init(hbi, hbi->hb, offset);
3538 }
3539
3540 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3541 {
3542     return hbitmap_count(bitmap->bitmap);
3543 }
3544
3545 /* Get a reference to bs */
3546 void bdrv_ref(BlockDriverState *bs)
3547 {
3548     bs->refcnt++;
3549 }
3550
3551 /* Release a previously grabbed reference to bs.
3552  * If after releasing, reference count is zero, the BlockDriverState is
3553  * deleted. */
3554 void bdrv_unref(BlockDriverState *bs)
3555 {
3556     if (!bs) {
3557         return;
3558     }
3559     assert(bs->refcnt > 0);
3560     if (--bs->refcnt == 0) {
3561         bdrv_delete(bs);
3562     }
3563 }
3564
3565 struct BdrvOpBlocker {
3566     Error *reason;
3567     QLIST_ENTRY(BdrvOpBlocker) list;
3568 };
3569
3570 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3571 {
3572     BdrvOpBlocker *blocker;
3573     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3574     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3575         blocker = QLIST_FIRST(&bs->op_blockers[op]);
3576         if (errp) {
3577             error_setg(errp, "Node '%s' is busy: %s",
3578                        bdrv_get_device_or_node_name(bs),
3579                        error_get_pretty(blocker->reason));
3580         }
3581         return true;
3582     }
3583     return false;
3584 }
3585
3586 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3587 {
3588     BdrvOpBlocker *blocker;
3589     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3590
3591     blocker = g_new0(BdrvOpBlocker, 1);
3592     blocker->reason = reason;
3593     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3594 }
3595
3596 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3597 {
3598     BdrvOpBlocker *blocker, *next;
3599     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3600     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3601         if (blocker->reason == reason) {
3602             QLIST_REMOVE(blocker, list);
3603             g_free(blocker);
3604         }
3605     }
3606 }
3607
3608 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3609 {
3610     int i;
3611     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3612         bdrv_op_block(bs, i, reason);
3613     }
3614 }
3615
3616 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3617 {
3618     int i;
3619     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3620         bdrv_op_unblock(bs, i, reason);
3621     }
3622 }
3623
3624 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3625 {
3626     int i;
3627
3628     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3629         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3630             return false;
3631         }
3632     }
3633     return true;
3634 }
3635
3636 void bdrv_iostatus_enable(BlockDriverState *bs)
3637 {
3638     bs->iostatus_enabled = true;
3639     bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3640 }
3641
3642 /* The I/O status is only enabled if the drive explicitly
3643  * enables it _and_ the VM is configured to stop on errors */
3644 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3645 {
3646     return (bs->iostatus_enabled &&
3647            (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3648             bs->on_write_error == BLOCKDEV_ON_ERROR_STOP   ||
3649             bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3650 }
3651
3652 void bdrv_iostatus_disable(BlockDriverState *bs)
3653 {
3654     bs->iostatus_enabled = false;
3655 }
3656
3657 void bdrv_iostatus_reset(BlockDriverState *bs)
3658 {
3659     if (bdrv_iostatus_is_enabled(bs)) {
3660         bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3661         if (bs->job) {
3662             block_job_iostatus_reset(bs->job);
3663         }
3664     }
3665 }
3666
3667 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3668 {
3669     assert(bdrv_iostatus_is_enabled(bs));
3670     if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3671         bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3672                                          BLOCK_DEVICE_IO_STATUS_FAILED;
3673     }
3674 }
3675
3676 void bdrv_img_create(const char *filename, const char *fmt,
3677                      const char *base_filename, const char *base_fmt,
3678                      char *options, uint64_t img_size, int flags,
3679                      Error **errp, bool quiet)
3680 {
3681     QemuOptsList *create_opts = NULL;
3682     QemuOpts *opts = NULL;
3683     const char *backing_fmt, *backing_file;
3684     int64_t size;
3685     BlockDriver *drv, *proto_drv;
3686     BlockDriver *backing_drv = NULL;
3687     Error *local_err = NULL;
3688     int ret = 0;
3689
3690     /* Find driver and parse its options */
3691     drv = bdrv_find_format(fmt);
3692     if (!drv) {
3693         error_setg(errp, "Unknown file format '%s'", fmt);
3694         return;
3695     }
3696
3697     proto_drv = bdrv_find_protocol(filename, true, errp);
3698     if (!proto_drv) {
3699         return;
3700     }
3701
3702     if (!drv->create_opts) {
3703         error_setg(errp, "Format driver '%s' does not support image creation",
3704                    drv->format_name);
3705         return;
3706     }
3707
3708     if (!proto_drv->create_opts) {
3709         error_setg(errp, "Protocol driver '%s' does not support image creation",
3710                    proto_drv->format_name);
3711         return;
3712     }
3713
3714     create_opts = qemu_opts_append(create_opts, drv->create_opts);
3715     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3716
3717     /* Create parameter list with default values */
3718     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3719     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3720
3721     /* Parse -o options */
3722     if (options) {
3723         qemu_opts_do_parse(opts, options, NULL, &local_err);
3724         if (local_err) {
3725             error_report_err(local_err);
3726             local_err = NULL;
3727             error_setg(errp, "Invalid options for file format '%s'", fmt);
3728             goto out;
3729         }
3730     }
3731
3732     if (base_filename) {
3733         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3734         if (local_err) {
3735             error_setg(errp, "Backing file not supported for file format '%s'",
3736                        fmt);
3737             goto out;
3738         }
3739     }
3740
3741     if (base_fmt) {
3742         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3743         if (local_err) {
3744             error_setg(errp, "Backing file format not supported for file "
3745                              "format '%s'", fmt);
3746             goto out;
3747         }
3748     }
3749
3750     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3751     if (backing_file) {
3752         if (!strcmp(filename, backing_file)) {
3753             error_setg(errp, "Error: Trying to create an image with the "
3754                              "same filename as the backing file");
3755             goto out;
3756         }
3757     }
3758
3759     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3760     if (backing_fmt) {
3761         backing_drv = bdrv_find_format(backing_fmt);
3762         if (!backing_drv) {
3763             error_setg(errp, "Unknown backing file format '%s'",
3764                        backing_fmt);
3765             goto out;
3766         }
3767     }
3768
3769     // The size for the image must always be specified, with one exception:
3770     // If we are using a backing file, we can obtain the size from there
3771     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3772     if (size == -1) {
3773         if (backing_file) {
3774             BlockDriverState *bs;
3775             char *full_backing = g_new0(char, PATH_MAX);
3776             int64_t size;
3777             int back_flags;
3778
3779             bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3780                                                          full_backing, PATH_MAX,
3781                                                          &local_err);
3782             if (local_err) {
3783                 g_free(full_backing);
3784                 goto out;
3785             }
3786
3787             /* backing files always opened read-only */
3788             back_flags =
3789                 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3790
3791             bs = NULL;
3792             ret = bdrv_open(&bs, full_backing, NULL, NULL, back_flags,
3793                             backing_drv, &local_err);
3794             g_free(full_backing);
3795             if (ret < 0) {
3796                 goto out;
3797             }
3798             size = bdrv_getlength(bs);
3799             if (size < 0) {
3800                 error_setg_errno(errp, -size, "Could not get size of '%s'",
3801                                  backing_file);
3802                 bdrv_unref(bs);
3803                 goto out;
3804             }
3805
3806             qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3807
3808             bdrv_unref(bs);
3809         } else {
3810             error_setg(errp, "Image creation needs a size parameter");
3811             goto out;
3812         }
3813     }
3814
3815     if (!quiet) {
3816         printf("Formatting '%s', fmt=%s", filename, fmt);
3817         qemu_opts_print(opts, " ");
3818         puts("");
3819     }
3820
3821     ret = bdrv_create(drv, filename, opts, &local_err);
3822
3823     if (ret == -EFBIG) {
3824         /* This is generally a better message than whatever the driver would
3825          * deliver (especially because of the cluster_size_hint), since that
3826          * is most probably not much different from "image too large". */
3827         const char *cluster_size_hint = "";
3828         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3829             cluster_size_hint = " (try using a larger cluster size)";
3830         }
3831         error_setg(errp, "The image size is too large for file format '%s'"
3832                    "%s", fmt, cluster_size_hint);
3833         error_free(local_err);
3834         local_err = NULL;
3835     }
3836
3837 out:
3838     qemu_opts_del(opts);
3839     qemu_opts_free(create_opts);
3840     if (local_err) {
3841         error_propagate(errp, local_err);
3842     }
3843 }
3844
3845 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3846 {
3847     return bs->aio_context;
3848 }
3849
3850 void bdrv_detach_aio_context(BlockDriverState *bs)
3851 {
3852     BdrvAioNotifier *baf;
3853
3854     if (!bs->drv) {
3855         return;
3856     }
3857
3858     QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3859         baf->detach_aio_context(baf->opaque);
3860     }
3861
3862     if (bs->io_limits_enabled) {
3863         throttle_timers_detach_aio_context(&bs->throttle_timers);
3864     }
3865     if (bs->drv->bdrv_detach_aio_context) {
3866         bs->drv->bdrv_detach_aio_context(bs);
3867     }
3868     if (bs->file) {
3869         bdrv_detach_aio_context(bs->file);
3870     }
3871     if (bs->backing_hd) {
3872         bdrv_detach_aio_context(bs->backing_hd);
3873     }
3874
3875     bs->aio_context = NULL;
3876 }
3877
3878 void bdrv_attach_aio_context(BlockDriverState *bs,
3879                              AioContext *new_context)
3880 {
3881     BdrvAioNotifier *ban;
3882
3883     if (!bs->drv) {
3884         return;
3885     }
3886
3887     bs->aio_context = new_context;
3888
3889     if (bs->backing_hd) {
3890         bdrv_attach_aio_context(bs->backing_hd, new_context);
3891     }
3892     if (bs->file) {
3893         bdrv_attach_aio_context(bs->file, new_context);
3894     }
3895     if (bs->drv->bdrv_attach_aio_context) {
3896         bs->drv->bdrv_attach_aio_context(bs, new_context);
3897     }
3898     if (bs->io_limits_enabled) {
3899         throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3900     }
3901
3902     QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3903         ban->attached_aio_context(new_context, ban->opaque);
3904     }
3905 }
3906
3907 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3908 {
3909     bdrv_drain(bs); /* ensure there are no in-flight requests */
3910
3911     bdrv_detach_aio_context(bs);
3912
3913     /* This function executes in the old AioContext so acquire the new one in
3914      * case it runs in a different thread.
3915      */
3916     aio_context_acquire(new_context);
3917     bdrv_attach_aio_context(bs, new_context);
3918     aio_context_release(new_context);
3919 }
3920
3921 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3922         void (*attached_aio_context)(AioContext *new_context, void *opaque),
3923         void (*detach_aio_context)(void *opaque), void *opaque)
3924 {
3925     BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3926     *ban = (BdrvAioNotifier){
3927         .attached_aio_context = attached_aio_context,
3928         .detach_aio_context   = detach_aio_context,
3929         .opaque               = opaque
3930     };
3931
3932     QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3933 }
3934
3935 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3936                                       void (*attached_aio_context)(AioContext *,
3937                                                                    void *),
3938                                       void (*detach_aio_context)(void *),
3939                                       void *opaque)
3940 {
3941     BdrvAioNotifier *ban, *ban_next;
3942
3943     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3944         if (ban->attached_aio_context == attached_aio_context &&
3945             ban->detach_aio_context   == detach_aio_context   &&
3946             ban->opaque               == opaque)
3947         {
3948             QLIST_REMOVE(ban, list);
3949             g_free(ban);
3950
3951             return;
3952         }
3953     }
3954
3955     abort();
3956 }
3957
3958 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3959                        BlockDriverAmendStatusCB *status_cb)
3960 {
3961     if (!bs->drv->bdrv_amend_options) {
3962         return -ENOTSUP;
3963     }
3964     return bs->drv->bdrv_amend_options(bs, opts, status_cb);
3965 }
3966
3967 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3968  * of block filter and by bdrv_is_first_non_filter.
3969  * It is used to test if the given bs is the candidate or recurse more in the
3970  * node graph.
3971  */
3972 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3973                                       BlockDriverState *candidate)
3974 {
3975     /* return false if basic checks fails */
3976     if (!bs || !bs->drv) {
3977         return false;
3978     }
3979
3980     /* the code reached a non block filter driver -> check if the bs is
3981      * the same as the candidate. It's the recursion termination condition.
3982      */
3983     if (!bs->drv->is_filter) {
3984         return bs == candidate;
3985     }
3986     /* Down this path the driver is a block filter driver */
3987
3988     /* If the block filter recursion method is defined use it to recurse down
3989      * the node graph.
3990      */
3991     if (bs->drv->bdrv_recurse_is_first_non_filter) {
3992         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3993     }
3994
3995     /* the driver is a block filter but don't allow to recurse -> return false
3996      */
3997     return false;
3998 }
3999
4000 /* This function checks if the candidate is the first non filter bs down it's
4001  * bs chain. Since we don't have pointers to parents it explore all bs chains
4002  * from the top. Some filters can choose not to pass down the recursion.
4003  */
4004 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4005 {
4006     BlockDriverState *bs;
4007
4008     /* walk down the bs forest recursively */
4009     QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4010         bool perm;
4011
4012         /* try to recurse in this top level bs */
4013         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4014
4015         /* candidate is the first non filter */
4016         if (perm) {
4017             return true;
4018         }
4019     }
4020
4021     return false;
4022 }
4023
4024 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
4025 {
4026     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4027     AioContext *aio_context;
4028
4029     if (!to_replace_bs) {
4030         error_setg(errp, "Node name '%s' not found", node_name);
4031         return NULL;
4032     }
4033
4034     aio_context = bdrv_get_aio_context(to_replace_bs);
4035     aio_context_acquire(aio_context);
4036
4037     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4038         to_replace_bs = NULL;
4039         goto out;
4040     }
4041
4042     /* We don't want arbitrary node of the BDS chain to be replaced only the top
4043      * most non filter in order to prevent data corruption.
4044      * Another benefit is that this tests exclude backing files which are
4045      * blocked by the backing blockers.
4046      */
4047     if (!bdrv_is_first_non_filter(to_replace_bs)) {
4048         error_setg(errp, "Only top most non filter can be replaced");
4049         to_replace_bs = NULL;
4050         goto out;
4051     }
4052
4053 out:
4054     aio_context_release(aio_context);
4055     return to_replace_bs;
4056 }
4057
4058 static bool append_open_options(QDict *d, BlockDriverState *bs)
4059 {
4060     const QDictEntry *entry;
4061     bool found_any = false;
4062
4063     for (entry = qdict_first(bs->options); entry;
4064          entry = qdict_next(bs->options, entry))
4065     {
4066         /* Only take options for this level and exclude all non-driver-specific
4067          * options */
4068         if (!strchr(qdict_entry_key(entry), '.') &&
4069             strcmp(qdict_entry_key(entry), "node-name"))
4070         {
4071             qobject_incref(qdict_entry_value(entry));
4072             qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4073             found_any = true;
4074         }
4075     }
4076
4077     return found_any;
4078 }
4079
4080 /* Updates the following BDS fields:
4081  *  - exact_filename: A filename which may be used for opening a block device
4082  *                    which (mostly) equals the given BDS (even without any
4083  *                    other options; so reading and writing must return the same
4084  *                    results, but caching etc. may be different)
4085  *  - full_open_options: Options which, when given when opening a block device
4086  *                       (without a filename), result in a BDS (mostly)
4087  *                       equalling the given one
4088  *  - filename: If exact_filename is set, it is copied here. Otherwise,
4089  *              full_open_options is converted to a JSON object, prefixed with
4090  *              "json:" (for use through the JSON pseudo protocol) and put here.
4091  */
4092 void bdrv_refresh_filename(BlockDriverState *bs)
4093 {
4094     BlockDriver *drv = bs->drv;
4095     QDict *opts;
4096
4097     if (!drv) {
4098         return;
4099     }
4100
4101     /* This BDS's file name will most probably depend on its file's name, so
4102      * refresh that first */
4103     if (bs->file) {
4104         bdrv_refresh_filename(bs->file);
4105     }
4106
4107     if (drv->bdrv_refresh_filename) {
4108         /* Obsolete information is of no use here, so drop the old file name
4109          * information before refreshing it */
4110         bs->exact_filename[0] = '\0';
4111         if (bs->full_open_options) {
4112             QDECREF(bs->full_open_options);
4113             bs->full_open_options = NULL;
4114         }
4115
4116         drv->bdrv_refresh_filename(bs);
4117     } else if (bs->file) {
4118         /* Try to reconstruct valid information from the underlying file */
4119         bool has_open_options;
4120
4121         bs->exact_filename[0] = '\0';
4122         if (bs->full_open_options) {
4123             QDECREF(bs->full_open_options);
4124             bs->full_open_options = NULL;
4125         }
4126
4127         opts = qdict_new();
4128         has_open_options = append_open_options(opts, bs);
4129
4130         /* If no specific options have been given for this BDS, the filename of
4131          * the underlying file should suffice for this one as well */
4132         if (bs->file->exact_filename[0] && !has_open_options) {
4133             strcpy(bs->exact_filename, bs->file->exact_filename);
4134         }
4135         /* Reconstructing the full options QDict is simple for most format block
4136          * drivers, as long as the full options are known for the underlying
4137          * file BDS. The full options QDict of that file BDS should somehow
4138          * contain a representation of the filename, therefore the following
4139          * suffices without querying the (exact_)filename of this BDS. */
4140         if (bs->file->full_open_options) {
4141             qdict_put_obj(opts, "driver",
4142                           QOBJECT(qstring_from_str(drv->format_name)));
4143             QINCREF(bs->file->full_open_options);
4144             qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
4145
4146             bs->full_open_options = opts;
4147         } else {
4148             QDECREF(opts);
4149         }
4150     } else if (!bs->full_open_options && qdict_size(bs->options)) {
4151         /* There is no underlying file BDS (at least referenced by BDS.file),
4152          * so the full options QDict should be equal to the options given
4153          * specifically for this block device when it was opened (plus the
4154          * driver specification).
4155          * Because those options don't change, there is no need to update
4156          * full_open_options when it's already set. */
4157
4158         opts = qdict_new();
4159         append_open_options(opts, bs);
4160         qdict_put_obj(opts, "driver",
4161                       QOBJECT(qstring_from_str(drv->format_name)));
4162
4163         if (bs->exact_filename[0]) {
4164             /* This may not work for all block protocol drivers (some may
4165              * require this filename to be parsed), but we have to find some
4166              * default solution here, so just include it. If some block driver
4167              * does not support pure options without any filename at all or
4168              * needs some special format of the options QDict, it needs to
4169              * implement the driver-specific bdrv_refresh_filename() function.
4170              */
4171             qdict_put_obj(opts, "filename",
4172                           QOBJECT(qstring_from_str(bs->exact_filename)));
4173         }
4174
4175         bs->full_open_options = opts;
4176     }
4177
4178     if (bs->exact_filename[0]) {
4179         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4180     } else if (bs->full_open_options) {
4181         QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4182         snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4183                  qstring_get_str(json));
4184         QDECREF(json);
4185     }
4186 }
4187
4188 /* This accessor function purpose is to allow the device models to access the
4189  * BlockAcctStats structure embedded inside a BlockDriverState without being
4190  * aware of the BlockDriverState structure layout.
4191  * It will go away when the BlockAcctStats structure will be moved inside
4192  * the device models.
4193  */
4194 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4195 {
4196     return &bs->stats;
4197 }