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