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