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
  25 #include "qemu/osdep.h"
  26 #include "block/trace.h"
  27 #include "block/block_int.h"
  28 #include "block/blockjob.h"
  29 #include "block/nbd.h"
  30 #include "qemu/error-report.h"
  31 #include "module_block.h"
  32 #include "qemu/module.h"
  33 #include "qapi/error.h"
  34 #include "qapi/qmp/qdict.h"
  35 #include "qapi/qmp/qjson.h"
  36 #include "qapi/qmp/qstring.h"
  37 #include "qapi/qobject-output-visitor.h"
  38 #include "qapi/qapi-visit-block-core.h"
  39 #include "sysemu/block-backend.h"
  40 #include "sysemu/sysemu.h"
  41 #include "qemu/notify.h"
  42 #include "qemu/option.h"
  43 #include "qemu/coroutine.h"
  44 #include "block/qapi.h"
  45 #include "qemu/timer.h"
  46 #include "qemu/cutils.h"
  47 #include "qemu/id.h"
  48
  49 #ifdef CONFIG_BSD
  50 #include <sys/ioctl.h>
  51 #include <sys/queue.h>
  52 #ifndef __DragonFly__
  53 #include <sys/disk.h>
  54 #endif
  55 #endif
  56
  57 #ifdef _WIN32
  58 #include <windows.h>
  59 #endif
  60
  61 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
  62
  63 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
  64     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
  65
  66 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
  67     QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
  68
  69 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
  70     QLIST_HEAD_INITIALIZER(bdrv_drivers);
  71
  72 static BlockDriverState *bdrv_open_inherit(const char *filename,
  73                                            const char *reference,
  74                                            QDict *options, int flags,
  75                                            BlockDriverState *parent,
  76                                            const BdrvChildRole *child_role,
  77                                            Error **errp);
  78
  79 /* If non-zero, use only whitelisted block drivers */
  80 static int use_bdrv_whitelist;
  81
  82 #ifdef _WIN32
  83 static int is_windows_drive_prefix(const char *filename)
  84 {
  85     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
  86              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
  87             filename[1] == ':');
  88 }
  89
  90 int is_windows_drive(const char *filename)
  91 {
  92     if (is_windows_drive_prefix(filename) &&
  93         filename[2] == '\0')
  94         return 1;
  95     if (strstart(filename, "\\\\.\\", NULL) ||
  96         strstart(filename, "//./", NULL))
  97         return 1;
  98     return 0;
  99 }
 100 #endif
 101
 102 size_t bdrv_opt_mem_align(BlockDriverState *bs)
 103 {
 104     if (!bs || !bs->drv) {
 105         /* page size or 4k (hdd sector size) should be on the safe side */
 106         return MAX(4096, getpagesize());
 107     }
 108
 109     return bs->bl.opt_mem_alignment;
 110 }
 111
 112 size_t bdrv_min_mem_align(BlockDriverState *bs)
 113 {
 114     if (!bs || !bs->drv) {
 115         /* page size or 4k (hdd sector size) should be on the safe side */
 116         return MAX(4096, getpagesize());
 117     }
 118
 119     return bs->bl.min_mem_alignment;
 120 }
 121
 122 /* check if the path starts with "<protocol>:" */
 123 int path_has_protocol(const char *path)
 124 {
 125     const char *p;
 126
 127 #ifdef _WIN32
 128     if (is_windows_drive(path) ||
 129         is_windows_drive_prefix(path)) {
 130         return 0;
 131     }
 132     p = path + strcspn(path, ":/\\");
 133 #else
 134     p = path + strcspn(path, ":/");
 135 #endif
 136
 137     return *p == ':';
 138 }
 139
 140 int path_is_absolute(const char *path)
 141 {
 142 #ifdef _WIN32
 143     /* specific case for names like: "\\.\d:" */
 144     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
 145         return 1;
 146     }
 147     return (*path == '/' || *path == '\\');
 148 #else
 149     return (*path == '/');
 150 #endif
 151 }
 152
 153 /* if filename is absolute, just copy it to dest. Otherwise, build a
 154    path to it by considering it is relative to base_path. URL are
 155    supported. */
 156 void path_combine(char *dest, int dest_size,
 157                   const char *base_path,
 158                   const char *filename)
 159 {
 160     const char *p, *p1;
 161     int len;
 162
 163     if (dest_size <= 0)
 164         return;
 165     if (path_is_absolute(filename)) {
 166         pstrcpy(dest, dest_size, filename);
 167     } else {
 168         const char *protocol_stripped = NULL;
 169
 170         if (path_has_protocol(base_path)) {
 171             protocol_stripped = strchr(base_path, ':');
 172             if (protocol_stripped) {
 173                 protocol_stripped++;
 174             }
 175         }
 176         p = protocol_stripped ?: base_path;
 177
 178         p1 = strrchr(base_path, '/');
 179 #ifdef _WIN32
 180         {
 181             const char *p2;
 182             p2 = strrchr(base_path, '\\');
 183             if (!p1 || p2 > p1)
 184                 p1 = p2;
 185         }
 186 #endif
 187         if (p1)
 188             p1++;
 189         else
 190             p1 = base_path;
 191         if (p1 > p)
 192             p = p1;
 193         len = p - base_path;
 194         if (len > dest_size - 1)
 195             len = dest_size - 1;
 196         memcpy(dest, base_path, len);
 197         dest[len] = '\0';
 198         pstrcat(dest, dest_size, filename);
 199     }
 200 }
 201
 202 /*
 203  * Helper function for bdrv_parse_filename() implementations to remove optional
 204  * protocol prefixes (especially "file:") from a filename and for putting the
 205  * stripped filename into the options QDict if there is such a prefix.
 206  */
 207 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
 208                                       QDict *options)
 209 {
 210     if (strstart(filename, prefix, &filename)) {
 211         /* Stripping the explicit protocol prefix may result in a protocol
 212          * prefix being (wrongly) detected (if the filename contains a colon) */
 213         if (path_has_protocol(filename)) {
 214             QString *fat_filename;
 215
 216             /* This means there is some colon before the first slash; therefore,
 217              * this cannot be an absolute path */
 218             assert(!path_is_absolute(filename));
 219
 220             /* And we can thus fix the protocol detection issue by prefixing it
 221              * by "./" */
 222             fat_filename = qstring_from_str("./");
 223             qstring_append(fat_filename, filename);
 224
 225             assert(!path_has_protocol(qstring_get_str(fat_filename)));
 226
 227             qdict_put(options, "filename", fat_filename);
 228         } else {
 229             /* If no protocol prefix was detected, we can use the shortened
 230              * filename as-is */
 231             qdict_put_str(options, "filename", filename);
 232         }
 233     }
 234 }
 235
 236
 237 /* Returns whether the image file is opened as read-only. Note that this can
 238  * return false and writing to the image file is still not possible because the
 239  * image is inactivated. */
 240 bool bdrv_is_read_only(BlockDriverState *bs)
 241 {
 242     return bs->read_only;
 243 }
 244
 245 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
 246                            bool ignore_allow_rdw, Error **errp)
 247 {
 248     /* Do not set read_only if copy_on_read is enabled */
 249     if (bs->copy_on_read && read_only) {
 250         error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
 251                    bdrv_get_device_or_node_name(bs));
 252         return -EINVAL;
 253     }
 254
 255     /* Do not clear read_only if it is prohibited */
 256     if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
 257         !ignore_allow_rdw)
 258     {
 259         error_setg(errp, "Node '%s' is read only",
 260                    bdrv_get_device_or_node_name(bs));
 261         return -EPERM;
 262     }
 263
 264     return 0;
 265 }
 266
 267 /* TODO Remove (deprecated since 2.11)
 268  * Block drivers are not supposed to automatically change bs->read_only.
 269  * Instead, they should just check whether they can provide what the user
 270  * explicitly requested and error out if read-write is requested, but they can
 271  * only provide read-only access. */
 272 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 273 {
 274     int ret = 0;
 275
 276     ret = bdrv_can_set_read_only(bs, read_only, false, errp);
 277     if (ret < 0) {
 278         return ret;
 279     }
 280
 281     bs->read_only = read_only;
 282     return 0;
 283 }
 284
 285 void bdrv_get_full_backing_filename_from_filename(const char *backed,
 286                                                   const char *backing,
 287                                                   char *dest, size_t sz,
 288                                                   Error **errp)
 289 {
 290     if (backing[0] == '\0' || path_has_protocol(backing) ||
 291         path_is_absolute(backing))
 292     {
 293         pstrcpy(dest, sz, backing);
 294     } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
 295         error_setg(errp, "Cannot use relative backing file names for '%s'",
 296                    backed);
 297     } else {
 298         path_combine(dest, sz, backed, backing);
 299     }
 300 }
 301
 302 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
 303                                     Error **errp)
 304 {
 305     char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
 306
 307     bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
 308                                                  dest, sz, errp);
 309 }
 310
 311 void bdrv_register(BlockDriver *bdrv)
 312 {
 313     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 314 }
 315
 316 BlockDriverState *bdrv_new(void)
 317 {
 318     BlockDriverState *bs;
 319     int i;
 320
 321     bs = g_new0(BlockDriverState, 1);
 322     QLIST_INIT(&bs->dirty_bitmaps);
 323     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
 324         QLIST_INIT(&bs->op_blockers[i]);
 325     }
 326     notifier_with_return_list_init(&bs->before_write_notifiers);
 327     qemu_co_mutex_init(&bs->reqs_lock);
 328     qemu_mutex_init(&bs->dirty_bitmap_mutex);
 329     bs->refcnt = 1;
 330     bs->aio_context = qemu_get_aio_context();
 331
 332     qemu_co_queue_init(&bs->flush_queue);
 333
 334     QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
 335
 336     return bs;
 337 }
 338
 339 static BlockDriver *bdrv_do_find_format(const char *format_name)
 340 {
 341     BlockDriver *drv1;
 342
 343     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 344         if (!strcmp(drv1->format_name, format_name)) {
 345             return drv1;
 346         }
 347     }
 348
 349     return NULL;
 350 }
 351
 352 BlockDriver *bdrv_find_format(const char *format_name)
 353 {
 354     BlockDriver *drv1;
 355     int i;
 356
 357     drv1 = bdrv_do_find_format(format_name);
 358     if (drv1) {
 359         return drv1;
 360     }
 361
 362     /* The driver isn't registered, maybe we need to load a module */
 363     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
 364         if (!strcmp(block_driver_modules[i].format_name, format_name)) {
 365             block_module_load_one(block_driver_modules[i].library_name);
 366             break;
 367         }
 368     }
 369
 370     return bdrv_do_find_format(format_name);
 371 }
 372
 373 int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
 374 {
 375     static const char *whitelist_rw[] = {
 376         CONFIG_BDRV_RW_WHITELIST
 377     };
 378     static const char *whitelist_ro[] = {
 379         CONFIG_BDRV_RO_WHITELIST
 380     };
 381     const char **p;
 382
 383     if (!whitelist_rw[0] && !whitelist_ro[0]) {
 384         return 1;               /* no whitelist, anything goes */
 385     }
 386
 387     for (p = whitelist_rw; *p; p++) {
 388         if (!strcmp(drv->format_name, *p)) {
 389             return 1;
 390         }
 391     }
 392     if (read_only) {
 393         for (p = whitelist_ro; *p; p++) {
 394             if (!strcmp(drv->format_name, *p)) {
 395                 return 1;
 396             }
 397         }
 398     }
 399     return 0;
 400 }
 401
 402 bool bdrv_uses_whitelist(void)
 403 {
 404     return use_bdrv_whitelist;
 405 }
 406
 407 typedef struct CreateCo {
 408     BlockDriver *drv;
 409     char *filename;
 410     QemuOpts *opts;
 411     int ret;
 412     Error *err;
 413 } CreateCo;
 414
 415 static void coroutine_fn bdrv_create_co_entry(void *opaque)
 416 {
 417     Error *local_err = NULL;
 418     int ret;
 419
 420     CreateCo *cco = opaque;
 421     assert(cco->drv);
 422
 423     ret = cco->drv->bdrv_co_create_opts(cco->filename, cco->opts, &local_err);
 424     error_propagate(&cco->err, local_err);
 425     cco->ret = ret;
 426 }
 427
 428 int bdrv_create(BlockDriver *drv, const char* filename,
 429                 QemuOpts *opts, Error **errp)
 430 {
 431     int ret;
 432
 433     Coroutine *co;
 434     CreateCo cco = {
 435         .drv = drv,
 436         .filename = g_strdup(filename),
 437         .opts = opts,
 438         .ret = NOT_DONE,
 439         .err = NULL,
 440     };
 441
 442     if (!drv->bdrv_co_create_opts) {
 443         error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
 444         ret = -ENOTSUP;
 445         goto out;
 446     }
 447
 448     if (qemu_in_coroutine()) {
 449         /* Fast-path if already in coroutine context */
 450         bdrv_create_co_entry(&cco);
 451     } else {
 452         co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
 453         qemu_coroutine_enter(co);
 454         while (cco.ret == NOT_DONE) {
 455             aio_poll(qemu_get_aio_context(), true);
 456         }
 457     }
 458
 459     ret = cco.ret;
 460     if (ret < 0) {
 461         if (cco.err) {
 462             error_propagate(errp, cco.err);
 463         } else {
 464             error_setg_errno(errp, -ret, "Could not create image");
 465         }
 466     }
 467
 468 out:
 469     g_free(cco.filename);
 470     return ret;
 471 }
 472
 473 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
 474 {
 475     BlockDriver *drv;
 476     Error *local_err = NULL;
 477     int ret;
 478
 479     drv = bdrv_find_protocol(filename, true, errp);
 480     if (drv == NULL) {
 481         return -ENOENT;
 482     }
 483
 484     ret = bdrv_create(drv, filename, opts, &local_err);
 485     error_propagate(errp, local_err);
 486     return ret;
 487 }
 488
 489 /**
 490  * Try to get @bs's logical and physical block size.
 491  * On success, store them in @bsz struct and return 0.
 492  * On failure return -errno.
 493  * @bs must not be empty.
 494  */
 495 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 496 {
 497     BlockDriver *drv = bs->drv;
 498
 499     if (drv && drv->bdrv_probe_blocksizes) {
 500         return drv->bdrv_probe_blocksizes(bs, bsz);
 501     } else if (drv && drv->is_filter && bs->file) {
 502         return bdrv_probe_blocksizes(bs->file->bs, bsz);
 503     }
 504
 505     return -ENOTSUP;
 506 }
 507
 508 /**
 509  * Try to get @bs's geometry (cyls, heads, sectors).
 510  * On success, store them in @geo struct and return 0.
 511  * On failure return -errno.
 512  * @bs must not be empty.
 513  */
 514 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 515 {
 516     BlockDriver *drv = bs->drv;
 517
 518     if (drv && drv->bdrv_probe_geometry) {
 519         return drv->bdrv_probe_geometry(bs, geo);
 520     } else if (drv && drv->is_filter && bs->file) {
 521         return bdrv_probe_geometry(bs->file->bs, geo);
 522     }
 523
 524     return -ENOTSUP;
 525 }
 526
 527 /*
 528  * Create a uniquely-named empty temporary file.
 529  * Return 0 upon success, otherwise a negative errno value.
 530  */
 531 int get_tmp_filename(char *filename, int size)
 532 {
 533 #ifdef _WIN32
 534     char temp_dir[MAX_PATH];
 535     /* GetTempFileName requires that its output buffer (4th param)
 536        have length MAX_PATH or greater.  */
 537     assert(size >= MAX_PATH);
 538     return (GetTempPath(MAX_PATH, temp_dir)
 539             && GetTempFileName(temp_dir, "qem", 0, filename)
 540             ? 0 : -GetLastError());
 541 #else
 542     int fd;
 543     const char *tmpdir;
 544     tmpdir = getenv("TMPDIR");
 545     if (!tmpdir) {
 546         tmpdir = "/var/tmp";
 547     }
 548     if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
 549         return -EOVERFLOW;
 550     }
 551     fd = mkstemp(filename);
 552     if (fd < 0) {
 553         return -errno;
 554     }
 555     if (close(fd) != 0) {
 556         unlink(filename);
 557         return -errno;
 558     }
 559     return 0;
 560 #endif
 561 }
 562
 563 /*
 564  * Detect host devices. By convention, /dev/cdrom[N] is always
 565  * recognized as a host CDROM.
 566  */
 567 static BlockDriver *find_hdev_driver(const char *filename)
 568 {
 569     int score_max = 0, score;
 570     BlockDriver *drv = NULL, *d;
 571
 572     QLIST_FOREACH(d, &bdrv_drivers, list) {
 573         if (d->bdrv_probe_device) {
 574             score = d->bdrv_probe_device(filename);
 575             if (score > score_max) {
 576                 score_max = score;
 577                 drv = d;
 578             }
 579         }
 580     }
 581
 582     return drv;
 583 }
 584
 585 static BlockDriver *bdrv_do_find_protocol(const char *protocol)
 586 {
 587     BlockDriver *drv1;
 588
 589     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 590         if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
 591             return drv1;
 592         }
 593     }
 594
 595     return NULL;
 596 }
 597
 598 BlockDriver *bdrv_find_protocol(const char *filename,
 599                                 bool allow_protocol_prefix,
 600                                 Error **errp)
 601 {
 602     BlockDriver *drv1;
 603     char protocol[128];
 604     int len;
 605     const char *p;
 606     int i;
 607
 608     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 609
 610     /*
 611      * XXX(hch): we really should not let host device detection
 612      * override an explicit protocol specification, but moving this
 613      * later breaks access to device names with colons in them.
 614      * Thanks to the brain-dead persistent naming schemes on udev-
 615      * based Linux systems those actually are quite common.
 616      */
 617     drv1 = find_hdev_driver(filename);
 618     if (drv1) {
 619         return drv1;
 620     }
 621
 622     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
 623         return &bdrv_file;
 624     }
 625
 626     p = strchr(filename, ':');
 627     assert(p != NULL);
 628     len = p - filename;
 629     if (len > sizeof(protocol) - 1)
 630         len = sizeof(protocol) - 1;
 631     memcpy(protocol, filename, len);
 632     protocol[len] = '\0';
 633
 634     drv1 = bdrv_do_find_protocol(protocol);
 635     if (drv1) {
 636         return drv1;
 637     }
 638
 639     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
 640         if (block_driver_modules[i].protocol_name &&
 641             !strcmp(block_driver_modules[i].protocol_name, protocol)) {
 642             block_module_load_one(block_driver_modules[i].library_name);
 643             break;
 644         }
 645     }
 646
 647     drv1 = bdrv_do_find_protocol(protocol);
 648     if (!drv1) {
 649         error_setg(errp, "Unknown protocol '%s'", protocol);
 650     }
 651     return drv1;
 652 }
 653
 654 /*
 655  * Guess image format by probing its contents.
 656  * This is not a good idea when your image is raw (CVE-2008-2004), but
 657  * we do it anyway for backward compatibility.
 658  *
 659  * @buf         contains the image's first @buf_size bytes.
 660  * @buf_size    is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
 661  *              but can be smaller if the image file is smaller)
 662  * @filename    is its filename.
 663  *
 664  * For all block drivers, call the bdrv_probe() method to get its
 665  * probing score.
 666  * Return the first block driver with the highest probing score.
 667  */
 668 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
 669                             const char *filename)
 670 {
 671     int score_max = 0, score;
 672     BlockDriver *drv = NULL, *d;
 673
 674     QLIST_FOREACH(d, &bdrv_drivers, list) {
 675         if (d->bdrv_probe) {
 676             score = d->bdrv_probe(buf, buf_size, filename);
 677             if (score > score_max) {
 678                 score_max = score;
 679                 drv = d;
 680             }
 681         }
 682     }
 683
 684     return drv;
 685 }
 686
 687 static int find_image_format(BlockBackend *file, const char *filename,
 688                              BlockDriver **pdrv, Error **errp)
 689 {
 690     BlockDriver *drv;
 691     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
 692     int ret = 0;
 693
 694     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
 695     if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
 696         *pdrv = &bdrv_raw;
 697         return ret;
 698     }
 699
 700     ret = blk_pread(file, 0, buf, sizeof(buf));
 701     if (ret < 0) {
 702         error_setg_errno(errp, -ret, "Could not read image for determining its "
 703                          "format");
 704         *pdrv = NULL;
 705         return ret;
 706     }
 707
 708     drv = bdrv_probe_all(buf, ret, filename);
 709     if (!drv) {
 710         error_setg(errp, "Could not determine image format: No compatible "
 711                    "driver found");
 712         ret = -ENOENT;
 713     }
 714     *pdrv = drv;
 715     return ret;
 716 }
 717
 718 /**
 719  * Set the current 'total_sectors' value
 720  * Return 0 on success, -errno on error.
 721  */
 722 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
 723 {
 724     BlockDriver *drv = bs->drv;
 725
 726     if (!drv) {
 727         return -ENOMEDIUM;
 728     }
 729
 730     /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
 731     if (bdrv_is_sg(bs))
 732         return 0;
 733
 734     /* query actual device if possible, otherwise just trust the hint */
 735     if (drv->bdrv_getlength) {
 736         int64_t length = drv->bdrv_getlength(bs);
 737         if (length < 0) {
 738             return length;
 739         }
 740         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
 741     }
 742
 743     bs->total_sectors = hint;
 744     return 0;
 745 }
 746
 747 /**
 748  * Combines a QDict of new block driver @options with any missing options taken
 749  * from @old_options, so that leaving out an option defaults to its old value.
 750  */
 751 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
 752                               QDict *old_options)
 753 {
 754     if (bs->drv && bs->drv->bdrv_join_options) {
 755         bs->drv->bdrv_join_options(options, old_options);
 756     } else {
 757         qdict_join(options, old_options, false);
 758     }
 759 }
 760
 761 /**
 762  * Set open flags for a given discard mode
 763  *
 764  * Return 0 on success, -1 if the discard mode was invalid.
 765  */
 766 int bdrv_parse_discard_flags(const char *mode, int *flags)
 767 {
 768     *flags &= ~BDRV_O_UNMAP;
 769
 770     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
 771         /* do nothing */
 772     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
 773         *flags |= BDRV_O_UNMAP;
 774     } else {
 775         return -1;
 776     }
 777
 778     return 0;
 779 }
 780
 781 /**
 782  * Set open flags for a given cache mode
 783  *
 784  * Return 0 on success, -1 if the cache mode was invalid.
 785  */
 786 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
 787 {
 788     *flags &= ~BDRV_O_CACHE_MASK;
 789
 790     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
 791         *writethrough = false;
 792         *flags |= BDRV_O_NOCACHE;
 793     } else if (!strcmp(mode, "directsync")) {
 794         *writethrough = true;
 795         *flags |= BDRV_O_NOCACHE;
 796     } else if (!strcmp(mode, "writeback")) {
 797         *writethrough = false;
 798     } else if (!strcmp(mode, "unsafe")) {
 799         *writethrough = false;
 800         *flags |= BDRV_O_NO_FLUSH;
 801     } else if (!strcmp(mode, "writethrough")) {
 802         *writethrough = true;
 803     } else {
 804         return -1;
 805     }
 806
 807     return 0;
 808 }
 809
 810 static char *bdrv_child_get_parent_desc(BdrvChild *c)
 811 {
 812     BlockDriverState *parent = c->opaque;
 813     return g_strdup(bdrv_get_device_or_node_name(parent));
 814 }
 815
 816 static void bdrv_child_cb_drained_begin(BdrvChild *child)
 817 {
 818     BlockDriverState *bs = child->opaque;
 819     bdrv_drained_begin(bs);
 820 }
 821
 822 static void bdrv_child_cb_drained_end(BdrvChild *child)
 823 {
 824     BlockDriverState *bs = child->opaque;
 825     bdrv_drained_end(bs);
 826 }
 827
 828 static void bdrv_child_cb_attach(BdrvChild *child)
 829 {
 830     BlockDriverState *bs = child->opaque;
 831     bdrv_apply_subtree_drain(child, bs);
 832 }
 833
 834 static void bdrv_child_cb_detach(BdrvChild *child)
 835 {
 836     BlockDriverState *bs = child->opaque;
 837     bdrv_unapply_subtree_drain(child, bs);
 838 }
 839
 840 static int bdrv_child_cb_inactivate(BdrvChild *child)
 841 {
 842     BlockDriverState *bs = child->opaque;
 843     assert(bs->open_flags & BDRV_O_INACTIVE);
 844     return 0;
 845 }
 846
 847 /*
 848  * Returns the options and flags that a temporary snapshot should get, based on
 849  * the originally requested flags (the originally requested image will have
 850  * flags like a backing file)
 851  */
 852 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
 853                                        int parent_flags, QDict *parent_options)
 854 {
 855     *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
 856
 857     /* For temporary files, unconditional cache=unsafe is fine */
 858     qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
 859     qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
 860
 861     /* Copy the read-only option from the parent */
 862     qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
 863
 864     /* aio=native doesn't work for cache.direct=off, so disable it for the
 865      * temporary snapshot */
 866     *child_flags &= ~BDRV_O_NATIVE_AIO;
 867 }
 868
 869 /*
 870  * Returns the options and flags that bs->file should get if a protocol driver
 871  * is expected, based on the given options and flags for the parent BDS
 872  */
 873 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
 874                                    int parent_flags, QDict *parent_options)
 875 {
 876     int flags = parent_flags;
 877
 878     /* Enable protocol handling, disable format probing for bs->file */
 879     flags |= BDRV_O_PROTOCOL;
 880
 881     /* If the cache mode isn't explicitly set, inherit direct and no-flush from
 882      * the parent. */
 883     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
 884     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
 885     qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
 886
 887     /* Inherit the read-only option from the parent if it's not set */
 888     qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
 889
 890     /* Our block drivers take care to send flushes and respect unmap policy,
 891      * so we can default to enable both on lower layers regardless of the
 892      * corresponding parent options. */
 893     qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
 894
 895     /* Clear flags that only apply to the top layer */
 896     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
 897                BDRV_O_NO_IO);
 898
 899     *child_flags = flags;
 900 }
 901
 902 const BdrvChildRole child_file = {
 903     .get_parent_desc = bdrv_child_get_parent_desc,
 904     .inherit_options = bdrv_inherited_options,
 905     .drained_begin   = bdrv_child_cb_drained_begin,
 906     .drained_end     = bdrv_child_cb_drained_end,
 907     .attach          = bdrv_child_cb_attach,
 908     .detach          = bdrv_child_cb_detach,
 909     .inactivate      = bdrv_child_cb_inactivate,
 910 };
 911
 912 /*
 913  * Returns the options and flags that bs->file should get if the use of formats
 914  * (and not only protocols) is permitted for it, based on the given options and
 915  * flags for the parent BDS
 916  */
 917 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
 918                                        int parent_flags, QDict *parent_options)
 919 {
 920     child_file.inherit_options(child_flags, child_options,
 921                                parent_flags, parent_options);
 922
 923     *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
 924 }
 925
 926 const BdrvChildRole child_format = {
 927     .get_parent_desc = bdrv_child_get_parent_desc,
 928     .inherit_options = bdrv_inherited_fmt_options,
 929     .drained_begin   = bdrv_child_cb_drained_begin,
 930     .drained_end     = bdrv_child_cb_drained_end,
 931     .attach          = bdrv_child_cb_attach,
 932     .detach          = bdrv_child_cb_detach,
 933     .inactivate      = bdrv_child_cb_inactivate,
 934 };
 935
 936 static void bdrv_backing_attach(BdrvChild *c)
 937 {
 938     BlockDriverState *parent = c->opaque;
 939     BlockDriverState *backing_hd = c->bs;
 940
 941     assert(!parent->backing_blocker);
 942     error_setg(&parent->backing_blocker,
 943                "node is used as backing hd of '%s'",
 944                bdrv_get_device_or_node_name(parent));
 945
 946     parent->open_flags &= ~BDRV_O_NO_BACKING;
 947     pstrcpy(parent->backing_file, sizeof(parent->backing_file),
 948             backing_hd->filename);
 949     pstrcpy(parent->backing_format, sizeof(parent->backing_format),
 950             backing_hd->drv ? backing_hd->drv->format_name : "");
 951
 952     bdrv_op_block_all(backing_hd, parent->backing_blocker);
 953     /* Otherwise we won't be able to commit or stream */
 954     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
 955                     parent->backing_blocker);
 956     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
 957                     parent->backing_blocker);
 958     /*
 959      * We do backup in 3 ways:
 960      * 1. drive backup
 961      *    The target bs is new opened, and the source is top BDS
 962      * 2. blockdev backup
 963      *    Both the source and the target are top BDSes.
 964      * 3. internal backup(used for block replication)
 965      *    Both the source and the target are backing file
 966      *
 967      * In case 1 and 2, neither the source nor the target is the backing file.
 968      * In case 3, we will block the top BDS, so there is only one block job
 969      * for the top BDS and its backing chain.
 970      */
 971     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
 972                     parent->backing_blocker);
 973     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
 974                     parent->backing_blocker);
 975
 976     bdrv_child_cb_attach(c);
 977 }
 978
 979 static void bdrv_backing_detach(BdrvChild *c)
 980 {
 981     BlockDriverState *parent = c->opaque;
 982
 983     assert(parent->backing_blocker);
 984     bdrv_op_unblock_all(c->bs, parent->backing_blocker);
 985     error_free(parent->backing_blocker);
 986     parent->backing_blocker = NULL;
 987
 988     bdrv_child_cb_detach(c);
 989 }
 990
 991 /*
 992  * Returns the options and flags that bs->backing should get, based on the
 993  * given options and flags for the parent BDS
 994  */
 995 static void bdrv_backing_options(int *child_flags, QDict *child_options,
 996                                  int parent_flags, QDict *parent_options)
 997 {
 998     int flags = parent_flags;
 999
1000     /* The cache mode is inherited unmodified for backing files; except WCE,
1001      * which is only applied on the top level (BlockBackend) */
1002     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1003     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
1004     qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
1005
1006     /* backing files always opened read-only */
1007     qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
1008     flags &= ~BDRV_O_COPY_ON_READ;
1009
1010     /* snapshot=on is handled on the top layer */
1011     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
1012
1013     *child_flags = flags;
1014 }
1015
1016 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
1017                                         const char *filename, Error **errp)
1018 {
1019     BlockDriverState *parent = c->opaque;
1020     int orig_flags = bdrv_get_flags(parent);
1021     int ret;
1022
1023     if (!(orig_flags & BDRV_O_RDWR)) {
1024         ret = bdrv_reopen(parent, orig_flags | BDRV_O_RDWR, errp);
1025         if (ret < 0) {
1026             return ret;
1027         }
1028     }
1029
1030     ret = bdrv_change_backing_file(parent, filename,
1031                                    base->drv ? base->drv->format_name : "");
1032     if (ret < 0) {
1033         error_setg_errno(errp, -ret, "Could not update backing file link");
1034     }
1035
1036     if (!(orig_flags & BDRV_O_RDWR)) {
1037         bdrv_reopen(parent, orig_flags, NULL);
1038     }
1039
1040     return ret;
1041 }
1042
1043 const BdrvChildRole child_backing = {
1044     .get_parent_desc = bdrv_child_get_parent_desc,
1045     .attach          = bdrv_backing_attach,
1046     .detach          = bdrv_backing_detach,
1047     .inherit_options = bdrv_backing_options,
1048     .drained_begin   = bdrv_child_cb_drained_begin,
1049     .drained_end     = bdrv_child_cb_drained_end,
1050     .inactivate      = bdrv_child_cb_inactivate,
1051     .update_filename = bdrv_backing_update_filename,
1052 };
1053
1054 static int bdrv_open_flags(BlockDriverState *bs, int flags)
1055 {
1056     int open_flags = flags;
1057
1058     /*
1059      * Clear flags that are internal to the block layer before opening the
1060      * image.
1061      */
1062     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
1063
1064     /*
1065      * Snapshots should be writable.
1066      */
1067     if (flags & BDRV_O_TEMPORARY) {
1068         open_flags |= BDRV_O_RDWR;
1069     }
1070
1071     return open_flags;
1072 }
1073
1074 static void update_flags_from_options(int *flags, QemuOpts *opts)
1075 {
1076     *flags &= ~BDRV_O_CACHE_MASK;
1077
1078     assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
1079     if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
1080         *flags |= BDRV_O_NO_FLUSH;
1081     }
1082
1083     assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
1084     if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
1085         *flags |= BDRV_O_NOCACHE;
1086     }
1087
1088     *flags &= ~BDRV_O_RDWR;
1089
1090     assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));
1091     if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) {
1092         *flags |= BDRV_O_RDWR;
1093     }
1094
1095 }
1096
1097 static void update_options_from_flags(QDict *options, int flags)
1098 {
1099     if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
1100         qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
1101     }
1102     if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
1103         qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1104                        flags & BDRV_O_NO_FLUSH);
1105     }
1106     if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
1107         qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
1108     }
1109 }
1110
1111 static void bdrv_assign_node_name(BlockDriverState *bs,
1112                                   const char *node_name,
1113                                   Error **errp)
1114 {
1115     char *gen_node_name = NULL;
1116
1117     if (!node_name) {
1118         node_name = gen_node_name = id_generate(ID_BLOCK);
1119     } else if (!id_wellformed(node_name)) {
1120         /*
1121          * Check for empty string or invalid characters, but not if it is
1122          * generated (generated names use characters not available to the user)
1123          */
1124         error_setg(errp, "Invalid node name");
1125         return;
1126     }
1127
1128     /* takes care of avoiding namespaces collisions */
1129     if (blk_by_name(node_name)) {
1130         error_setg(errp, "node-name=%s is conflicting with a device id",
1131                    node_name);
1132         goto out;
1133     }
1134
1135     /* takes care of avoiding duplicates node names */
1136     if (bdrv_find_node(node_name)) {
1137         error_setg(errp, "Duplicate node name");
1138         goto out;
1139     }
1140
1141     /* copy node name into the bs and insert it into the graph list */
1142     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1143     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
1144 out:
1145     g_free(gen_node_name);
1146 }
1147
1148 static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
1149                             const char *node_name, QDict *options,
1150                             int open_flags, Error **errp)
1151 {
1152     Error *local_err = NULL;
1153     int ret;
1154
1155     bdrv_assign_node_name(bs, node_name, &local_err);
1156     if (local_err) {
1157         error_propagate(errp, local_err);
1158         return -EINVAL;
1159     }
1160
1161     bs->drv = drv;
1162     bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1163     bs->opaque = g_malloc0(drv->instance_size);
1164
1165     if (drv->bdrv_file_open) {
1166         assert(!drv->bdrv_needs_filename || bs->filename[0]);
1167         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1168     } else if (drv->bdrv_open) {
1169         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1170     } else {
1171         ret = 0;
1172     }
1173
1174     if (ret < 0) {
1175         if (local_err) {
1176             error_propagate(errp, local_err);
1177         } else if (bs->filename[0]) {
1178             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1179         } else {
1180             error_setg_errno(errp, -ret, "Could not open image");
1181         }
1182         goto open_failed;
1183     }
1184
1185     ret = refresh_total_sectors(bs, bs->total_sectors);
1186     if (ret < 0) {
1187         error_setg_errno(errp, -ret, "Could not refresh total sector count");
1188         return ret;
1189     }
1190
1191     bdrv_refresh_limits(bs, &local_err);
1192     if (local_err) {
1193         error_propagate(errp, local_err);
1194         return -EINVAL;
1195     }
1196
1197     assert(bdrv_opt_mem_align(bs) != 0);
1198     assert(bdrv_min_mem_align(bs) != 0);
1199     assert(is_power_of_2(bs->bl.request_alignment));
1200
1201     return 0;
1202 open_failed:
1203     bs->drv = NULL;
1204     if (bs->file != NULL) {
1205         bdrv_unref_child(bs, bs->file);
1206         bs->file = NULL;
1207     }
1208     g_free(bs->opaque);
1209     bs->opaque = NULL;
1210     return ret;
1211 }
1212
1213 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1214                                        int flags, Error **errp)
1215 {
1216     BlockDriverState *bs;
1217     int ret;
1218
1219     bs = bdrv_new();
1220     bs->open_flags = flags;
1221     bs->explicit_options = qdict_new();
1222     bs->options = qdict_new();
1223     bs->opaque = NULL;
1224
1225     update_options_from_flags(bs->options, flags);
1226
1227     ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1228     if (ret < 0) {
1229         QDECREF(bs->explicit_options);
1230         bs->explicit_options = NULL;
1231         QDECREF(bs->options);
1232         bs->options = NULL;
1233         bdrv_unref(bs);
1234         return NULL;
1235     }
1236
1237     return bs;
1238 }
1239
1240 QemuOptsList bdrv_runtime_opts = {
1241     .name = "bdrv_common",
1242     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1243     .desc = {
1244         {
1245             .name = "node-name",
1246             .type = QEMU_OPT_STRING,
1247             .help = "Node name of the block device node",
1248         },
1249         {
1250             .name = "driver",
1251             .type = QEMU_OPT_STRING,
1252             .help = "Block driver to use for the node",
1253         },
1254         {
1255             .name = BDRV_OPT_CACHE_DIRECT,
1256             .type = QEMU_OPT_BOOL,
1257             .help = "Bypass software writeback cache on the host",
1258         },
1259         {
1260             .name = BDRV_OPT_CACHE_NO_FLUSH,
1261             .type = QEMU_OPT_BOOL,
1262             .help = "Ignore flush requests",
1263         },
1264         {
1265             .name = BDRV_OPT_READ_ONLY,
1266             .type = QEMU_OPT_BOOL,
1267             .help = "Node is opened in read-only mode",
1268         },
1269         {
1270             .name = "detect-zeroes",
1271             .type = QEMU_OPT_STRING,
1272             .help = "try to optimize zero writes (off, on, unmap)",
1273         },
1274         {
1275             .name = "discard",
1276             .type = QEMU_OPT_STRING,
1277             .help = "discard operation (ignore/off, unmap/on)",
1278         },
1279         {
1280             .name = BDRV_OPT_FORCE_SHARE,
1281             .type = QEMU_OPT_BOOL,
1282             .help = "always accept other writers (default: off)",
1283         },
1284         { /* end of list */ }
1285     },
1286 };
1287
1288 /*
1289  * Common part for opening disk images and files
1290  *
1291  * Removes all processed options from *options.
1292  */
1293 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
1294                             QDict *options, Error **errp)
1295 {
1296     int ret, open_flags;
1297     const char *filename;
1298     const char *driver_name = NULL;
1299     const char *node_name = NULL;
1300     const char *discard;
1301     const char *detect_zeroes;
1302     QemuOpts *opts;
1303     BlockDriver *drv;
1304     Error *local_err = NULL;
1305
1306     assert(bs->file == NULL);
1307     assert(options != NULL && bs->options != options);
1308
1309     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1310     qemu_opts_absorb_qdict(opts, options, &local_err);
1311     if (local_err) {
1312         error_propagate(errp, local_err);
1313         ret = -EINVAL;
1314         goto fail_opts;
1315     }
1316
1317     update_flags_from_options(&bs->open_flags, opts);
1318
1319     driver_name = qemu_opt_get(opts, "driver");
1320     drv = bdrv_find_format(driver_name);
1321     assert(drv != NULL);
1322
1323     bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1324
1325     if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1326         error_setg(errp,
1327                    BDRV_OPT_FORCE_SHARE
1328                    "=on can only be used with read-only images");
1329         ret = -EINVAL;
1330         goto fail_opts;
1331     }
1332
1333     if (file != NULL) {
1334         filename = blk_bs(file)->filename;
1335     } else {
1336         /*
1337          * Caution: while qdict_get_try_str() is fine, getting
1338          * non-string types would require more care.  When @options
1339          * come from -blockdev or blockdev_add, its members are typed
1340          * according to the QAPI schema, but when they come from
1341          * -drive, they're all QString.
1342          */
1343         filename = qdict_get_try_str(options, "filename");
1344     }
1345
1346     if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
1347         error_setg(errp, "The '%s' block driver requires a file name",
1348                    drv->format_name);
1349         ret = -EINVAL;
1350         goto fail_opts;
1351     }
1352
1353     trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1354                            drv->format_name);
1355
1356     bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1357
1358     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
1359         error_setg(errp,
1360                    !bs->read_only && bdrv_is_whitelisted(drv, true)
1361                         ? "Driver '%s' can only be used for read-only devices"
1362                         : "Driver '%s' is not whitelisted",
1363                    drv->format_name);
1364         ret = -ENOTSUP;
1365         goto fail_opts;
1366     }
1367
1368     /* bdrv_new() and bdrv_close() make it so */
1369     assert(atomic_read(&bs->copy_on_read) == 0);
1370
1371     if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1372         if (!bs->read_only) {
1373             bdrv_enable_copy_on_read(bs);
1374         } else {
1375             error_setg(errp, "Can't use copy-on-read on read-only device");
1376             ret = -EINVAL;
1377             goto fail_opts;
1378         }
1379     }
1380
1381     discard = qemu_opt_get(opts, "discard");
1382     if (discard != NULL) {
1383         if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1384             error_setg(errp, "Invalid discard option");
1385             ret = -EINVAL;
1386             goto fail_opts;
1387         }
1388     }
1389
1390     detect_zeroes = qemu_opt_get(opts, "detect-zeroes");
1391     if (detect_zeroes) {
1392         BlockdevDetectZeroesOptions value =
1393             qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
1394                             detect_zeroes,
1395                             BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
1396                             &local_err);
1397         if (local_err) {
1398             error_propagate(errp, local_err);
1399             ret = -EINVAL;
1400             goto fail_opts;
1401         }
1402
1403         if (value == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1404             !(bs->open_flags & BDRV_O_UNMAP))
1405         {
1406             error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1407                              "without setting discard operation to unmap");
1408             ret = -EINVAL;
1409             goto fail_opts;
1410         }
1411
1412         bs->detect_zeroes = value;
1413     }
1414
1415     if (filename != NULL) {
1416         pstrcpy(bs->filename, sizeof(bs->filename), filename);
1417     } else {
1418         bs->filename[0] = '\0';
1419     }
1420     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1421
1422     /* Open the image, either directly or using a protocol */
1423     open_flags = bdrv_open_flags(bs, bs->open_flags);
1424     node_name = qemu_opt_get(opts, "node-name");
1425
1426     assert(!drv->bdrv_file_open || file == NULL);
1427     ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
1428     if (ret < 0) {
1429         goto fail_opts;
1430     }
1431
1432     qemu_opts_del(opts);
1433     return 0;
1434
1435 fail_opts:
1436     qemu_opts_del(opts);
1437     return ret;
1438 }
1439
1440 static QDict *parse_json_filename(const char *filename, Error **errp)
1441 {
1442     QObject *options_obj;
1443     QDict *options;
1444     int ret;
1445
1446     ret = strstart(filename, "json:", &filename);
1447     assert(ret);
1448
1449     options_obj = qobject_from_json(filename, errp);
1450     if (!options_obj) {
1451         /* Work around qobject_from_json() lossage TODO fix that */
1452         if (errp && !*errp) {
1453             error_setg(errp, "Could not parse the JSON options");
1454             return NULL;
1455         }
1456         error_prepend(errp, "Could not parse the JSON options: ");
1457         return NULL;
1458     }
1459
1460     options = qobject_to_qdict(options_obj);
1461     if (!options) {
1462         qobject_decref(options_obj);
1463         error_setg(errp, "Invalid JSON object given");
1464         return NULL;
1465     }
1466
1467     qdict_flatten(options);
1468
1469     return options;
1470 }
1471
1472 static void parse_json_protocol(QDict *options, const char **pfilename,
1473                                 Error **errp)
1474 {
1475     QDict *json_options;
1476     Error *local_err = NULL;
1477
1478     /* Parse json: pseudo-protocol */
1479     if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1480         return;
1481     }
1482
1483     json_options = parse_json_filename(*pfilename, &local_err);
1484     if (local_err) {
1485         error_propagate(errp, local_err);
1486         return;
1487     }
1488
1489     /* Options given in the filename have lower priority than options
1490      * specified directly */
1491     qdict_join(options, json_options, false);
1492     QDECREF(json_options);
1493     *pfilename = NULL;
1494 }
1495
1496 /*
1497  * Fills in default options for opening images and converts the legacy
1498  * filename/flags pair to option QDict entries.
1499  * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1500  * block driver has been specified explicitly.
1501  */
1502 static int bdrv_fill_options(QDict **options, const char *filename,
1503                              int *flags, Error **errp)
1504 {
1505     const char *drvname;
1506     bool protocol = *flags & BDRV_O_PROTOCOL;
1507     bool parse_filename = false;
1508     BlockDriver *drv = NULL;
1509     Error *local_err = NULL;
1510
1511     /*
1512      * Caution: while qdict_get_try_str() is fine, getting non-string
1513      * types would require more care.  When @options come from
1514      * -blockdev or blockdev_add, its members are typed according to
1515      * the QAPI schema, but when they come from -drive, they're all
1516      * QString.
1517      */
1518     drvname = qdict_get_try_str(*options, "driver");
1519     if (drvname) {
1520         drv = bdrv_find_format(drvname);
1521         if (!drv) {
1522             error_setg(errp, "Unknown driver '%s'", drvname);
1523             return -ENOENT;
1524         }
1525         /* If the user has explicitly specified the driver, this choice should
1526          * override the BDRV_O_PROTOCOL flag */
1527         protocol = drv->bdrv_file_open;
1528     }
1529
1530     if (protocol) {
1531         *flags |= BDRV_O_PROTOCOL;
1532     } else {
1533         *flags &= ~BDRV_O_PROTOCOL;
1534     }
1535
1536     /* Translate cache options from flags into options */
1537     update_options_from_flags(*options, *flags);
1538
1539     /* Fetch the file name from the options QDict if necessary */
1540     if (protocol && filename) {
1541         if (!qdict_haskey(*options, "filename")) {
1542             qdict_put_str(*options, "filename", filename);
1543             parse_filename = true;
1544         } else {
1545             error_setg(errp, "Can't specify 'file' and 'filename' options at "
1546                              "the same time");
1547             return -EINVAL;
1548         }
1549     }
1550
1551     /* Find the right block driver */
1552     /* See cautionary note on accessing @options above */
1553     filename = qdict_get_try_str(*options, "filename");
1554
1555     if (!drvname && protocol) {
1556         if (filename) {
1557             drv = bdrv_find_protocol(filename, parse_filename, errp);
1558             if (!drv) {
1559                 return -EINVAL;
1560             }
1561
1562             drvname = drv->format_name;
1563             qdict_put_str(*options, "driver", drvname);
1564         } else {
1565             error_setg(errp, "Must specify either driver or file");
1566             return -EINVAL;
1567         }
1568     }
1569
1570     assert(drv || !protocol);
1571
1572     /* Driver-specific filename parsing */
1573     if (drv && drv->bdrv_parse_filename && parse_filename) {
1574         drv->bdrv_parse_filename(filename, *options, &local_err);
1575         if (local_err) {
1576             error_propagate(errp, local_err);
1577             return -EINVAL;
1578         }
1579
1580         if (!drv->bdrv_needs_filename) {
1581             qdict_del(*options, "filename");
1582         }
1583     }
1584
1585     return 0;
1586 }
1587
1588 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1589                                  uint64_t perm, uint64_t shared,
1590                                  GSList *ignore_children, Error **errp);
1591 static void bdrv_child_abort_perm_update(BdrvChild *c);
1592 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
1593
1594 typedef struct BlockReopenQueueEntry {
1595      bool prepared;
1596      BDRVReopenState state;
1597      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1598 } BlockReopenQueueEntry;
1599
1600 /*
1601  * Return the flags that @bs will have after the reopens in @q have
1602  * successfully completed. If @q is NULL (or @bs is not contained in @q),
1603  * return the current flags.
1604  */
1605 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
1606 {
1607     BlockReopenQueueEntry *entry;
1608
1609     if (q != NULL) {
1610         QSIMPLEQ_FOREACH(entry, q, entry) {
1611             if (entry->state.bs == bs) {
1612                 return entry->state.flags;
1613             }
1614         }
1615     }
1616
1617     return bs->open_flags;
1618 }
1619
1620 /* Returns whether the image file can be written to after the reopen queue @q
1621  * has been successfully applied, or right now if @q is NULL. */
1622 static bool bdrv_is_writable(BlockDriverState *bs, BlockReopenQueue *q)
1623 {
1624     int flags = bdrv_reopen_get_flags(q, bs);
1625
1626     return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
1627 }
1628
1629 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
1630                             BdrvChild *c, const BdrvChildRole *role,
1631                             BlockReopenQueue *reopen_queue,
1632                             uint64_t parent_perm, uint64_t parent_shared,
1633                             uint64_t *nperm, uint64_t *nshared)
1634 {
1635     if (bs->drv && bs->drv->bdrv_child_perm) {
1636         bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
1637                                  parent_perm, parent_shared,
1638                                  nperm, nshared);
1639     }
1640     /* TODO Take force_share from reopen_queue */
1641     if (child_bs && child_bs->force_share) {
1642         *nshared = BLK_PERM_ALL;
1643     }
1644 }
1645
1646 /*
1647  * Check whether permissions on this node can be changed in a way that
1648  * @cumulative_perms and @cumulative_shared_perms are the new cumulative
1649  * permissions of all its parents. This involves checking whether all necessary
1650  * permission changes to child nodes can be performed.
1651  *
1652  * A call to this function must always be followed by a call to bdrv_set_perm()
1653  * or bdrv_abort_perm_update().
1654  */
1655 static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
1656                            uint64_t cumulative_perms,
1657                            uint64_t cumulative_shared_perms,
1658                            GSList *ignore_children, Error **errp)
1659 {
1660     BlockDriver *drv = bs->drv;
1661     BdrvChild *c;
1662     int ret;
1663
1664     /* Write permissions never work with read-only images */
1665     if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
1666         !bdrv_is_writable(bs, q))
1667     {
1668         error_setg(errp, "Block node is read-only");
1669         return -EPERM;
1670     }
1671
1672     /* Check this node */
1673     if (!drv) {
1674         return 0;
1675     }
1676
1677     if (drv->bdrv_check_perm) {
1678         return drv->bdrv_check_perm(bs, cumulative_perms,
1679                                     cumulative_shared_perms, errp);
1680     }
1681
1682     /* Drivers that never have children can omit .bdrv_child_perm() */
1683     if (!drv->bdrv_child_perm) {
1684         assert(QLIST_EMPTY(&bs->children));
1685         return 0;
1686     }
1687
1688     /* Check all children */
1689     QLIST_FOREACH(c, &bs->children, next) {
1690         uint64_t cur_perm, cur_shared;
1691         bdrv_child_perm(bs, c->bs, c, c->role, q,
1692                         cumulative_perms, cumulative_shared_perms,
1693                         &cur_perm, &cur_shared);
1694         ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared,
1695                                     ignore_children, errp);
1696         if (ret < 0) {
1697             return ret;
1698         }
1699     }
1700
1701     return 0;
1702 }
1703
1704 /*
1705  * Notifies drivers that after a previous bdrv_check_perm() call, the
1706  * permission update is not performed and any preparations made for it (e.g.
1707  * taken file locks) need to be undone.
1708  *
1709  * This function recursively notifies all child nodes.
1710  */
1711 static void bdrv_abort_perm_update(BlockDriverState *bs)
1712 {
1713     BlockDriver *drv = bs->drv;
1714     BdrvChild *c;
1715
1716     if (!drv) {
1717         return;
1718     }
1719
1720     if (drv->bdrv_abort_perm_update) {
1721         drv->bdrv_abort_perm_update(bs);
1722     }
1723
1724     QLIST_FOREACH(c, &bs->children, next) {
1725         bdrv_child_abort_perm_update(c);
1726     }
1727 }
1728
1729 static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
1730                           uint64_t cumulative_shared_perms)
1731 {
1732     BlockDriver *drv = bs->drv;
1733     BdrvChild *c;
1734
1735     if (!drv) {
1736         return;
1737     }
1738
1739     /* Update this node */
1740     if (drv->bdrv_set_perm) {
1741         drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
1742     }
1743
1744     /* Drivers that never have children can omit .bdrv_child_perm() */
1745     if (!drv->bdrv_child_perm) {
1746         assert(QLIST_EMPTY(&bs->children));
1747         return;
1748     }
1749
1750     /* Update all children */
1751     QLIST_FOREACH(c, &bs->children, next) {
1752         uint64_t cur_perm, cur_shared;
1753         bdrv_child_perm(bs, c->bs, c, c->role, NULL,
1754                         cumulative_perms, cumulative_shared_perms,
1755                         &cur_perm, &cur_shared);
1756         bdrv_child_set_perm(c, cur_perm, cur_shared);
1757     }
1758 }
1759
1760 static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
1761                                      uint64_t *shared_perm)
1762 {
1763     BdrvChild *c;
1764     uint64_t cumulative_perms = 0;
1765     uint64_t cumulative_shared_perms = BLK_PERM_ALL;
1766
1767     QLIST_FOREACH(c, &bs->parents, next_parent) {
1768         cumulative_perms |= c->perm;
1769         cumulative_shared_perms &= c->shared_perm;
1770     }
1771
1772     *perm = cumulative_perms;
1773     *shared_perm = cumulative_shared_perms;
1774 }
1775
1776 static char *bdrv_child_user_desc(BdrvChild *c)
1777 {
1778     if (c->role->get_parent_desc) {
1779         return c->role->get_parent_desc(c);
1780     }
1781
1782     return g_strdup("another user");
1783 }
1784
1785 char *bdrv_perm_names(uint64_t perm)
1786 {
1787     struct perm_name {
1788         uint64_t perm;
1789         const char *name;
1790     } permissions[] = {
1791         { BLK_PERM_CONSISTENT_READ, "consistent read" },
1792         { BLK_PERM_WRITE,           "write" },
1793         { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
1794         { BLK_PERM_RESIZE,          "resize" },
1795         { BLK_PERM_GRAPH_MOD,       "change children" },
1796         { 0, NULL }
1797     };
1798
1799     char *result = g_strdup("");
1800     struct perm_name *p;
1801
1802     for (p = permissions; p->name; p++) {
1803         if (perm & p->perm) {
1804             char *old = result;
1805             result = g_strdup_printf("%s%s%s", old, *old ? ", " : "", p->name);
1806             g_free(old);
1807         }
1808     }
1809
1810     return result;
1811 }
1812
1813 /*
1814  * Checks whether a new reference to @bs can be added if the new user requires
1815  * @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is
1816  * set, the BdrvChild objects in this list are ignored in the calculations;
1817  * this allows checking permission updates for an existing reference.
1818  *
1819  * Needs to be followed by a call to either bdrv_set_perm() or
1820  * bdrv_abort_perm_update(). */
1821 static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q,
1822                                   uint64_t new_used_perm,
1823                                   uint64_t new_shared_perm,
1824                                   GSList *ignore_children, Error **errp)
1825 {
1826     BdrvChild *c;
1827     uint64_t cumulative_perms = new_used_perm;
1828     uint64_t cumulative_shared_perms = new_shared_perm;
1829
1830     /* There is no reason why anyone couldn't tolerate write_unchanged */
1831     assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED);
1832
1833     QLIST_FOREACH(c, &bs->parents, next_parent) {
1834         if (g_slist_find(ignore_children, c)) {
1835             continue;
1836         }
1837
1838         if ((new_used_perm & c->shared_perm) != new_used_perm) {
1839             char *user = bdrv_child_user_desc(c);
1840             char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm);
1841             error_setg(errp, "Conflicts with use by %s as '%s', which does not "
1842                              "allow '%s' on %s",
1843                        user, c->name, perm_names, bdrv_get_node_name(c->bs));
1844             g_free(user);
1845             g_free(perm_names);
1846             return -EPERM;
1847         }
1848
1849         if ((c->perm & new_shared_perm) != c->perm) {
1850             char *user = bdrv_child_user_desc(c);
1851             char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm);
1852             error_setg(errp, "Conflicts with use by %s as '%s', which uses "
1853                              "'%s' on %s",
1854                        user, c->name, perm_names, bdrv_get_node_name(c->bs));
1855             g_free(user);
1856             g_free(perm_names);
1857             return -EPERM;
1858         }
1859
1860         cumulative_perms |= c->perm;
1861         cumulative_shared_perms &= c->shared_perm;
1862     }
1863
1864     return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms,
1865                            ignore_children, errp);
1866 }
1867
1868 /* Needs to be followed by a call to either bdrv_child_set_perm() or
1869  * bdrv_child_abort_perm_update(). */
1870 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1871                                  uint64_t perm, uint64_t shared,
1872                                  GSList *ignore_children, Error **errp)
1873 {
1874     int ret;
1875
1876     ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c);
1877     ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, errp);
1878     g_slist_free(ignore_children);
1879
1880     return ret;
1881 }
1882
1883 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)
1884 {
1885     uint64_t cumulative_perms, cumulative_shared_perms;
1886
1887     c->perm = perm;
1888     c->shared_perm = shared;
1889
1890     bdrv_get_cumulative_perm(c->bs, &cumulative_perms,
1891                              &cumulative_shared_perms);
1892     bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);
1893 }
1894
1895 static void bdrv_child_abort_perm_update(BdrvChild *c)
1896 {
1897     bdrv_abort_perm_update(c->bs);
1898 }
1899
1900 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
1901                             Error **errp)
1902 {
1903     int ret;
1904
1905     ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, errp);
1906     if (ret < 0) {
1907         bdrv_child_abort_perm_update(c);
1908         return ret;
1909     }
1910
1911     bdrv_child_set_perm(c, perm, shared);
1912
1913     return 0;
1914 }
1915
1916 #define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
1917                                  | BLK_PERM_WRITE \
1918                                  | BLK_PERM_WRITE_UNCHANGED \
1919                                  | BLK_PERM_RESIZE)
1920 #define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
1921
1922 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
1923                                const BdrvChildRole *role,
1924                                BlockReopenQueue *reopen_queue,
1925                                uint64_t perm, uint64_t shared,
1926                                uint64_t *nperm, uint64_t *nshared)
1927 {
1928     if (c == NULL) {
1929         *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
1930         *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
1931         return;
1932     }
1933
1934     *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
1935              (c->perm & DEFAULT_PERM_UNCHANGED);
1936     *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
1937                (c->shared_perm & DEFAULT_PERM_UNCHANGED);
1938 }
1939
1940 void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
1941                                const BdrvChildRole *role,
1942                                BlockReopenQueue *reopen_queue,
1943                                uint64_t perm, uint64_t shared,
1944                                uint64_t *nperm, uint64_t *nshared)
1945 {
1946     bool backing = (role == &child_backing);
1947     assert(role == &child_backing || role == &child_file);
1948
1949     if (!backing) {
1950         int flags = bdrv_reopen_get_flags(reopen_queue, bs);
1951
1952         /* Apart from the modifications below, the same permissions are
1953          * forwarded and left alone as for filters */
1954         bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
1955                                   &perm, &shared);
1956
1957         /* Format drivers may touch metadata even if the guest doesn't write */
1958         if (bdrv_is_writable(bs, reopen_queue)) {
1959             perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1960         }
1961
1962         /* bs->file always needs to be consistent because of the metadata. We
1963          * can never allow other users to resize or write to it. */
1964         if (!(flags & BDRV_O_NO_IO)) {
1965             perm |= BLK_PERM_CONSISTENT_READ;
1966         }
1967         shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
1968     } else {
1969         /* We want consistent read from backing files if the parent needs it.
1970          * No other operations are performed on backing files. */
1971         perm &= BLK_PERM_CONSISTENT_READ;
1972
1973         /* If the parent can deal with changing data, we're okay with a
1974          * writable and resizable backing file. */
1975         /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
1976         if (shared & BLK_PERM_WRITE) {
1977             shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
1978         } else {
1979             shared = 0;
1980         }
1981
1982         shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
1983                   BLK_PERM_WRITE_UNCHANGED;
1984     }
1985
1986     if (bs->open_flags & BDRV_O_INACTIVE) {
1987         shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1988     }
1989
1990     *nperm = perm;
1991     *nshared = shared;
1992 }
1993
1994 static void bdrv_replace_child_noperm(BdrvChild *child,
1995                                       BlockDriverState *new_bs)
1996 {
1997     BlockDriverState *old_bs = child->bs;
1998     int i;
1999
2000     if (old_bs && new_bs) {
2001         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
2002     }
2003     if (old_bs) {
2004         /* Detach first so that the recursive drain sections coming from @child
2005          * are already gone and we only end the drain sections that came from
2006          * elsewhere. */
2007         if (child->role->detach) {
2008             child->role->detach(child);
2009         }
2010         if (old_bs->quiesce_counter && child->role->drained_end) {
2011             for (i = 0; i < old_bs->quiesce_counter; i++) {
2012                 child->role->drained_end(child);
2013             }
2014         }
2015         QLIST_REMOVE(child, next_parent);
2016     }
2017
2018     child->bs = new_bs;
2019
2020     if (new_bs) {
2021         QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
2022         if (new_bs->quiesce_counter && child->role->drained_begin) {
2023             for (i = 0; i < new_bs->quiesce_counter; i++) {
2024                 child->role->drained_begin(child);
2025             }
2026         }
2027
2028         /* Attach only after starting new drained sections, so that recursive
2029          * drain sections coming from @child don't get an extra .drained_begin
2030          * callback. */
2031         if (child->role->attach) {
2032             child->role->attach(child);
2033         }
2034     }
2035 }
2036
2037 /*
2038  * Updates @child to change its reference to point to @new_bs, including
2039  * checking and applying the necessary permisson updates both to the old node
2040  * and to @new_bs.
2041  *
2042  * NULL is passed as @new_bs for removing the reference before freeing @child.
2043  *
2044  * If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this
2045  * function uses bdrv_set_perm() to update the permissions according to the new
2046  * reference that @new_bs gets.
2047  */
2048 static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
2049 {
2050     BlockDriverState *old_bs = child->bs;
2051     uint64_t perm, shared_perm;
2052
2053     bdrv_replace_child_noperm(child, new_bs);
2054
2055     if (old_bs) {
2056         /* Update permissions for old node. This is guaranteed to succeed
2057          * because we're just taking a parent away, so we're loosening
2058          * restrictions. */
2059         bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);
2060         bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort);
2061         bdrv_set_perm(old_bs, perm, shared_perm);
2062     }
2063
2064     if (new_bs) {
2065         bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);
2066         bdrv_set_perm(new_bs, perm, shared_perm);
2067     }
2068 }
2069
2070 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
2071                                   const char *child_name,
2072                                   const BdrvChildRole *child_role,
2073                                   uint64_t perm, uint64_t shared_perm,
2074                                   void *opaque, Error **errp)
2075 {
2076     BdrvChild *child;
2077     int ret;
2078
2079     ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp);
2080     if (ret < 0) {
2081         bdrv_abort_perm_update(child_bs);
2082         return NULL;
2083     }
2084
2085     child = g_new(BdrvChild, 1);
2086     *child = (BdrvChild) {
2087         .bs             = NULL,
2088         .name           = g_strdup(child_name),
2089         .role           = child_role,
2090         .perm           = perm,
2091         .shared_perm    = shared_perm,
2092         .opaque         = opaque,
2093     };
2094
2095     /* This performs the matching bdrv_set_perm() for the above check. */
2096     bdrv_replace_child(child, child_bs);
2097
2098     return child;
2099 }
2100
2101 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
2102                              BlockDriverState *child_bs,
2103                              const char *child_name,
2104                              const BdrvChildRole *child_role,
2105                              Error **errp)
2106 {
2107     BdrvChild *child;
2108     uint64_t perm, shared_perm;
2109
2110     bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
2111
2112     assert(parent_bs->drv);
2113     assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs));
2114     bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
2115                     perm, shared_perm, &perm, &shared_perm);
2116
2117     child = bdrv_root_attach_child(child_bs, child_name, child_role,
2118                                    perm, shared_perm, parent_bs, errp);
2119     if (child == NULL) {
2120         return NULL;
2121     }
2122
2123     QLIST_INSERT_HEAD(&parent_bs->children, child, next);
2124     return child;
2125 }
2126
2127 static void bdrv_detach_child(BdrvChild *child)
2128 {
2129     if (child->next.le_prev) {
2130         QLIST_REMOVE(child, next);
2131         child->next.le_prev = NULL;
2132     }
2133
2134     bdrv_replace_child(child, NULL);
2135
2136     g_free(child->name);
2137     g_free(child);
2138 }
2139
2140 void bdrv_root_unref_child(BdrvChild *child)
2141 {
2142     BlockDriverState *child_bs;
2143
2144     child_bs = child->bs;
2145     bdrv_detach_child(child);
2146     bdrv_unref(child_bs);
2147 }
2148
2149 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
2150 {
2151     if (child == NULL) {
2152         return;
2153     }
2154
2155     if (child->bs->inherits_from == parent) {
2156         BdrvChild *c;
2157
2158         /* Remove inherits_from only when the last reference between parent and
2159          * child->bs goes away. */
2160         QLIST_FOREACH(c, &parent->children, next) {
2161             if (c != child && c->bs == child->bs) {
2162                 break;
2163             }
2164         }
2165         if (c == NULL) {
2166             child->bs->inherits_from = NULL;
2167         }
2168     }
2169
2170     bdrv_root_unref_child(child);
2171 }
2172
2173
2174 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
2175 {
2176     BdrvChild *c;
2177     QLIST_FOREACH(c, &bs->parents, next_parent) {
2178         if (c->role->change_media) {
2179             c->role->change_media(c, load);
2180         }
2181     }
2182 }
2183
2184 static void bdrv_parent_cb_resize(BlockDriverState *bs)
2185 {
2186     BdrvChild *c;
2187     QLIST_FOREACH(c, &bs->parents, next_parent) {
2188         if (c->role->resize) {
2189             c->role->resize(c);
2190         }
2191     }
2192 }
2193
2194 /*
2195  * Sets the backing file link of a BDS. A new reference is created; callers
2196  * which don't need their own reference any more must call bdrv_unref().
2197  */
2198 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
2199                          Error **errp)
2200 {
2201     if (backing_hd) {
2202         bdrv_ref(backing_hd);
2203     }
2204
2205     if (bs->backing) {
2206         bdrv_unref_child(bs, bs->backing);
2207     }
2208
2209     if (!backing_hd) {
2210         bs->backing = NULL;
2211         goto out;
2212     }
2213
2214     bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
2215                                     errp);
2216     if (!bs->backing) {
2217         bdrv_unref(backing_hd);
2218     }
2219
2220     bdrv_refresh_filename(bs);
2221
2222 out:
2223     bdrv_refresh_limits(bs, NULL);
2224 }
2225
2226 /*
2227  * Opens the backing file for a BlockDriverState if not yet open
2228  *
2229  * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
2230  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2231  * itself, all options starting with "${bdref_key}." are considered part of the
2232  * BlockdevRef.
2233  *
2234  * TODO Can this be unified with bdrv_open_image()?
2235  */
2236 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
2237                            const char *bdref_key, Error **errp)
2238 {
2239     char *backing_filename = g_malloc0(PATH_MAX);
2240     char *bdref_key_dot;
2241     const char *reference = NULL;
2242     int ret = 0;
2243     BlockDriverState *backing_hd;
2244     QDict *options;
2245     QDict *tmp_parent_options = NULL;
2246     Error *local_err = NULL;
2247
2248     if (bs->backing != NULL) {
2249         goto free_exit;
2250     }
2251
2252     /* NULL means an empty set of options */
2253     if (parent_options == NULL) {
2254         tmp_parent_options = qdict_new();
2255         parent_options = tmp_parent_options;
2256     }
2257
2258     bs->open_flags &= ~BDRV_O_NO_BACKING;
2259
2260     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2261     qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
2262     g_free(bdref_key_dot);
2263
2264     /*
2265      * Caution: while qdict_get_try_str() is fine, getting non-string
2266      * types would require more care.  When @parent_options come from
2267      * -blockdev or blockdev_add, its members are typed according to
2268      * the QAPI schema, but when they come from -drive, they're all
2269      * QString.
2270      */
2271     reference = qdict_get_try_str(parent_options, bdref_key);
2272     if (reference || qdict_haskey(options, "file.filename")) {
2273         backing_filename[0] = '\0';
2274     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
2275         QDECREF(options);
2276         goto free_exit;
2277     } else {
2278         bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
2279                                        &local_err);
2280         if (local_err) {
2281             ret = -EINVAL;
2282             error_propagate(errp, local_err);
2283             QDECREF(options);
2284             goto free_exit;
2285         }
2286     }
2287
2288     if (!bs->drv || !bs->drv->supports_backing) {
2289         ret = -EINVAL;
2290         error_setg(errp, "Driver doesn't support backing files");
2291         QDECREF(options);
2292         goto free_exit;
2293     }
2294
2295     if (!reference &&
2296         bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
2297         qdict_put_str(options, "driver", bs->backing_format);
2298     }
2299
2300     backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
2301                                    reference, options, 0, bs, &child_backing,
2302                                    errp);
2303     if (!backing_hd) {
2304         bs->open_flags |= BDRV_O_NO_BACKING;
2305         error_prepend(errp, "Could not open backing file: ");
2306         ret = -EINVAL;
2307         goto free_exit;
2308     }
2309     bdrv_set_aio_context(backing_hd, bdrv_get_aio_context(bs));
2310
2311     /* Hook up the backing file link; drop our reference, bs owns the
2312      * backing_hd reference now */
2313     bdrv_set_backing_hd(bs, backing_hd, &local_err);
2314     bdrv_unref(backing_hd);
2315     if (local_err) {
2316         error_propagate(errp, local_err);
2317         ret = -EINVAL;
2318         goto free_exit;
2319     }
2320
2321     qdict_del(parent_options, bdref_key);
2322
2323 free_exit:
2324     g_free(backing_filename);
2325     QDECREF(tmp_parent_options);
2326     return ret;
2327 }
2328
2329 static BlockDriverState *
2330 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
2331                    BlockDriverState *parent, const BdrvChildRole *child_role,
2332                    bool allow_none, Error **errp)
2333 {
2334     BlockDriverState *bs = NULL;
2335     QDict *image_options;
2336     char *bdref_key_dot;
2337     const char *reference;
2338
2339     assert(child_role != NULL);
2340
2341     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2342     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
2343     g_free(bdref_key_dot);
2344
2345     /*
2346      * Caution: while qdict_get_try_str() is fine, getting non-string
2347      * types would require more care.  When @options come from
2348      * -blockdev or blockdev_add, its members are typed according to
2349      * the QAPI schema, but when they come from -drive, they're all
2350      * QString.
2351      */
2352     reference = qdict_get_try_str(options, bdref_key);
2353     if (!filename && !reference && !qdict_size(image_options)) {
2354         if (!allow_none) {
2355             error_setg(errp, "A block device must be specified for \"%s\"",
2356                        bdref_key);
2357         }
2358         QDECREF(image_options);
2359         goto done;
2360     }
2361
2362     bs = bdrv_open_inherit(filename, reference, image_options, 0,
2363                            parent, child_role, errp);
2364     if (!bs) {
2365         goto done;
2366     }
2367
2368 done:
2369     qdict_del(options, bdref_key);
2370     return bs;
2371 }
2372
2373 /*
2374  * Opens a disk image whose options are given as BlockdevRef in another block
2375  * device's options.
2376  *
2377  * If allow_none is true, no image will be opened if filename is false and no
2378  * BlockdevRef is given. NULL will be returned, but errp remains unset.
2379  *
2380  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
2381  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2382  * itself, all options starting with "${bdref_key}." are considered part of the
2383  * BlockdevRef.
2384  *
2385  * The BlockdevRef will be removed from the options QDict.
2386  */
2387 BdrvChild *bdrv_open_child(const char *filename,
2388                            QDict *options, const char *bdref_key,
2389                            BlockDriverState *parent,
2390                            const BdrvChildRole *child_role,
2391                            bool allow_none, Error **errp)
2392 {
2393     BdrvChild *c;
2394     BlockDriverState *bs;
2395
2396     bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
2397                             allow_none, errp);
2398     if (bs == NULL) {
2399         return NULL;
2400     }
2401
2402     c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
2403     if (!c) {
2404         bdrv_unref(bs);
2405         return NULL;
2406     }
2407
2408     return c;
2409 }
2410
2411 /* TODO Future callers may need to specify parent/child_role in order for
2412  * option inheritance to work. Existing callers use it for the root node. */
2413 BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
2414 {
2415     BlockDriverState *bs = NULL;
2416     Error *local_err = NULL;
2417     QObject *obj = NULL;
2418     QDict *qdict = NULL;
2419     const char *reference = NULL;
2420     Visitor *v = NULL;
2421
2422     if (ref->type == QTYPE_QSTRING) {
2423         reference = ref->u.reference;
2424     } else {
2425         BlockdevOptions *options = &ref->u.definition;
2426         assert(ref->type == QTYPE_QDICT);
2427
2428         v = qobject_output_visitor_new(&obj);
2429         visit_type_BlockdevOptions(v, NULL, &options, &local_err);
2430         if (local_err) {
2431             error_propagate(errp, local_err);
2432             goto fail;
2433         }
2434         visit_complete(v, &obj);
2435
2436         qdict = qobject_to_qdict(obj);
2437         qdict_flatten(qdict);
2438
2439         /* bdrv_open_inherit() defaults to the values in bdrv_flags (for
2440          * compatibility with other callers) rather than what we want as the
2441          * real defaults. Apply the defaults here instead. */
2442         qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
2443         qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
2444         qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
2445     }
2446
2447     bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp);
2448     obj = NULL;
2449
2450 fail:
2451     qobject_decref(obj);
2452     visit_free(v);
2453     return bs;
2454 }
2455
2456 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
2457                                                    int flags,
2458                                                    QDict *snapshot_options,
2459                                                    Error **errp)
2460 {
2461     /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
2462     char *tmp_filename = g_malloc0(PATH_MAX + 1);
2463     int64_t total_size;
2464     QemuOpts *opts = NULL;
2465     BlockDriverState *bs_snapshot = NULL;
2466     Error *local_err = NULL;
2467     int ret;
2468
2469     /* if snapshot, we create a temporary backing file and open it
2470        instead of opening 'filename' directly */
2471
2472     /* Get the required size from the image */
2473     total_size = bdrv_getlength(bs);
2474     if (total_size < 0) {
2475         error_setg_errno(errp, -total_size, "Could not get image size");
2476         goto out;
2477     }
2478
2479     /* Create the temporary image */
2480     ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
2481     if (ret < 0) {
2482         error_setg_errno(errp, -ret, "Could not get temporary filename");
2483         goto out;
2484     }
2485
2486     opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
2487                             &error_abort);
2488     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
2489     ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
2490     qemu_opts_del(opts);
2491     if (ret < 0) {
2492         error_prepend(errp, "Could not create temporary overlay '%s': ",
2493                       tmp_filename);
2494         goto out;
2495     }
2496
2497     /* Prepare options QDict for the temporary file */
2498     qdict_put_str(snapshot_options, "file.driver", "file");
2499     qdict_put_str(snapshot_options, "file.filename", tmp_filename);
2500     qdict_put_str(snapshot_options, "driver", "qcow2");
2501
2502     bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
2503     snapshot_options = NULL;
2504     if (!bs_snapshot) {
2505         goto out;
2506     }
2507
2508     /* bdrv_append() consumes a strong reference to bs_snapshot
2509      * (i.e. it will call bdrv_unref() on it) even on error, so in
2510      * order to be able to return one, we have to increase
2511      * bs_snapshot's refcount here */
2512     bdrv_ref(bs_snapshot);
2513     bdrv_append(bs_snapshot, bs, &local_err);
2514     if (local_err) {
2515         error_propagate(errp, local_err);
2516         bs_snapshot = NULL;
2517         goto out;
2518     }
2519
2520 out:
2521     QDECREF(snapshot_options);
2522     g_free(tmp_filename);
2523     return bs_snapshot;
2524 }
2525
2526 /*
2527  * Opens a disk image (raw, qcow2, vmdk, ...)
2528  *
2529  * options is a QDict of options to pass to the block drivers, or NULL for an
2530  * empty set of options. The reference to the QDict belongs to the block layer
2531  * after the call (even on failure), so if the caller intends to reuse the
2532  * dictionary, it needs to use QINCREF() before calling bdrv_open.
2533  *
2534  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
2535  * If it is not NULL, the referenced BDS will be reused.
2536  *
2537  * The reference parameter may be used to specify an existing block device which
2538  * should be opened. If specified, neither options nor a filename may be given,
2539  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
2540  */
2541 static BlockDriverState *bdrv_open_inherit(const char *filename,
2542                                            const char *reference,
2543                                            QDict *options, int flags,
2544                                            BlockDriverState *parent,
2545                                            const BdrvChildRole *child_role,
2546                                            Error **errp)
2547 {
2548     int ret;
2549     BlockBackend *file = NULL;
2550     BlockDriverState *bs;
2551     BlockDriver *drv = NULL;
2552     const char *drvname;
2553     const char *backing;
2554     Error *local_err = NULL;
2555     QDict *snapshot_options = NULL;
2556     int snapshot_flags = 0;
2557
2558     assert(!child_role || !flags);
2559     assert(!child_role == !parent);
2560
2561     if (reference) {
2562         bool options_non_empty = options ? qdict_size(options) : false;
2563         QDECREF(options);
2564
2565         if (filename || options_non_empty) {
2566             error_setg(errp, "Cannot reference an existing block device with "
2567                        "additional options or a new filename");
2568             return NULL;
2569         }
2570
2571         bs = bdrv_lookup_bs(reference, reference, errp);
2572         if (!bs) {
2573             return NULL;
2574         }
2575
2576         bdrv_ref(bs);
2577         return bs;
2578     }
2579
2580     bs = bdrv_new();
2581
2582     /* NULL means an empty set of options */
2583     if (options == NULL) {
2584         options = qdict_new();
2585     }
2586
2587     /* json: syntax counts as explicit options, as if in the QDict */
2588     parse_json_protocol(options, &filename, &local_err);
2589     if (local_err) {
2590         goto fail;
2591     }
2592
2593     bs->explicit_options = qdict_clone_shallow(options);
2594
2595     if (child_role) {
2596         bs->inherits_from = parent;
2597         child_role->inherit_options(&flags, options,
2598                                     parent->open_flags, parent->options);
2599     }
2600
2601     ret = bdrv_fill_options(&options, filename, &flags, &local_err);
2602     if (local_err) {
2603         goto fail;
2604     }
2605
2606     /*
2607      * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
2608      * Caution: getting a boolean member of @options requires care.
2609      * When @options come from -blockdev or blockdev_add, members are
2610      * typed according to the QAPI schema, but when they come from
2611      * -drive, they're all QString.
2612      */
2613     if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
2614         !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
2615         flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
2616     } else {
2617         flags &= ~BDRV_O_RDWR;
2618     }
2619
2620     if (flags & BDRV_O_SNAPSHOT) {
2621         snapshot_options = qdict_new();
2622         bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
2623                                    flags, options);
2624         /* Let bdrv_backing_options() override "read-only" */
2625         qdict_del(options, BDRV_OPT_READ_ONLY);
2626         bdrv_backing_options(&flags, options, flags, options);
2627     }
2628
2629     bs->open_flags = flags;
2630     bs->options = options;
2631     options = qdict_clone_shallow(options);
2632
2633     /* Find the right image format driver */
2634     /* See cautionary note on accessing @options above */
2635     drvname = qdict_get_try_str(options, "driver");
2636     if (drvname) {
2637         drv = bdrv_find_format(drvname);
2638         if (!drv) {
2639             error_setg(errp, "Unknown driver: '%s'", drvname);
2640             goto fail;
2641         }
2642     }
2643
2644     assert(drvname || !(flags & BDRV_O_PROTOCOL));
2645
2646     /* See cautionary note on accessing @options above */
2647     backing = qdict_get_try_str(options, "backing");
2648     if (backing && *backing == '\0') {
2649         flags |= BDRV_O_NO_BACKING;
2650         qdict_del(options, "backing");
2651     }
2652
2653     /* Open image file without format layer. This BlockBackend is only used for
2654      * probing, the block drivers will do their own bdrv_open_child() for the
2655      * same BDS, which is why we put the node name back into options. */
2656     if ((flags & BDRV_O_PROTOCOL) == 0) {
2657         BlockDriverState *file_bs;
2658
2659         file_bs = bdrv_open_child_bs(filename, options, "file", bs,
2660                                      &child_file, true, &local_err);
2661         if (local_err) {
2662             goto fail;
2663         }
2664         if (file_bs != NULL) {
2665             /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
2666              * looking at the header to guess the image format. This works even
2667              * in cases where a guest would not see a consistent state. */
2668             file = blk_new(0, BLK_PERM_ALL);
2669             blk_insert_bs(file, file_bs, &local_err);
2670             bdrv_unref(file_bs);
2671             if (local_err) {
2672                 goto fail;
2673             }
2674
2675             qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
2676         }
2677     }
2678
2679     /* Image format probing */
2680     bs->probed = !drv;
2681     if (!drv && file) {
2682         ret = find_image_format(file, filename, &drv, &local_err);
2683         if (ret < 0) {
2684             goto fail;
2685         }
2686         /*
2687          * This option update would logically belong in bdrv_fill_options(),
2688          * but we first need to open bs->file for the probing to work, while
2689          * opening bs->file already requires the (mostly) final set of options
2690          * so that cache mode etc. can be inherited.
2691          *
2692          * Adding the driver later is somewhat ugly, but it's not an option
2693          * that would ever be inherited, so it's correct. We just need to make
2694          * sure to update both bs->options (which has the full effective
2695          * options for bs) and options (which has file.* already removed).
2696          */
2697         qdict_put_str(bs->options, "driver", drv->format_name);
2698         qdict_put_str(options, "driver", drv->format_name);
2699     } else if (!drv) {
2700         error_setg(errp, "Must specify either driver or file");
2701         goto fail;
2702     }
2703
2704     /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
2705     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
2706     /* file must be NULL if a protocol BDS is about to be created
2707      * (the inverse results in an error message from bdrv_open_common()) */
2708     assert(!(flags & BDRV_O_PROTOCOL) || !file);
2709
2710     /* Open the image */
2711     ret = bdrv_open_common(bs, file, options, &local_err);
2712     if (ret < 0) {
2713         goto fail;
2714     }
2715
2716     if (file) {
2717         blk_unref(file);
2718         file = NULL;
2719     }
2720
2721     /* If there is a backing file, use it */
2722     if ((flags & BDRV_O_NO_BACKING) == 0) {
2723         ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
2724         if (ret < 0) {
2725             goto close_and_fail;
2726         }
2727     }
2728
2729     bdrv_refresh_filename(bs);
2730
2731     /* Check if any unknown options were used */
2732     if (qdict_size(options) != 0) {
2733         const QDictEntry *entry = qdict_first(options);
2734         if (flags & BDRV_O_PROTOCOL) {
2735             error_setg(errp, "Block protocol '%s' doesn't support the option "
2736                        "'%s'", drv->format_name, entry->key);
2737         } else {
2738             error_setg(errp,
2739                        "Block format '%s' does not support the option '%s'",
2740                        drv->format_name, entry->key);
2741         }
2742
2743         goto close_and_fail;
2744     }
2745
2746     bdrv_parent_cb_change_media(bs, true);
2747
2748     QDECREF(options);
2749
2750     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
2751      * temporary snapshot afterwards. */
2752     if (snapshot_flags) {
2753         BlockDriverState *snapshot_bs;
2754         snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
2755                                                 snapshot_options, &local_err);
2756         snapshot_options = NULL;
2757         if (local_err) {
2758             goto close_and_fail;
2759         }
2760         /* We are not going to return bs but the overlay on top of it
2761          * (snapshot_bs); thus, we have to drop the strong reference to bs
2762          * (which we obtained by calling bdrv_new()). bs will not be deleted,
2763          * though, because the overlay still has a reference to it. */
2764         bdrv_unref(bs);
2765         bs = snapshot_bs;
2766     }
2767
2768     return bs;
2769
2770 fail:
2771     blk_unref(file);
2772     QDECREF(snapshot_options);
2773     QDECREF(bs->explicit_options);
2774     QDECREF(bs->options);
2775     QDECREF(options);
2776     bs->options = NULL;
2777     bs->explicit_options = NULL;
2778     bdrv_unref(bs);
2779     error_propagate(errp, local_err);
2780     return NULL;
2781
2782 close_and_fail:
2783     bdrv_unref(bs);
2784     QDECREF(snapshot_options);
2785     QDECREF(options);
2786     error_propagate(errp, local_err);
2787     return NULL;
2788 }
2789
2790 BlockDriverState *bdrv_open(const char *filename, const char *reference,
2791                             QDict *options, int flags, Error **errp)
2792 {
2793     return bdrv_open_inherit(filename, reference, options, flags, NULL,
2794                              NULL, errp);
2795 }
2796
2797 /*
2798  * Adds a BlockDriverState to a simple queue for an atomic, transactional
2799  * reopen of multiple devices.
2800  *
2801  * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
2802  * already performed, or alternatively may be NULL a new BlockReopenQueue will
2803  * be created and initialized. This newly created BlockReopenQueue should be
2804  * passed back in for subsequent calls that are intended to be of the same
2805  * atomic 'set'.
2806  *
2807  * bs is the BlockDriverState to add to the reopen queue.
2808  *
2809  * options contains the changed options for the associated bs
2810  * (the BlockReopenQueue takes ownership)
2811  *
2812  * flags contains the open flags for the associated bs
2813  *
2814  * returns a pointer to bs_queue, which is either the newly allocated
2815  * bs_queue, or the existing bs_queue being used.
2816  *
2817  * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
2818  */
2819 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
2820                                                  BlockDriverState *bs,
2821                                                  QDict *options,
2822                                                  int flags,
2823                                                  const BdrvChildRole *role,
2824                                                  QDict *parent_options,
2825                                                  int parent_flags)
2826 {
2827     assert(bs != NULL);
2828
2829     BlockReopenQueueEntry *bs_entry;
2830     BdrvChild *child;
2831     QDict *old_options, *explicit_options;
2832
2833     /* Make sure that the caller remembered to use a drained section. This is
2834      * important to avoid graph changes between the recursive queuing here and
2835      * bdrv_reopen_multiple(). */
2836     assert(bs->quiesce_counter > 0);
2837
2838     if (bs_queue == NULL) {
2839         bs_queue = g_new0(BlockReopenQueue, 1);
2840         QSIMPLEQ_INIT(bs_queue);
2841     }
2842
2843     if (!options) {
2844         options = qdict_new();
2845     }
2846
2847     /* Check if this BlockDriverState is already in the queue */
2848     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2849         if (bs == bs_entry->state.bs) {
2850             break;
2851         }
2852     }
2853
2854     /*
2855      * Precedence of options:
2856      * 1. Explicitly passed in options (highest)
2857      * 2. Set in flags (only for top level)
2858      * 3. Retained from explicitly set options of bs
2859      * 4. Inherited from parent node
2860      * 5. Retained from effective options of bs
2861      */
2862
2863     if (!parent_options) {
2864         /*
2865          * Any setting represented by flags is always updated. If the
2866          * corresponding QDict option is set, it takes precedence. Otherwise
2867          * the flag is translated into a QDict option. The old setting of bs is
2868          * not considered.
2869          */
2870         update_options_from_flags(options, flags);
2871     }
2872
2873     /* Old explicitly set values (don't overwrite by inherited value) */
2874     if (bs_entry) {
2875         old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
2876     } else {
2877         old_options = qdict_clone_shallow(bs->explicit_options);
2878     }
2879     bdrv_join_options(bs, options, old_options);
2880     QDECREF(old_options);
2881
2882     explicit_options = qdict_clone_shallow(options);
2883
2884     /* Inherit from parent node */
2885     if (parent_options) {
2886         assert(!flags);
2887         role->inherit_options(&flags, options, parent_flags, parent_options);
2888     }
2889
2890     /* Old values are used for options that aren't set yet */
2891     old_options = qdict_clone_shallow(bs->options);
2892     bdrv_join_options(bs, options, old_options);
2893     QDECREF(old_options);
2894
2895     /* bdrv_open_inherit() sets and clears some additional flags internally */
2896     flags &= ~BDRV_O_PROTOCOL;
2897     if (flags & BDRV_O_RDWR) {
2898         flags |= BDRV_O_ALLOW_RDWR;
2899     }
2900
2901     if (!bs_entry) {
2902         bs_entry = g_new0(BlockReopenQueueEntry, 1);
2903         QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
2904     } else {
2905         QDECREF(bs_entry->state.options);
2906         QDECREF(bs_entry->state.explicit_options);
2907     }
2908
2909     bs_entry->state.bs = bs;
2910     bs_entry->state.options = options;
2911     bs_entry->state.explicit_options = explicit_options;
2912     bs_entry->state.flags = flags;
2913
2914     /* This needs to be overwritten in bdrv_reopen_prepare() */
2915     bs_entry->state.perm = UINT64_MAX;
2916     bs_entry->state.shared_perm = 0;
2917
2918     QLIST_FOREACH(child, &bs->children, next) {
2919         QDict *new_child_options;
2920         char *child_key_dot;
2921
2922         /* reopen can only change the options of block devices that were
2923          * implicitly created and inherited options. For other (referenced)
2924          * block devices, a syntax like "backing.foo" results in an error. */
2925         if (child->bs->inherits_from != bs) {
2926             continue;
2927         }
2928
2929         child_key_dot = g_strdup_printf("%s.", child->name);
2930         qdict_extract_subqdict(options, &new_child_options, child_key_dot);
2931         g_free(child_key_dot);
2932
2933         bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
2934                                 child->role, options, flags);
2935     }
2936
2937     return bs_queue;
2938 }
2939
2940 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
2941                                     BlockDriverState *bs,
2942                                     QDict *options, int flags)
2943 {
2944     return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
2945                                    NULL, NULL, 0);
2946 }
2947
2948 /*
2949  * Reopen multiple BlockDriverStates atomically & transactionally.
2950  *
2951  * The queue passed in (bs_queue) must have been built up previous
2952  * via bdrv_reopen_queue().
2953  *
2954  * Reopens all BDS specified in the queue, with the appropriate
2955  * flags.  All devices are prepared for reopen, and failure of any
2956  * device will cause all device changes to be abandonded, and intermediate
2957  * data cleaned up.
2958  *
2959  * If all devices prepare successfully, then the changes are committed
2960  * to all devices.
2961  *
2962  * All affected nodes must be drained between bdrv_reopen_queue() and
2963  * bdrv_reopen_multiple().
2964  */
2965 int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
2966 {
2967     int ret = -1;
2968     BlockReopenQueueEntry *bs_entry, *next;
2969     Error *local_err = NULL;
2970
2971     assert(bs_queue != NULL);
2972
2973     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2974         assert(bs_entry->state.bs->quiesce_counter > 0);
2975         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
2976             error_propagate(errp, local_err);
2977             goto cleanup;
2978         }
2979         bs_entry->prepared = true;
2980     }
2981
2982     /* If we reach this point, we have success and just need to apply the
2983      * changes
2984      */
2985     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2986         bdrv_reopen_commit(&bs_entry->state);
2987     }
2988
2989     ret = 0;
2990
2991 cleanup:
2992     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
2993         if (ret && bs_entry->prepared) {
2994             bdrv_reopen_abort(&bs_entry->state);
2995         } else if (ret) {
2996             QDECREF(bs_entry->state.explicit_options);
2997         }
2998         QDECREF(bs_entry->state.options);
2999         g_free(bs_entry);
3000     }
3001     g_free(bs_queue);
3002
3003     return ret;
3004 }
3005
3006
3007 /* Reopen a single BlockDriverState with the specified flags. */
3008 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
3009 {
3010     int ret = -1;
3011     Error *local_err = NULL;
3012     BlockReopenQueue *queue;
3013
3014     bdrv_subtree_drained_begin(bs);
3015
3016     queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
3017     ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
3018     if (local_err != NULL) {
3019         error_propagate(errp, local_err);
3020     }
3021
3022     bdrv_subtree_drained_end(bs);
3023
3024     return ret;
3025 }
3026
3027 static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q,
3028                                                           BdrvChild *c)
3029 {
3030     BlockReopenQueueEntry *entry;
3031
3032     QSIMPLEQ_FOREACH(entry, q, entry) {
3033         BlockDriverState *bs = entry->state.bs;
3034         BdrvChild *child;
3035
3036         QLIST_FOREACH(child, &bs->children, next) {
3037             if (child == c) {
3038                 return entry;
3039             }
3040         }
3041     }
3042
3043     return NULL;
3044 }
3045
3046 static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
3047                              uint64_t *perm, uint64_t *shared)
3048 {
3049     BdrvChild *c;
3050     BlockReopenQueueEntry *parent;
3051     uint64_t cumulative_perms = 0;
3052     uint64_t cumulative_shared_perms = BLK_PERM_ALL;
3053
3054     QLIST_FOREACH(c, &bs->parents, next_parent) {
3055         parent = find_parent_in_reopen_queue(q, c);
3056         if (!parent) {
3057             cumulative_perms |= c->perm;
3058             cumulative_shared_perms &= c->shared_perm;
3059         } else {
3060             uint64_t nperm, nshared;
3061
3062             bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
3063                             parent->state.perm, parent->state.shared_perm,
3064                             &nperm, &nshared);
3065
3066             cumulative_perms |= nperm;
3067             cumulative_shared_perms &= nshared;
3068         }
3069     }
3070     *perm = cumulative_perms;
3071     *shared = cumulative_shared_perms;
3072 }
3073
3074 /*
3075  * Prepares a BlockDriverState for reopen. All changes are staged in the
3076  * 'opaque' field of the BDRVReopenState, which is used and allocated by
3077  * the block driver layer .bdrv_reopen_prepare()
3078  *
3079  * bs is the BlockDriverState to reopen
3080  * flags are the new open flags
3081  * queue is the reopen queue
3082  *
3083  * Returns 0 on success, non-zero on error.  On error errp will be set
3084  * as well.
3085  *
3086  * On failure, bdrv_reopen_abort() will be called to clean up any data.
3087  * It is the responsibility of the caller to then call the abort() or
3088  * commit() for any other BDS that have been left in a prepare() state
3089  *
3090  */
3091 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
3092                         Error **errp)
3093 {
3094     int ret = -1;
3095     Error *local_err = NULL;
3096     BlockDriver *drv;
3097     QemuOpts *opts;
3098     const char *value;
3099     bool read_only;
3100
3101     assert(reopen_state != NULL);
3102     assert(reopen_state->bs->drv != NULL);
3103     drv = reopen_state->bs->drv;
3104
3105     /* Process generic block layer options */
3106     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3107     qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
3108     if (local_err) {
3109         error_propagate(errp, local_err);
3110         ret = -EINVAL;
3111         goto error;
3112     }
3113
3114     update_flags_from_options(&reopen_state->flags, opts);
3115
3116     /* node-name and driver must be unchanged. Put them back into the QDict, so
3117      * that they are checked at the end of this function. */
3118     value = qemu_opt_get(opts, "node-name");
3119     if (value) {
3120         qdict_put_str(reopen_state->options, "node-name", value);
3121     }
3122
3123     value = qemu_opt_get(opts, "driver");
3124     if (value) {
3125         qdict_put_str(reopen_state->options, "driver", value);
3126     }
3127
3128     /* If we are to stay read-only, do not allow permission change
3129      * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
3130      * not set, or if the BDS still has copy_on_read enabled */
3131     read_only = !(reopen_state->flags & BDRV_O_RDWR);
3132     ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
3133     if (local_err) {
3134         error_propagate(errp, local_err);
3135         goto error;
3136     }
3137
3138     /* Calculate required permissions after reopening */
3139     bdrv_reopen_perm(queue, reopen_state->bs,
3140                      &reopen_state->perm, &reopen_state->shared_perm);
3141
3142     ret = bdrv_flush(reopen_state->bs);
3143     if (ret) {
3144         error_setg_errno(errp, -ret, "Error flushing drive");
3145         goto error;
3146     }
3147
3148     if (drv->bdrv_reopen_prepare) {
3149         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
3150         if (ret) {
3151             if (local_err != NULL) {
3152                 error_propagate(errp, local_err);
3153             } else {
3154                 error_setg(errp, "failed while preparing to reopen image '%s'",
3155                            reopen_state->bs->filename);
3156             }
3157             goto error;
3158         }
3159     } else {
3160         /* It is currently mandatory to have a bdrv_reopen_prepare()
3161          * handler for each supported drv. */
3162         error_setg(errp, "Block format '%s' used by node '%s' "
3163                    "does not support reopening files", drv->format_name,
3164                    bdrv_get_device_or_node_name(reopen_state->bs));
3165         ret = -1;
3166         goto error;
3167     }
3168
3169     /* Options that are not handled are only okay if they are unchanged
3170      * compared to the old state. It is expected that some options are only
3171      * used for the initial open, but not reopen (e.g. filename) */
3172     if (qdict_size(reopen_state->options)) {
3173         const QDictEntry *entry = qdict_first(reopen_state->options);
3174
3175         do {
3176             QObject *new = entry->value;
3177             QObject *old = qdict_get(reopen_state->bs->options, entry->key);
3178
3179             /*
3180              * TODO: When using -drive to specify blockdev options, all values
3181              * will be strings; however, when using -blockdev, blockdev-add or
3182              * filenames using the json:{} pseudo-protocol, they will be
3183              * correctly typed.
3184              * In contrast, reopening options are (currently) always strings
3185              * (because you can only specify them through qemu-io; all other
3186              * callers do not specify any options).
3187              * Therefore, when using anything other than -drive to create a BDS,
3188              * this cannot detect non-string options as unchanged, because
3189              * qobject_is_equal() always returns false for objects of different
3190              * type.  In the future, this should be remedied by correctly typing
3191              * all options.  For now, this is not too big of an issue because
3192              * the user can simply omit options which cannot be changed anyway,
3193              * so they will stay unchanged.
3194              */
3195             if (!qobject_is_equal(new, old)) {
3196                 error_setg(errp, "Cannot change the option '%s'", entry->key);
3197                 ret = -EINVAL;
3198                 goto error;
3199             }
3200         } while ((entry = qdict_next(reopen_state->options, entry)));
3201     }
3202
3203     ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,
3204                           reopen_state->shared_perm, NULL, errp);
3205     if (ret < 0) {
3206         goto error;
3207     }
3208
3209     ret = 0;
3210
3211 error:
3212     qemu_opts_del(opts);
3213     return ret;
3214 }
3215
3216 /*
3217  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
3218  * makes them final by swapping the staging BlockDriverState contents into
3219  * the active BlockDriverState contents.
3220  */
3221 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
3222 {
3223     BlockDriver *drv;
3224     BlockDriverState *bs;
3225     bool old_can_write, new_can_write;
3226
3227     assert(reopen_state != NULL);
3228     bs = reopen_state->bs;
3229     drv = bs->drv;
3230     assert(drv != NULL);
3231
3232     old_can_write =
3233         !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3234
3235     /* If there are any driver level actions to take */
3236     if (drv->bdrv_reopen_commit) {
3237         drv->bdrv_reopen_commit(reopen_state);
3238     }
3239
3240     /* set BDS specific flags now */
3241     QDECREF(bs->explicit_options);
3242
3243     bs->explicit_options   = reopen_state->explicit_options;
3244     bs->open_flags         = reopen_state->flags;
3245     bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
3246
3247     bdrv_refresh_limits(bs, NULL);
3248
3249     bdrv_set_perm(reopen_state->bs, reopen_state->perm,
3250                   reopen_state->shared_perm);
3251
3252     new_can_write =
3253         !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3254     if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) {
3255         Error *local_err = NULL;
3256         if (drv->bdrv_reopen_bitmaps_rw(bs, &local_err) < 0) {
3257             /* This is not fatal, bitmaps just left read-only, so all following
3258              * writes will fail. User can remove read-only bitmaps to unblock
3259              * writes.
3260              */
3261             error_reportf_err(local_err,
3262                               "%s: Failed to make dirty bitmaps writable: ",
3263                               bdrv_get_node_name(bs));
3264         }
3265     }
3266 }
3267
3268 /*
3269  * Abort the reopen, and delete and free the staged changes in
3270  * reopen_state
3271  */
3272 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
3273 {
3274     BlockDriver *drv;
3275
3276     assert(reopen_state != NULL);
3277     drv = reopen_state->bs->drv;
3278     assert(drv != NULL);
3279
3280     if (drv->bdrv_reopen_abort) {
3281         drv->bdrv_reopen_abort(reopen_state);
3282     }
3283
3284     QDECREF(reopen_state->explicit_options);
3285
3286     bdrv_abort_perm_update(reopen_state->bs);
3287 }
3288
3289
3290 static void bdrv_close(BlockDriverState *bs)
3291 {
3292     BdrvAioNotifier *ban, *ban_next;
3293     BdrvChild *child, *next;
3294
3295     assert(!bs->job);
3296     assert(!bs->refcnt);
3297
3298     bdrv_drained_begin(bs); /* complete I/O */
3299     bdrv_flush(bs);
3300     bdrv_drain(bs); /* in case flush left pending I/O */
3301
3302     if (bs->drv) {
3303         bs->drv->bdrv_close(bs);
3304         bs->drv = NULL;
3305     }
3306
3307     bdrv_set_backing_hd(bs, NULL, &error_abort);
3308
3309     if (bs->file != NULL) {
3310         bdrv_unref_child(bs, bs->file);
3311         bs->file = NULL;
3312     }
3313
3314     QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
3315         /* TODO Remove bdrv_unref() from drivers' close function and use
3316          * bdrv_unref_child() here */
3317         if (child->bs->inherits_from == bs) {
3318             child->bs->inherits_from = NULL;
3319         }
3320         bdrv_detach_child(child);
3321     }
3322
3323     g_free(bs->opaque);
3324     bs->opaque = NULL;
3325     atomic_set(&bs->copy_on_read, 0);
3326     bs->backing_file[0] = '\0';
3327     bs->backing_format[0] = '\0';
3328     bs->total_sectors = 0;
3329     bs->encrypted = false;
3330     bs->sg = false;
3331     QDECREF(bs->options);
3332     QDECREF(bs->explicit_options);
3333     bs->options = NULL;
3334     bs->explicit_options = NULL;
3335     QDECREF(bs->full_open_options);
3336     bs->full_open_options = NULL;
3337
3338     bdrv_release_named_dirty_bitmaps(bs);
3339     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
3340
3341     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3342         g_free(ban);
3343     }
3344     QLIST_INIT(&bs->aio_notifiers);
3345     bdrv_drained_end(bs);
3346 }
3347
3348 void bdrv_close_all(void)
3349 {
3350     block_job_cancel_sync_all();
3351     nbd_export_close_all();
3352
3353     /* Drop references from requests still in flight, such as canceled block
3354      * jobs whose AIO context has not been polled yet */
3355     bdrv_drain_all();
3356
3357     blk_remove_all_bs();
3358     blockdev_close_all_bdrv_states();
3359
3360     assert(QTAILQ_EMPTY(&all_bdrv_states));
3361 }
3362
3363 static bool should_update_child(BdrvChild *c, BlockDriverState *to)
3364 {
3365     BdrvChild *to_c;
3366
3367     if (c->role->stay_at_node) {
3368         return false;
3369     }
3370
3371     if (c->role == &child_backing) {
3372         /* If @from is a backing file of @to, ignore the child to avoid
3373          * creating a loop. We only want to change the pointer of other
3374          * parents. */
3375         QLIST_FOREACH(to_c, &to->children, next) {
3376             if (to_c == c) {
3377                 break;
3378             }
3379         }
3380         if (to_c) {
3381             return false;
3382         }
3383     }
3384
3385     return true;
3386 }
3387
3388 void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
3389                        Error **errp)
3390 {
3391     BdrvChild *c, *next;
3392     GSList *list = NULL, *p;
3393     uint64_t old_perm, old_shared;
3394     uint64_t perm = 0, shared = BLK_PERM_ALL;
3395     int ret;
3396
3397     assert(!atomic_read(&from->in_flight));
3398     assert(!atomic_read(&to->in_flight));
3399
3400     /* Make sure that @from doesn't go away until we have successfully attached
3401      * all of its parents to @to. */
3402     bdrv_ref(from);
3403
3404     /* Put all parents into @list and calculate their cumulative permissions */
3405     QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
3406         if (!should_update_child(c, to)) {
3407             continue;
3408         }
3409         list = g_slist_prepend(list, c);
3410         perm |= c->perm;
3411         shared &= c->shared_perm;
3412     }
3413
3414     /* Check whether the required permissions can be granted on @to, ignoring
3415      * all BdrvChild in @list so that they can't block themselves. */
3416     ret = bdrv_check_update_perm(to, NULL, perm, shared, list, errp);
3417     if (ret < 0) {
3418         bdrv_abort_perm_update(to);
3419         goto out;
3420     }
3421
3422     /* Now actually perform the change. We performed the permission check for
3423      * all elements of @list at once, so set the permissions all at once at the
3424      * very end. */
3425     for (p = list; p != NULL; p = p->next) {
3426         c = p->data;
3427
3428         bdrv_ref(to);
3429         bdrv_replace_child_noperm(c, to);
3430         bdrv_unref(from);
3431     }
3432
3433     bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
3434     bdrv_set_perm(to, old_perm | perm, old_shared | shared);
3435
3436 out:
3437     g_slist_free(list);
3438     bdrv_unref(from);
3439 }
3440
3441 /*
3442  * Add new bs contents at the top of an image chain while the chain is
3443  * live, while keeping required fields on the top layer.
3444  *
3445  * This will modify the BlockDriverState fields, and swap contents
3446  * between bs_new and bs_top. Both bs_new and bs_top are modified.
3447  *
3448  * bs_new must not be attached to a BlockBackend.
3449  *
3450  * This function does not create any image files.
3451  *
3452  * bdrv_append() takes ownership of a bs_new reference and unrefs it because
3453  * that's what the callers commonly need. bs_new will be referenced by the old
3454  * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
3455  * reference of its own, it must call bdrv_ref().
3456  */
3457 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
3458                  Error **errp)
3459 {
3460     Error *local_err = NULL;
3461
3462     bdrv_set_backing_hd(bs_new, bs_top, &local_err);
3463     if (local_err) {
3464         error_propagate(errp, local_err);
3465         goto out;
3466     }
3467
3468     bdrv_replace_node(bs_top, bs_new, &local_err);
3469     if (local_err) {
3470         error_propagate(errp, local_err);
3471         bdrv_set_backing_hd(bs_new, NULL, &error_abort);
3472         goto out;
3473     }
3474
3475     /* bs_new is now referenced by its new parents, we don't need the
3476      * additional reference any more. */
3477 out:
3478     bdrv_unref(bs_new);
3479 }
3480
3481 static void bdrv_delete(BlockDriverState *bs)
3482 {
3483     assert(!bs->job);
3484     assert(bdrv_op_blocker_is_empty(bs));
3485     assert(!bs->refcnt);
3486
3487     bdrv_close(bs);
3488
3489     /* remove from list, if necessary */
3490     if (bs->node_name[0] != '\0') {
3491         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
3492     }
3493     QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
3494
3495     g_free(bs);
3496 }
3497
3498 /*
3499  * Run consistency checks on an image
3500  *
3501  * Returns 0 if the check could be completed (it doesn't mean that the image is
3502  * free of errors) or -errno when an internal error occurred. The results of the
3503  * check are stored in res.
3504  */
3505 static int coroutine_fn bdrv_co_check(BlockDriverState *bs,
3506                                       BdrvCheckResult *res, BdrvCheckMode fix)
3507 {
3508     if (bs->drv == NULL) {
3509         return -ENOMEDIUM;
3510     }
3511     if (bs->drv->bdrv_co_check == NULL) {
3512         return -ENOTSUP;
3513     }
3514
3515     memset(res, 0, sizeof(*res));
3516     return bs->drv->bdrv_co_check(bs, res, fix);
3517 }
3518
3519 typedef struct CheckCo {
3520     BlockDriverState *bs;
3521     BdrvCheckResult *res;
3522     BdrvCheckMode fix;
3523     int ret;
3524 } CheckCo;
3525
3526 static void bdrv_check_co_entry(void *opaque)
3527 {
3528     CheckCo *cco = opaque;
3529     cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);
3530 }
3531
3532 int bdrv_check(BlockDriverState *bs,
3533                BdrvCheckResult *res, BdrvCheckMode fix)
3534 {
3535     Coroutine *co;
3536     CheckCo cco = {
3537         .bs = bs,
3538         .res = res,
3539         .ret = -EINPROGRESS,
3540         .fix = fix,
3541     };
3542
3543     if (qemu_in_coroutine()) {
3544         /* Fast-path if already in coroutine context */
3545         bdrv_check_co_entry(&cco);
3546     } else {
3547         co = qemu_coroutine_create(bdrv_check_co_entry, &cco);
3548         qemu_coroutine_enter(co);
3549         BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);
3550     }
3551
3552     return cco.ret;
3553 }
3554
3555 /*
3556  * Return values:
3557  * 0        - success
3558  * -EINVAL  - backing format specified, but no file
3559  * -ENOSPC  - can't update the backing file because no space is left in the
3560  *            image file header
3561  * -ENOTSUP - format driver doesn't support changing the backing file
3562  */
3563 int bdrv_change_backing_file(BlockDriverState *bs,
3564     const char *backing_file, const char *backing_fmt)
3565 {
3566     BlockDriver *drv = bs->drv;
3567     int ret;
3568
3569     if (!drv) {
3570         return -ENOMEDIUM;
3571     }
3572
3573     /* Backing file format doesn't make sense without a backing file */
3574     if (backing_fmt && !backing_file) {
3575         return -EINVAL;
3576     }
3577
3578     if (drv->bdrv_change_backing_file != NULL) {
3579         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
3580     } else {
3581         ret = -ENOTSUP;
3582     }
3583
3584     if (ret == 0) {
3585         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3586         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3587     }
3588     return ret;
3589 }
3590
3591 /*
3592  * Finds the image layer in the chain that has 'bs' as its backing file.
3593  *
3594  * active is the current topmost image.
3595  *
3596  * Returns NULL if bs is not found in active's image chain,
3597  * or if active == bs.
3598  *
3599  * Returns the bottommost base image if bs == NULL.
3600  */
3601 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
3602                                     BlockDriverState *bs)
3603 {
3604     while (active && bs != backing_bs(active)) {
3605         active = backing_bs(active);
3606     }
3607
3608     return active;
3609 }
3610
3611 /* Given a BDS, searches for the base layer. */
3612 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3613 {
3614     return bdrv_find_overlay(bs, NULL);
3615 }
3616
3617 /*
3618  * Drops images above 'base' up to and including 'top', and sets the image
3619  * above 'top' to have base as its backing file.
3620  *
3621  * Requires that the overlay to 'top' is opened r/w, so that the backing file
3622  * information in 'bs' can be properly updated.
3623  *
3624  * E.g., this will convert the following chain:
3625  * bottom <- base <- intermediate <- top <- active
3626  *
3627  * to
3628  *
3629  * bottom <- base <- active
3630  *
3631  * It is allowed for bottom==base, in which case it converts:
3632  *
3633  * base <- intermediate <- top <- active
3634  *
3635  * to
3636  *
3637  * base <- active
3638  *
3639  * If backing_file_str is non-NULL, it will be used when modifying top's
3640  * overlay image metadata.
3641  *
3642  * Error conditions:
3643  *  if active == top, that is considered an error
3644  *
3645  */
3646 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
3647                            const char *backing_file_str)
3648 {
3649     BdrvChild *c, *next;
3650     Error *local_err = NULL;
3651     int ret = -EIO;
3652
3653     bdrv_ref(top);
3654
3655     if (!top->drv || !base->drv) {
3656         goto exit;
3657     }
3658
3659     /* Make sure that base is in the backing chain of top */
3660     if (!bdrv_chain_contains(top, base)) {
3661         goto exit;
3662     }
3663
3664     /* success - we can delete the intermediate states, and link top->base */
3665     /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once
3666      * we've figured out how they should work. */
3667     backing_file_str = backing_file_str ? backing_file_str : base->filename;
3668
3669     QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
3670         /* Check whether we are allowed to switch c from top to base */
3671         GSList *ignore_children = g_slist_prepend(NULL, c);
3672         bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
3673                                ignore_children, &local_err);
3674         if (local_err) {
3675             ret = -EPERM;
3676             error_report_err(local_err);
3677             goto exit;
3678         }
3679         g_slist_free(ignore_children);
3680
3681         /* If so, update the backing file path in the image file */
3682         if (c->role->update_filename) {
3683             ret = c->role->update_filename(c, base, backing_file_str,
3684                                            &local_err);
3685             if (ret < 0) {
3686                 bdrv_abort_perm_update(base);
3687                 error_report_err(local_err);
3688                 goto exit;
3689             }
3690         }
3691
3692         /* Do the actual switch in the in-memory graph.
3693          * Completes bdrv_check_update_perm() transaction internally. */
3694         bdrv_ref(base);
3695         bdrv_replace_child(c, base);
3696         bdrv_unref(top);
3697     }
3698
3699     ret = 0;
3700 exit:
3701     bdrv_unref(top);
3702     return ret;
3703 }
3704
3705 /**
3706  * Truncate file to 'offset' bytes (needed only for file protocols)
3707  */
3708 int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
3709                   Error **errp)
3710 {
3711     BlockDriverState *bs = child->bs;
3712     BlockDriver *drv = bs->drv;
3713     int ret;
3714
3715     assert(child->perm & BLK_PERM_RESIZE);
3716
3717     /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
3718     if (!drv) {
3719         error_setg(errp, "No medium inserted");
3720         return -ENOMEDIUM;
3721     }
3722     if (offset < 0) {
3723         error_setg(errp, "Image size cannot be negative");
3724         return -EINVAL;
3725     }
3726
3727     if (!drv->bdrv_truncate) {
3728         if (bs->file && drv->is_filter) {
3729             return bdrv_truncate(bs->file, offset, prealloc, errp);
3730         }
3731         error_setg(errp, "Image format driver does not support resize");
3732         return -ENOTSUP;
3733     }
3734     if (bs->read_only) {
3735         error_setg(errp, "Image is read-only");
3736         return -EACCES;
3737     }
3738
3739     assert(!(bs->open_flags & BDRV_O_INACTIVE));
3740
3741     ret = drv->bdrv_truncate(bs, offset, prealloc, errp);
3742     if (ret < 0) {
3743         return ret;
3744     }
3745     ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3746     if (ret < 0) {
3747         error_setg_errno(errp, -ret, "Could not refresh total sector count");
3748     } else {
3749         offset = bs->total_sectors * BDRV_SECTOR_SIZE;
3750     }
3751     bdrv_dirty_bitmap_truncate(bs, offset);
3752     bdrv_parent_cb_resize(bs);
3753     atomic_inc(&bs->write_gen);
3754     return ret;
3755 }
3756
3757 /**
3758  * Length of a allocated file in bytes. Sparse files are counted by actual
3759  * allocated space. Return < 0 if error or unknown.
3760  */
3761 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3762 {
3763     BlockDriver *drv = bs->drv;
3764     if (!drv) {
3765         return -ENOMEDIUM;
3766     }
3767     if (drv->bdrv_get_allocated_file_size) {
3768         return drv->bdrv_get_allocated_file_size(bs);
3769     }
3770     if (bs->file) {
3771         return bdrv_get_allocated_file_size(bs->file->bs);
3772     }
3773     return -ENOTSUP;
3774 }
3775
3776 /*
3777  * bdrv_measure:
3778  * @drv: Format driver
3779  * @opts: Creation options for new image
3780  * @in_bs: Existing image containing data for new image (may be NULL)
3781  * @errp: Error object
3782  * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
3783  *          or NULL on error
3784  *
3785  * Calculate file size required to create a new image.
3786  *
3787  * If @in_bs is given then space for allocated clusters and zero clusters
3788  * from that image are included in the calculation.  If @opts contains a
3789  * backing file that is shared by @in_bs then backing clusters may be omitted
3790  * from the calculation.
3791  *
3792  * If @in_bs is NULL then the calculation includes no allocated clusters
3793  * unless a preallocation option is given in @opts.
3794  *
3795  * Note that @in_bs may use a different BlockDriver from @drv.
3796  *
3797  * If an error occurs the @errp pointer is set.
3798  */
3799 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
3800                                BlockDriverState *in_bs, Error **errp)
3801 {
3802     if (!drv->bdrv_measure) {
3803         error_setg(errp, "Block driver '%s' does not support size measurement",
3804                    drv->format_name);
3805         return NULL;
3806     }
3807
3808     return drv->bdrv_measure(opts, in_bs, errp);
3809 }
3810
3811 /**
3812  * Return number of sectors on success, -errno on error.
3813  */
3814 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3815 {
3816     BlockDriver *drv = bs->drv;
3817
3818     if (!drv)
3819         return -ENOMEDIUM;
3820
3821     if (drv->has_variable_length) {
3822         int ret = refresh_total_sectors(bs, bs->total_sectors);
3823         if (ret < 0) {
3824             return ret;
3825         }
3826     }
3827     return bs->total_sectors;
3828 }
3829
3830 /**
3831  * Return length in bytes on success, -errno on error.
3832  * The length is always a multiple of BDRV_SECTOR_SIZE.
3833  */
3834 int64_t bdrv_getlength(BlockDriverState *bs)
3835 {
3836     int64_t ret = bdrv_nb_sectors(bs);
3837
3838     ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
3839     return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3840 }
3841
3842 /* return 0 as number of sectors if no device present or error */
3843 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3844 {
3845     int64_t nb_sectors = bdrv_nb_sectors(bs);
3846
3847     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3848 }
3849
3850 bool bdrv_is_sg(BlockDriverState *bs)
3851 {
3852     return bs->sg;
3853 }
3854
3855 bool bdrv_is_encrypted(BlockDriverState *bs)
3856 {
3857     if (bs->backing && bs->backing->bs->encrypted) {
3858         return true;
3859     }
3860     return bs->encrypted;
3861 }
3862
3863 const char *bdrv_get_format_name(BlockDriverState *bs)
3864 {
3865     return bs->drv ? bs->drv->format_name : NULL;
3866 }
3867
3868 static int qsort_strcmp(const void *a, const void *b)
3869 {
3870     return strcmp(*(char *const *)a, *(char *const *)b);
3871 }
3872
3873 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3874                          void *opaque)
3875 {
3876     BlockDriver *drv;
3877     int count = 0;
3878     int i;
3879     const char **formats = NULL;
3880
3881     QLIST_FOREACH(drv, &bdrv_drivers, list) {
3882         if (drv->format_name) {
3883             bool found = false;
3884             int i = count;
3885             while (formats && i && !found) {
3886                 found = !strcmp(formats[--i], drv->format_name);
3887             }
3888
3889             if (!found) {
3890                 formats = g_renew(const char *, formats, count + 1);
3891                 formats[count++] = drv->format_name;
3892             }
3893         }
3894     }
3895
3896     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
3897         const char *format_name = block_driver_modules[i].format_name;
3898
3899         if (format_name) {
3900             bool found = false;
3901             int j = count;
3902
3903             while (formats && j && !found) {
3904                 found = !strcmp(formats[--j], format_name);
3905             }
3906
3907             if (!found) {
3908                 formats = g_renew(const char *, formats, count + 1);
3909                 formats[count++] = format_name;
3910             }
3911         }
3912     }
3913
3914     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
3915
3916     for (i = 0; i < count; i++) {
3917         it(opaque, formats[i]);
3918     }
3919
3920     g_free(formats);
3921 }
3922
3923 /* This function is to find a node in the bs graph */
3924 BlockDriverState *bdrv_find_node(const char *node_name)
3925 {
3926     BlockDriverState *bs;
3927
3928     assert(node_name);
3929
3930     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3931         if (!strcmp(node_name, bs->node_name)) {
3932             return bs;
3933         }
3934     }
3935     return NULL;
3936 }
3937
3938 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3939 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
3940 {
3941     BlockDeviceInfoList *list, *entry;
3942     BlockDriverState *bs;
3943
3944     list = NULL;
3945     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3946         BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
3947         if (!info) {
3948             qapi_free_BlockDeviceInfoList(list);
3949             return NULL;
3950         }
3951         entry = g_malloc0(sizeof(*entry));
3952         entry->value = info;
3953         entry->next = list;
3954         list = entry;
3955     }
3956
3957     return list;
3958 }
3959
3960 BlockDriverState *bdrv_lookup_bs(const char *device,
3961                                  const char *node_name,
3962                                  Error **errp)
3963 {
3964     BlockBackend *blk;
3965     BlockDriverState *bs;
3966
3967     if (device) {
3968         blk = blk_by_name(device);
3969
3970         if (blk) {
3971             bs = blk_bs(blk);
3972             if (!bs) {
3973                 error_setg(errp, "Device '%s' has no medium", device);
3974             }
3975
3976             return bs;
3977         }
3978     }
3979
3980     if (node_name) {
3981         bs = bdrv_find_node(node_name);
3982
3983         if (bs) {
3984             return bs;
3985         }
3986     }
3987
3988     error_setg(errp, "Cannot find device=%s nor node_name=%s",
3989                      device ? device : "",
3990                      node_name ? node_name : "");
3991     return NULL;
3992 }
3993
3994 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3995  * return false.  If either argument is NULL, return false. */
3996 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3997 {
3998     while (top && top != base) {
3999         top = backing_bs(top);
4000     }
4001
4002     return top != NULL;
4003 }
4004
4005 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
4006 {
4007     if (!bs) {
4008         return QTAILQ_FIRST(&graph_bdrv_states);
4009     }
4010     return QTAILQ_NEXT(bs, node_list);
4011 }
4012
4013 const char *bdrv_get_node_name(const BlockDriverState *bs)
4014 {
4015     return bs->node_name;
4016 }
4017
4018 const char *bdrv_get_parent_name(const BlockDriverState *bs)
4019 {
4020     BdrvChild *c;
4021     const char *name;
4022
4023     /* If multiple parents have a name, just pick the first one. */
4024     QLIST_FOREACH(c, &bs->parents, next_parent) {
4025         if (c->role->get_name) {
4026             name = c->role->get_name(c);
4027             if (name && *name) {
4028                 return name;
4029             }
4030         }
4031     }
4032
4033     return NULL;
4034 }
4035
4036 /* TODO check what callers really want: bs->node_name or blk_name() */
4037 const char *bdrv_get_device_name(const BlockDriverState *bs)
4038 {
4039     return bdrv_get_parent_name(bs) ?: "";
4040 }
4041
4042 /* This can be used to identify nodes that might not have a device
4043  * name associated. Since node and device names live in the same
4044  * namespace, the result is unambiguous. The exception is if both are
4045  * absent, then this returns an empty (non-null) string. */
4046 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
4047 {
4048     return bdrv_get_parent_name(bs) ?: bs->node_name;
4049 }
4050
4051 int bdrv_get_flags(BlockDriverState *bs)
4052 {
4053     return bs->open_flags;
4054 }
4055
4056 int bdrv_has_zero_init_1(BlockDriverState *bs)
4057 {
4058     return 1;
4059 }
4060
4061 int bdrv_has_zero_init(BlockDriverState *bs)
4062 {
4063     if (!bs->drv) {
4064         return 0;
4065     }
4066
4067     /* If BS is a copy on write image, it is initialized to
4068        the contents of the base image, which may not be zeroes.  */
4069     if (bs->backing) {
4070         return 0;
4071     }
4072     if (bs->drv->bdrv_has_zero_init) {
4073         return bs->drv->bdrv_has_zero_init(bs);
4074     }
4075     if (bs->file && bs->drv->is_filter) {
4076         return bdrv_has_zero_init(bs->file->bs);
4077     }
4078
4079     /* safe default */
4080     return 0;
4081 }
4082
4083 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
4084 {
4085     BlockDriverInfo bdi;
4086
4087     if (bs->backing) {
4088         return false;
4089     }
4090
4091     if (bdrv_get_info(bs, &bdi) == 0) {
4092         return bdi.unallocated_blocks_are_zero;
4093     }
4094
4095     return false;
4096 }
4097
4098 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
4099 {
4100     if (!(bs->open_flags & BDRV_O_UNMAP)) {
4101         return false;
4102     }
4103
4104     return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
4105 }
4106
4107 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4108 {
4109     if (bs->backing && bs->backing->bs->encrypted)
4110         return bs->backing_file;
4111     else if (bs->encrypted)
4112         return bs->filename;
4113     else
4114         return NULL;
4115 }
4116
4117 void bdrv_get_backing_filename(BlockDriverState *bs,
4118                                char *filename, int filename_size)
4119 {
4120     pstrcpy(filename, filename_size, bs->backing_file);
4121 }
4122
4123 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4124 {
4125     BlockDriver *drv = bs->drv;
4126     /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
4127     if (!drv) {
4128         return -ENOMEDIUM;
4129     }
4130     if (!drv->bdrv_get_info) {
4131         if (bs->file && drv->is_filter) {
4132             return bdrv_get_info(bs->file->bs, bdi);
4133         }
4134         return -ENOTSUP;
4135     }
4136     memset(bdi, 0, sizeof(*bdi));
4137     return drv->bdrv_get_info(bs, bdi);
4138 }
4139
4140 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4141 {
4142     BlockDriver *drv = bs->drv;
4143     if (drv && drv->bdrv_get_specific_info) {
4144         return drv->bdrv_get_specific_info(bs);
4145     }
4146     return NULL;
4147 }
4148
4149 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
4150 {
4151     if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4152         return;
4153     }
4154
4155     bs->drv->bdrv_debug_event(bs, event);
4156 }
4157
4158 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4159                           const char *tag)
4160 {
4161     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4162         bs = bs->file ? bs->file->bs : NULL;
4163     }
4164
4165     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4166         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4167     }
4168
4169     return -ENOTSUP;
4170 }
4171
4172 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4173 {
4174     while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4175         bs = bs->file ? bs->file->bs : NULL;
4176     }
4177
4178     if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4179         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4180     }
4181
4182     return -ENOTSUP;
4183 }
4184
4185 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4186 {
4187     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4188         bs = bs->file ? bs->file->bs : NULL;
4189     }
4190
4191     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4192         return bs->drv->bdrv_debug_resume(bs, tag);
4193     }
4194
4195     return -ENOTSUP;
4196 }
4197
4198 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4199 {
4200     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4201         bs = bs->file ? bs->file->bs : NULL;
4202     }
4203
4204     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4205         return bs->drv->bdrv_debug_is_suspended(bs, tag);
4206     }
4207
4208     return false;
4209 }
4210
4211 /* backing_file can either be relative, or absolute, or a protocol.  If it is
4212  * relative, it must be relative to the chain.  So, passing in bs->filename
4213  * from a BDS as backing_file should not be done, as that may be relative to
4214  * the CWD rather than the chain. */
4215 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4216         const char *backing_file)
4217 {
4218     char *filename_full = NULL;
4219     char *backing_file_full = NULL;
4220     char *filename_tmp = NULL;
4221     int is_protocol = 0;
4222     BlockDriverState *curr_bs = NULL;
4223     BlockDriverState *retval = NULL;
4224     Error *local_error = NULL;
4225
4226     if (!bs || !bs->drv || !backing_file) {
4227         return NULL;
4228     }
4229
4230     filename_full     = g_malloc(PATH_MAX);
4231     backing_file_full = g_malloc(PATH_MAX);
4232     filename_tmp      = g_malloc(PATH_MAX);
4233
4234     is_protocol = path_has_protocol(backing_file);
4235
4236     for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
4237
4238         /* If either of the filename paths is actually a protocol, then
4239          * compare unmodified paths; otherwise make paths relative */
4240         if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4241             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4242                 retval = curr_bs->backing->bs;
4243                 break;
4244             }
4245             /* Also check against the full backing filename for the image */
4246             bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX,
4247                                            &local_error);
4248             if (local_error == NULL) {
4249                 if (strcmp(backing_file, backing_file_full) == 0) {
4250                     retval = curr_bs->backing->bs;
4251                     break;
4252                 }
4253             } else {
4254                 error_free(local_error);
4255                 local_error = NULL;
4256             }
4257         } else {
4258             /* If not an absolute filename path, make it relative to the current
4259              * image's filename path */
4260             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4261                          backing_file);
4262
4263             /* We are going to compare absolute pathnames */
4264             if (!realpath(filename_tmp, filename_full)) {
4265                 continue;
4266             }
4267
4268             /* We need to make sure the backing filename we are comparing against
4269              * is relative to the current image filename (or absolute) */
4270             path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4271                          curr_bs->backing_file);
4272
4273             if (!realpath(filename_tmp, backing_file_full)) {
4274                 continue;
4275             }
4276
4277             if (strcmp(backing_file_full, filename_full) == 0) {
4278                 retval = curr_bs->backing->bs;
4279                 break;
4280             }
4281         }
4282     }
4283
4284     g_free(filename_full);
4285     g_free(backing_file_full);
4286     g_free(filename_tmp);
4287     return retval;
4288 }
4289
4290 void bdrv_init(void)
4291 {
4292     module_call_init(MODULE_INIT_BLOCK);
4293 }
4294
4295 void bdrv_init_with_whitelist(void)
4296 {
4297     use_bdrv_whitelist = 1;
4298     bdrv_init();
4299 }
4300
4301 static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
4302                                                   Error **errp)
4303 {
4304     BdrvChild *child, *parent;
4305     uint64_t perm, shared_perm;
4306     Error *local_err = NULL;
4307     int ret;
4308
4309     if (!bs->drv)  {
4310         return;
4311     }
4312
4313     if (!(bs->open_flags & BDRV_O_INACTIVE)) {
4314         return;
4315     }
4316
4317     QLIST_FOREACH(child, &bs->children, next) {
4318         bdrv_co_invalidate_cache(child->bs, &local_err);
4319         if (local_err) {
4320             error_propagate(errp, local_err);
4321             return;
4322         }
4323     }
4324
4325     /*
4326      * Update permissions, they may differ for inactive nodes.
4327      *
4328      * Note that the required permissions of inactive images are always a
4329      * subset of the permissions required after activating the image. This
4330      * allows us to just get the permissions upfront without restricting
4331      * drv->bdrv_invalidate_cache().
4332      *
4333      * It also means that in error cases, we don't have to try and revert to
4334      * the old permissions (which is an operation that could fail, too). We can
4335      * just keep the extended permissions for the next time that an activation
4336      * of the image is tried.
4337      */
4338     bs->open_flags &= ~BDRV_O_INACTIVE;
4339     bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4340     ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
4341     if (ret < 0) {
4342         bs->open_flags |= BDRV_O_INACTIVE;
4343         error_propagate(errp, local_err);
4344         return;
4345     }
4346     bdrv_set_perm(bs, perm, shared_perm);
4347
4348     if (bs->drv->bdrv_co_invalidate_cache) {
4349         bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
4350         if (local_err) {
4351             bs->open_flags |= BDRV_O_INACTIVE;
4352             error_propagate(errp, local_err);
4353             return;
4354         }
4355     }
4356
4357     ret = refresh_total_sectors(bs, bs->total_sectors);
4358     if (ret < 0) {
4359         bs->open_flags |= BDRV_O_INACTIVE;
4360         error_setg_errno(errp, -ret, "Could not refresh total sector count");
4361         return;
4362     }
4363
4364     QLIST_FOREACH(parent, &bs->parents, next_parent) {
4365         if (parent->role->activate) {
4366             parent->role->activate(parent, &local_err);
4367             if (local_err) {
4368                 error_propagate(errp, local_err);
4369                 return;
4370             }
4371         }
4372     }
4373 }
4374
4375 typedef struct InvalidateCacheCo {
4376     BlockDriverState *bs;
4377     Error **errp;
4378     bool done;
4379 } InvalidateCacheCo;
4380
4381 static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque)
4382 {
4383     InvalidateCacheCo *ico = opaque;
4384     bdrv_co_invalidate_cache(ico->bs, ico->errp);
4385     ico->done = true;
4386 }
4387
4388 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4389 {
4390     Coroutine *co;
4391     InvalidateCacheCo ico = {
4392         .bs = bs,
4393         .done = false,
4394         .errp = errp
4395     };
4396
4397     if (qemu_in_coroutine()) {
4398         /* Fast-path if already in coroutine context */
4399         bdrv_invalidate_cache_co_entry(&ico);
4400     } else {
4401         co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);
4402         qemu_coroutine_enter(co);
4403         BDRV_POLL_WHILE(bs, !ico.done);
4404     }
4405 }
4406
4407 void bdrv_invalidate_cache_all(Error **errp)
4408 {
4409     BlockDriverState *bs;
4410     Error *local_err = NULL;
4411     BdrvNextIterator it;
4412
4413     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4414         AioContext *aio_context = bdrv_get_aio_context(bs);
4415
4416         aio_context_acquire(aio_context);
4417         bdrv_invalidate_cache(bs, &local_err);
4418         aio_context_release(aio_context);
4419         if (local_err) {
4420             error_propagate(errp, local_err);
4421             bdrv_next_cleanup(&it);
4422             return;
4423         }
4424     }
4425 }
4426
4427 static int bdrv_inactivate_recurse(BlockDriverState *bs,
4428                                    bool setting_flag)
4429 {
4430     BdrvChild *child, *parent;
4431     int ret;
4432
4433     if (!bs->drv) {
4434         return -ENOMEDIUM;
4435     }
4436
4437     if (!setting_flag && bs->drv->bdrv_inactivate) {
4438         ret = bs->drv->bdrv_inactivate(bs);
4439         if (ret < 0) {
4440             return ret;
4441         }
4442     }
4443
4444     if (setting_flag && !(bs->open_flags & BDRV_O_INACTIVE)) {
4445         uint64_t perm, shared_perm;
4446
4447         QLIST_FOREACH(parent, &bs->parents, next_parent) {
4448             if (parent->role->inactivate) {
4449                 ret = parent->role->inactivate(parent);
4450                 if (ret < 0) {
4451                     return ret;
4452                 }
4453             }
4454         }
4455
4456         bs->open_flags |= BDRV_O_INACTIVE;
4457
4458         /* Update permissions, they may differ for inactive nodes */
4459         bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4460         bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
4461         bdrv_set_perm(bs, perm, shared_perm);
4462     }
4463
4464     QLIST_FOREACH(child, &bs->children, next) {
4465         ret = bdrv_inactivate_recurse(child->bs, setting_flag);
4466         if (ret < 0) {
4467             return ret;
4468         }
4469     }
4470
4471     /* At this point persistent bitmaps should be already stored by the format
4472      * driver */
4473     bdrv_release_persistent_dirty_bitmaps(bs);
4474
4475     return 0;
4476 }
4477
4478 int bdrv_inactivate_all(void)
4479 {
4480     BlockDriverState *bs = NULL;
4481     BdrvNextIterator it;
4482     int ret = 0;
4483     int pass;
4484     GSList *aio_ctxs = NULL, *ctx;
4485
4486     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4487         AioContext *aio_context = bdrv_get_aio_context(bs);
4488
4489         if (!g_slist_find(aio_ctxs, aio_context)) {
4490             aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
4491             aio_context_acquire(aio_context);
4492         }
4493     }
4494
4495     /* We do two passes of inactivation. The first pass calls to drivers'
4496      * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
4497      * the second pass sets the BDRV_O_INACTIVE flag so that no further write
4498      * is allowed. */
4499     for (pass = 0; pass < 2; pass++) {
4500         for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4501             ret = bdrv_inactivate_recurse(bs, pass);
4502             if (ret < 0) {
4503                 bdrv_next_cleanup(&it);
4504                 goto out;
4505             }
4506         }
4507     }
4508
4509 out:
4510     for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
4511         AioContext *aio_context = ctx->data;
4512         aio_context_release(aio_context);
4513     }
4514     g_slist_free(aio_ctxs);
4515
4516     return ret;
4517 }
4518
4519 /**************************************************************/
4520 /* removable device support */
4521
4522 /**
4523  * Return TRUE if the media is present
4524  */
4525 bool bdrv_is_inserted(BlockDriverState *bs)
4526 {
4527     BlockDriver *drv = bs->drv;
4528     BdrvChild *child;
4529
4530     if (!drv) {
4531         return false;
4532     }
4533     if (drv->bdrv_is_inserted) {
4534         return drv->bdrv_is_inserted(bs);
4535     }
4536     QLIST_FOREACH(child, &bs->children, next) {
4537         if (!bdrv_is_inserted(child->bs)) {
4538             return false;
4539         }
4540     }
4541     return true;
4542 }
4543
4544 /**
4545  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4546  */
4547 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4548 {
4549     BlockDriver *drv = bs->drv;
4550
4551     if (drv && drv->bdrv_eject) {
4552         drv->bdrv_eject(bs, eject_flag);
4553     }
4554 }
4555
4556 /**
4557  * Lock or unlock the media (if it is locked, the user won't be able
4558  * to eject it manually).
4559  */
4560 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4561 {
4562     BlockDriver *drv = bs->drv;
4563
4564     trace_bdrv_lock_medium(bs, locked);
4565
4566     if (drv && drv->bdrv_lock_medium) {
4567         drv->bdrv_lock_medium(bs, locked);
4568     }
4569 }
4570
4571 /* Get a reference to bs */
4572 void bdrv_ref(BlockDriverState *bs)
4573 {
4574     bs->refcnt++;
4575 }
4576
4577 /* Release a previously grabbed reference to bs.
4578  * If after releasing, reference count is zero, the BlockDriverState is
4579  * deleted. */
4580 void bdrv_unref(BlockDriverState *bs)
4581 {
4582     if (!bs) {
4583         return;
4584     }
4585     assert(bs->refcnt > 0);
4586     if (--bs->refcnt == 0) {
4587         bdrv_delete(bs);
4588     }
4589 }
4590
4591 struct BdrvOpBlocker {
4592     Error *reason;
4593     QLIST_ENTRY(BdrvOpBlocker) list;
4594 };
4595
4596 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
4597 {
4598     BdrvOpBlocker *blocker;
4599     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4600     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
4601         blocker = QLIST_FIRST(&bs->op_blockers[op]);
4602         error_propagate(errp, error_copy(blocker->reason));
4603         error_prepend(errp, "Node '%s' is busy: ",
4604                       bdrv_get_device_or_node_name(bs));
4605         return true;
4606     }
4607     return false;
4608 }
4609
4610 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
4611 {
4612     BdrvOpBlocker *blocker;
4613     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4614
4615     blocker = g_new0(BdrvOpBlocker, 1);
4616     blocker->reason = reason;
4617     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
4618 }
4619
4620 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
4621 {
4622     BdrvOpBlocker *blocker, *next;
4623     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4624     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
4625         if (blocker->reason == reason) {
4626             QLIST_REMOVE(blocker, list);
4627             g_free(blocker);
4628         }
4629     }
4630 }
4631
4632 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
4633 {
4634     int i;
4635     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4636         bdrv_op_block(bs, i, reason);
4637     }
4638 }
4639
4640 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
4641 {
4642     int i;
4643     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4644         bdrv_op_unblock(bs, i, reason);
4645     }
4646 }
4647
4648 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
4649 {
4650     int i;
4651
4652     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4653         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
4654             return false;
4655         }
4656     }
4657     return true;
4658 }
4659
4660 void bdrv_img_create(const char *filename, const char *fmt,
4661                      const char *base_filename, const char *base_fmt,
4662                      char *options, uint64_t img_size, int flags, bool quiet,
4663                      Error **errp)
4664 {
4665     QemuOptsList *create_opts = NULL;
4666     QemuOpts *opts = NULL;
4667     const char *backing_fmt, *backing_file;
4668     int64_t size;
4669     BlockDriver *drv, *proto_drv;
4670     Error *local_err = NULL;
4671     int ret = 0;
4672
4673     /* Find driver and parse its options */
4674     drv = bdrv_find_format(fmt);
4675     if (!drv) {
4676         error_setg(errp, "Unknown file format '%s'", fmt);
4677         return;
4678     }
4679
4680     proto_drv = bdrv_find_protocol(filename, true, errp);
4681     if (!proto_drv) {
4682         return;
4683     }
4684
4685     if (!drv->create_opts) {
4686         error_setg(errp, "Format driver '%s' does not support image creation",
4687                    drv->format_name);
4688         return;
4689     }
4690
4691     if (!proto_drv->create_opts) {
4692         error_setg(errp, "Protocol driver '%s' does not support image creation",
4693                    proto_drv->format_name);
4694         return;
4695     }
4696
4697     create_opts = qemu_opts_append(create_opts, drv->create_opts);
4698     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4699
4700     /* Create parameter list with default values */
4701     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4702     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4703
4704     /* Parse -o options */
4705     if (options) {
4706         qemu_opts_do_parse(opts, options, NULL, &local_err);
4707         if (local_err) {
4708             error_report_err(local_err);
4709             local_err = NULL;
4710             error_setg(errp, "Invalid options for file format '%s'", fmt);
4711             goto out;
4712         }
4713     }
4714
4715     if (base_filename) {
4716         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
4717         if (local_err) {
4718             error_setg(errp, "Backing file not supported for file format '%s'",
4719                        fmt);
4720             goto out;
4721         }
4722     }
4723
4724     if (base_fmt) {
4725         qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
4726         if (local_err) {
4727             error_setg(errp, "Backing file format not supported for file "
4728                              "format '%s'", fmt);
4729             goto out;
4730         }
4731     }
4732
4733     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
4734     if (backing_file) {
4735         if (!strcmp(filename, backing_file)) {
4736             error_setg(errp, "Error: Trying to create an image with the "
4737                              "same filename as the backing file");
4738             goto out;
4739         }
4740     }
4741
4742     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
4743
4744     /* The size for the image must always be specified, unless we have a backing
4745      * file and we have not been forbidden from opening it. */
4746     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
4747     if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
4748         BlockDriverState *bs;
4749         char *full_backing = g_new0(char, PATH_MAX);
4750         int back_flags;
4751         QDict *backing_options = NULL;
4752
4753         bdrv_get_full_backing_filename_from_filename(filename, backing_file,
4754                                                      full_backing, PATH_MAX,
4755                                                      &local_err);
4756         if (local_err) {
4757             g_free(full_backing);
4758             goto out;
4759         }
4760
4761         /* backing files always opened read-only */
4762         back_flags = flags;
4763         back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4764
4765         backing_options = qdict_new();
4766         if (backing_fmt) {
4767             qdict_put_str(backing_options, "driver", backing_fmt);
4768         }
4769         qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
4770
4771         bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
4772                        &local_err);
4773         g_free(full_backing);
4774         if (!bs && size != -1) {
4775             /* Couldn't open BS, but we have a size, so it's nonfatal */
4776             warn_reportf_err(local_err,
4777                             "Could not verify backing image. "
4778                             "This may become an error in future versions.\n");
4779             local_err = NULL;
4780         } else if (!bs) {
4781             /* Couldn't open bs, do not have size */
4782             error_append_hint(&local_err,
4783                               "Could not open backing image to determine size.\n");
4784             goto out;
4785         } else {
4786             if (size == -1) {
4787                 /* Opened BS, have no size */
4788                 size = bdrv_getlength(bs);
4789                 if (size < 0) {
4790                     error_setg_errno(errp, -size, "Could not get size of '%s'",
4791                                      backing_file);
4792                     bdrv_unref(bs);
4793                     goto out;
4794                 }
4795                 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
4796             }
4797             bdrv_unref(bs);
4798         }
4799     } /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
4800
4801     if (size == -1) {
4802         error_setg(errp, "Image creation needs a size parameter");
4803         goto out;
4804     }
4805
4806     if (!quiet) {
4807         printf("Formatting '%s', fmt=%s ", filename, fmt);
4808         qemu_opts_print(opts, " ");
4809         puts("");
4810     }
4811
4812     ret = bdrv_create(drv, filename, opts, &local_err);
4813
4814     if (ret == -EFBIG) {
4815         /* This is generally a better message than whatever the driver would
4816          * deliver (especially because of the cluster_size_hint), since that
4817          * is most probably not much different from "image too large". */
4818         const char *cluster_size_hint = "";
4819         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
4820             cluster_size_hint = " (try using a larger cluster size)";
4821         }
4822         error_setg(errp, "The image size is too large for file format '%s'"
4823                    "%s", fmt, cluster_size_hint);
4824         error_free(local_err);
4825         local_err = NULL;
4826     }
4827
4828 out:
4829     qemu_opts_del(opts);
4830     qemu_opts_free(create_opts);
4831     error_propagate(errp, local_err);
4832 }
4833
4834 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4835 {
4836     return bs ? bs->aio_context : qemu_get_aio_context();
4837 }
4838
4839 AioWait *bdrv_get_aio_wait(BlockDriverState *bs)
4840 {
4841     return bs ? &bs->wait : NULL;
4842 }
4843
4844 void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
4845 {
4846     aio_co_enter(bdrv_get_aio_context(bs), co);
4847 }
4848
4849 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
4850 {
4851     QLIST_REMOVE(ban, list);
4852     g_free(ban);
4853 }
4854
4855 void bdrv_detach_aio_context(BlockDriverState *bs)
4856 {
4857     BdrvAioNotifier *baf, *baf_tmp;
4858     BdrvChild *child;
4859
4860     if (!bs->drv) {
4861         return;
4862     }
4863
4864     assert(!bs->walking_aio_notifiers);
4865     bs->walking_aio_notifiers = true;
4866     QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
4867         if (baf->deleted) {
4868             bdrv_do_remove_aio_context_notifier(baf);
4869         } else {
4870             baf->detach_aio_context(baf->opaque);
4871         }
4872     }
4873     /* Never mind iterating again to check for ->deleted.  bdrv_close() will
4874      * remove remaining aio notifiers if we aren't called again.
4875      */
4876     bs->walking_aio_notifiers = false;
4877
4878     if (bs->drv->bdrv_detach_aio_context) {
4879         bs->drv->bdrv_detach_aio_context(bs);
4880     }
4881     QLIST_FOREACH(child, &bs->children, next) {
4882         bdrv_detach_aio_context(child->bs);
4883     }
4884
4885     bs->aio_context = NULL;
4886 }
4887
4888 void bdrv_attach_aio_context(BlockDriverState *bs,
4889                              AioContext *new_context)
4890 {
4891     BdrvAioNotifier *ban, *ban_tmp;
4892     BdrvChild *child;
4893
4894     if (!bs->drv) {
4895         return;
4896     }
4897
4898     bs->aio_context = new_context;
4899
4900     QLIST_FOREACH(child, &bs->children, next) {
4901         bdrv_attach_aio_context(child->bs, new_context);
4902     }
4903     if (bs->drv->bdrv_attach_aio_context) {
4904         bs->drv->bdrv_attach_aio_context(bs, new_context);
4905     }
4906
4907     assert(!bs->walking_aio_notifiers);
4908     bs->walking_aio_notifiers = true;
4909     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
4910         if (ban->deleted) {
4911             bdrv_do_remove_aio_context_notifier(ban);
4912         } else {
4913             ban->attached_aio_context(new_context, ban->opaque);
4914         }
4915     }
4916     bs->walking_aio_notifiers = false;
4917 }
4918
4919 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4920 {
4921     AioContext *ctx = bdrv_get_aio_context(bs);
4922
4923     aio_disable_external(ctx);
4924     bdrv_parent_drained_begin(bs, NULL);
4925     bdrv_drain(bs); /* ensure there are no in-flight requests */
4926
4927     while (aio_poll(ctx, false)) {
4928         /* wait for all bottom halves to execute */
4929     }
4930
4931     bdrv_detach_aio_context(bs);
4932
4933     /* This function executes in the old AioContext so acquire the new one in
4934      * case it runs in a different thread.
4935      */
4936     aio_context_acquire(new_context);
4937     bdrv_attach_aio_context(bs, new_context);
4938     bdrv_parent_drained_end(bs, NULL);
4939     aio_enable_external(ctx);
4940     aio_context_release(new_context);
4941 }
4942
4943 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4944         void (*attached_aio_context)(AioContext *new_context, void *opaque),
4945         void (*detach_aio_context)(void *opaque), void *opaque)
4946 {
4947     BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4948     *ban = (BdrvAioNotifier){
4949         .attached_aio_context = attached_aio_context,
4950         .detach_aio_context   = detach_aio_context,
4951         .opaque               = opaque
4952     };
4953
4954     QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4955 }
4956
4957 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4958                                       void (*attached_aio_context)(AioContext *,
4959                                                                    void *),
4960                                       void (*detach_aio_context)(void *),
4961                                       void *opaque)
4962 {
4963     BdrvAioNotifier *ban, *ban_next;
4964
4965     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4966         if (ban->attached_aio_context == attached_aio_context &&
4967             ban->detach_aio_context   == detach_aio_context   &&
4968             ban->opaque               == opaque               &&
4969             ban->deleted              == false)
4970         {
4971             if (bs->walking_aio_notifiers) {
4972                 ban->deleted = true;
4973             } else {
4974                 bdrv_do_remove_aio_context_notifier(ban);
4975             }
4976             return;
4977         }
4978     }
4979
4980     abort();
4981 }
4982
4983 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4984                        BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
4985 {
4986     if (!bs->drv) {
4987         return -ENOMEDIUM;
4988     }
4989     if (!bs->drv->bdrv_amend_options) {
4990         return -ENOTSUP;
4991     }
4992     return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
4993 }
4994
4995 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4996  * of block filter and by bdrv_is_first_non_filter.
4997  * It is used to test if the given bs is the candidate or recurse more in the
4998  * node graph.
4999  */
5000 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5001                                       BlockDriverState *candidate)
5002 {
5003     /* return false if basic checks fails */
5004     if (!bs || !bs->drv) {
5005         return false;
5006     }
5007
5008     /* the code reached a non block filter driver -> check if the bs is
5009      * the same as the candidate. It's the recursion termination condition.
5010      */
5011     if (!bs->drv->is_filter) {
5012         return bs == candidate;
5013     }
5014     /* Down this path the driver is a block filter driver */
5015
5016     /* If the block filter recursion method is defined use it to recurse down
5017      * the node graph.
5018      */
5019     if (bs->drv->bdrv_recurse_is_first_non_filter) {
5020         return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5021     }
5022
5023     /* the driver is a block filter but don't allow to recurse -> return false
5024      */
5025     return false;
5026 }
5027
5028 /* This function checks if the candidate is the first non filter bs down it's
5029  * bs chain. Since we don't have pointers to parents it explore all bs chains
5030  * from the top. Some filters can choose not to pass down the recursion.
5031  */
5032 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5033 {
5034     BlockDriverState *bs;
5035     BdrvNextIterator it;
5036
5037     /* walk down the bs forest recursively */
5038     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
5039         bool perm;
5040
5041         /* try to recurse in this top level bs */
5042         perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5043
5044         /* candidate is the first non filter */
5045         if (perm) {
5046             bdrv_next_cleanup(&it);
5047             return true;
5048         }
5049     }
5050
5051     return false;
5052 }
5053
5054 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
5055                                         const char *node_name, Error **errp)
5056 {
5057     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5058     AioContext *aio_context;
5059
5060     if (!to_replace_bs) {
5061         error_setg(errp, "Node name '%s' not found", node_name);
5062         return NULL;
5063     }
5064
5065     aio_context = bdrv_get_aio_context(to_replace_bs);
5066     aio_context_acquire(aio_context);
5067
5068     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5069         to_replace_bs = NULL;
5070         goto out;
5071     }
5072
5073     /* We don't want arbitrary node of the BDS chain to be replaced only the top
5074      * most non filter in order to prevent data corruption.
5075      * Another benefit is that this tests exclude backing files which are
5076      * blocked by the backing blockers.
5077      */
5078     if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
5079         error_setg(errp, "Only top most non filter can be replaced");
5080         to_replace_bs = NULL;
5081         goto out;
5082     }
5083
5084 out:
5085     aio_context_release(aio_context);
5086     return to_replace_bs;
5087 }
5088
5089 static bool append_open_options(QDict *d, BlockDriverState *bs)
5090 {
5091     const QDictEntry *entry;
5092     QemuOptDesc *desc;
5093     BdrvChild *child;
5094     bool found_any = false;
5095     const char *p;
5096
5097     for (entry = qdict_first(bs->options); entry;
5098          entry = qdict_next(bs->options, entry))
5099     {
5100         /* Exclude options for children */
5101         QLIST_FOREACH(child, &bs->children, next) {
5102             if (strstart(qdict_entry_key(entry), child->name, &p)
5103                 && (!*p || *p == '.'))
5104             {
5105                 break;
5106             }
5107         }
5108         if (child) {
5109             continue;
5110         }
5111
5112         /* And exclude all non-driver-specific options */
5113         for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
5114             if (!strcmp(qdict_entry_key(entry), desc->name)) {
5115                 break;
5116             }
5117         }
5118         if (desc->name) {
5119             continue;
5120         }
5121
5122         qobject_incref(qdict_entry_value(entry));
5123         qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
5124         found_any = true;
5125     }
5126
5127     return found_any;
5128 }
5129
5130 /* Updates the following BDS fields:
5131  *  - exact_filename: A filename which may be used for opening a block device
5132  *                    which (mostly) equals the given BDS (even without any
5133  *                    other options; so reading and writing must return the same
5134  *                    results, but caching etc. may be different)
5135  *  - full_open_options: Options which, when given when opening a block device
5136  *                       (without a filename), result in a BDS (mostly)
5137  *                       equalling the given one
5138  *  - filename: If exact_filename is set, it is copied here. Otherwise,
5139  *              full_open_options is converted to a JSON object, prefixed with
5140  *              "json:" (for use through the JSON pseudo protocol) and put here.
5141  */
5142 void bdrv_refresh_filename(BlockDriverState *bs)
5143 {
5144     BlockDriver *drv = bs->drv;
5145     QDict *opts;
5146
5147     if (!drv) {
5148         return;
5149     }
5150
5151     /* This BDS's file name will most probably depend on its file's name, so
5152      * refresh that first */
5153     if (bs->file) {
5154         bdrv_refresh_filename(bs->file->bs);
5155     }
5156
5157     if (drv->bdrv_refresh_filename) {
5158         /* Obsolete information is of no use here, so drop the old file name
5159          * information before refreshing it */
5160         bs->exact_filename[0] = '\0';
5161         if (bs->full_open_options) {
5162             QDECREF(bs->full_open_options);
5163             bs->full_open_options = NULL;
5164         }
5165
5166         opts = qdict_new();
5167         append_open_options(opts, bs);
5168         drv->bdrv_refresh_filename(bs, opts);
5169         QDECREF(opts);
5170     } else if (bs->file) {
5171         /* Try to reconstruct valid information from the underlying file */
5172         bool has_open_options;
5173
5174         bs->exact_filename[0] = '\0';
5175         if (bs->full_open_options) {
5176             QDECREF(bs->full_open_options);
5177             bs->full_open_options = NULL;
5178         }
5179
5180         opts = qdict_new();
5181         has_open_options = append_open_options(opts, bs);
5182
5183         /* If no specific options have been given for this BDS, the filename of
5184          * the underlying file should suffice for this one as well */
5185         if (bs->file->bs->exact_filename[0] && !has_open_options) {
5186             strcpy(bs->exact_filename, bs->file->bs->exact_filename);
5187         }
5188         /* Reconstructing the full options QDict is simple for most format block
5189          * drivers, as long as the full options are known for the underlying
5190          * file BDS. The full options QDict of that file BDS should somehow
5191          * contain a representation of the filename, therefore the following
5192          * suffices without querying the (exact_)filename of this BDS. */
5193         if (bs->file->bs->full_open_options) {
5194             qdict_put_str(opts, "driver", drv->format_name);
5195             QINCREF(bs->file->bs->full_open_options);
5196             qdict_put(opts, "file", bs->file->bs->full_open_options);
5197
5198             bs->full_open_options = opts;
5199         } else {
5200             QDECREF(opts);
5201         }
5202     } else if (!bs->full_open_options && qdict_size(bs->options)) {
5203         /* There is no underlying file BDS (at least referenced by BDS.file),
5204          * so the full options QDict should be equal to the options given
5205          * specifically for this block device when it was opened (plus the
5206          * driver specification).
5207          * Because those options don't change, there is no need to update
5208          * full_open_options when it's already set. */
5209
5210         opts = qdict_new();
5211         append_open_options(opts, bs);
5212         qdict_put_str(opts, "driver", drv->format_name);
5213
5214         if (bs->exact_filename[0]) {
5215             /* This may not work for all block protocol drivers (some may
5216              * require this filename to be parsed), but we have to find some
5217              * default solution here, so just include it. If some block driver
5218              * does not support pure options without any filename at all or
5219              * needs some special format of the options QDict, it needs to
5220              * implement the driver-specific bdrv_refresh_filename() function.
5221              */
5222             qdict_put_str(opts, "filename", bs->exact_filename);
5223         }
5224
5225         bs->full_open_options = opts;
5226     }
5227
5228     if (bs->exact_filename[0]) {
5229         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
5230     } else if (bs->full_open_options) {
5231         QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
5232         snprintf(bs->filename, sizeof(bs->filename), "json:%s",
5233                  qstring_get_str(json));
5234         QDECREF(json);
5235     }
5236 }
5237
5238 /*
5239  * Hot add/remove a BDS's child. So the user can take a child offline when
5240  * it is broken and take a new child online
5241  */
5242 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
5243                     Error **errp)
5244 {
5245
5246     if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
5247         error_setg(errp, "The node %s does not support adding a child",
5248                    bdrv_get_device_or_node_name(parent_bs));
5249         return;
5250     }
5251
5252     if (!QLIST_EMPTY(&child_bs->parents)) {
5253         error_setg(errp, "The node %s already has a parent",
5254                    child_bs->node_name);
5255         return;
5256     }
5257
5258     parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
5259 }
5260
5261 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
5262 {
5263     BdrvChild *tmp;
5264
5265     if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
5266         error_setg(errp, "The node %s does not support removing a child",
5267                    bdrv_get_device_or_node_name(parent_bs));
5268         return;
5269     }
5270
5271     QLIST_FOREACH(tmp, &parent_bs->children, next) {
5272         if (tmp == child) {
5273             break;
5274         }
5275     }
5276
5277     if (!tmp) {
5278         error_setg(errp, "The node %s does not have a child named %s",
5279                    bdrv_get_device_or_node_name(parent_bs),
5280                    bdrv_get_device_or_node_name(child->bs));
5281         return;
5282     }
5283
5284     parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
5285 }
5286
5287 bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
5288                                      uint32_t granularity, Error **errp)
5289 {
5290     BlockDriver *drv = bs->drv;
5291
5292     if (!drv) {
5293         error_setg_errno(errp, ENOMEDIUM,
5294                          "Can't store persistent bitmaps to %s",
5295                          bdrv_get_device_or_node_name(bs));
5296         return false;
5297     }
5298
5299     if (!drv->bdrv_can_store_new_dirty_bitmap) {
5300         error_setg_errno(errp, ENOTSUP,
5301                          "Can't store persistent bitmaps to %s",
5302                          bdrv_get_device_or_node_name(bs));
5303         return false;
5304     }
5305
5306     return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);
5307 }