block.c

   1 /*
   2  * QEMU System Emulator block driver
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  * Copyright (c) 2020 Virtuozzo International GmbH.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "qemu/osdep.h"
  27 #include "block/trace.h"
  28 #include "block/block_int.h"
  29 #include "block/blockjob.h"
  30 #include "block/dirty-bitmap.h"
  31 #include "block/fuse.h"
  32 #include "block/nbd.h"
  33 #include "block/qdict.h"
  34 #include "qemu/error-report.h"
  35 #include "block/module_block.h"
  36 #include "qemu/main-loop.h"
  37 #include "qemu/module.h"
  38 #include "qapi/error.h"
  39 #include "qapi/qmp/qdict.h"
  40 #include "qapi/qmp/qjson.h"
  41 #include "qapi/qmp/qnull.h"
  42 #include "qapi/qmp/qstring.h"
  43 #include "qapi/qobject-output-visitor.h"
  44 #include "qapi/qapi-visit-block-core.h"
  45 #include "sysemu/block-backend.h"
  46 #include "qemu/notify.h"
  47 #include "qemu/option.h"
  48 #include "qemu/coroutine.h"
  49 #include "block/qapi.h"
  50 #include "qemu/timer.h"
  51 #include "qemu/cutils.h"
  52 #include "qemu/id.h"
  53 #include "qemu/range.h"
  54 #include "qemu/rcu.h"
  55 #include "block/coroutines.h"
  56
  57 #ifdef CONFIG_BSD
  58 #include <sys/ioctl.h>
  59 #include <sys/queue.h>
  60 #if defined(HAVE_SYS_DISK_H)
  61 #include <sys/disk.h>
  62 #endif
  63 #endif
  64
  65 #ifdef _WIN32
  66 #include <windows.h>
  67 #endif
  68
  69 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
  70
  71 /* Protected by BQL */
  72 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
  73     QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
  74
  75 /* Protected by BQL */
  76 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
  77     QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
  78
  79 /* Protected by BQL */
  80 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
  81     QLIST_HEAD_INITIALIZER(bdrv_drivers);
  82
  83 static BlockDriverState *bdrv_open_inherit(const char *filename,
  84                                            const char *reference,
  85                                            QDict *options, int flags,
  86                                            BlockDriverState *parent,
  87                                            const BdrvChildClass *child_class,
  88                                            BdrvChildRole child_role,
  89                                            Error **errp);
  90
  91 static bool bdrv_recurse_has_child(BlockDriverState *bs,
  92                                    BlockDriverState *child);
  93
  94 static void GRAPH_WRLOCK
  95 bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs);
  96
  97 static void GRAPH_WRLOCK
  98 bdrv_remove_child(BdrvChild *child, Transaction *tran);
  99
 100 static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
 101                                BlockReopenQueue *queue,
 102                                Transaction *change_child_tran, Error **errp);
 103 static void bdrv_reopen_commit(BDRVReopenState *reopen_state);
 104 static void bdrv_reopen_abort(BDRVReopenState *reopen_state);
 105
 106 static bool bdrv_backing_overridden(BlockDriverState *bs);
 107
 108 static bool bdrv_change_aio_context(BlockDriverState *bs, AioContext *ctx,
 109                                     GHashTable *visited, Transaction *tran,
 110                                     Error **errp);
 111
 112 /* If non-zero, use only whitelisted block drivers */
 113 static int use_bdrv_whitelist;
 114
 115 #ifdef _WIN32
 116 static int is_windows_drive_prefix(const char *filename)
 117 {
 118     return (((filename[0] >= 'a' && filename[0] <= 'z') ||
 119              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 120             filename[1] == ':');
 121 }
 122
 123 int is_windows_drive(const char *filename)
 124 {
 125     if (is_windows_drive_prefix(filename) &&
 126         filename[2] == '\0')
 127         return 1;
 128     if (strstart(filename, "\\\\.\\", NULL) ||
 129         strstart(filename, "//./", NULL))
 130         return 1;
 131     return 0;
 132 }
 133 #endif
 134
 135 size_t bdrv_opt_mem_align(BlockDriverState *bs)
 136 {
 137     if (!bs || !bs->drv) {
 138         /* page size or 4k (hdd sector size) should be on the safe side */
 139         return MAX(4096, qemu_real_host_page_size());
 140     }
 141     IO_CODE();
 142
 143     return bs->bl.opt_mem_alignment;
 144 }
 145
 146 size_t bdrv_min_mem_align(BlockDriverState *bs)
 147 {
 148     if (!bs || !bs->drv) {
 149         /* page size or 4k (hdd sector size) should be on the safe side */
 150         return MAX(4096, qemu_real_host_page_size());
 151     }
 152     IO_CODE();
 153
 154     return bs->bl.min_mem_alignment;
 155 }
 156
 157 /* check if the path starts with "<protocol>:" */
 158 int path_has_protocol(const char *path)
 159 {
 160     const char *p;
 161
 162 #ifdef _WIN32
 163     if (is_windows_drive(path) ||
 164         is_windows_drive_prefix(path)) {
 165         return 0;
 166     }
 167     p = path + strcspn(path, ":/\\");
 168 #else
 169     p = path + strcspn(path, ":/");
 170 #endif
 171
 172     return *p == ':';
 173 }
 174
 175 int path_is_absolute(const char *path)
 176 {
 177 #ifdef _WIN32
 178     /* specific case for names like: "\\.\d:" */
 179     if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
 180         return 1;
 181     }
 182     return (*path == '/' || *path == '\\');
 183 #else
 184     return (*path == '/');
 185 #endif
 186 }
 187
 188 /* if filename is absolute, just return its duplicate. Otherwise, build a
 189    path to it by considering it is relative to base_path. URL are
 190    supported. */
 191 char *path_combine(const char *base_path, const char *filename)
 192 {
 193     const char *protocol_stripped = NULL;
 194     const char *p, *p1;
 195     char *result;
 196     int len;
 197
 198     if (path_is_absolute(filename)) {
 199         return g_strdup(filename);
 200     }
 201
 202     if (path_has_protocol(base_path)) {
 203         protocol_stripped = strchr(base_path, ':');
 204         if (protocol_stripped) {
 205             protocol_stripped++;
 206         }
 207     }
 208     p = protocol_stripped ?: base_path;
 209
 210     p1 = strrchr(base_path, '/');
 211 #ifdef _WIN32
 212     {
 213         const char *p2;
 214         p2 = strrchr(base_path, '\\');
 215         if (!p1 || p2 > p1) {
 216             p1 = p2;
 217         }
 218     }
 219 #endif
 220     if (p1) {
 221         p1++;
 222     } else {
 223         p1 = base_path;
 224     }
 225     if (p1 > p) {
 226         p = p1;
 227     }
 228     len = p - base_path;
 229
 230     result = g_malloc(len + strlen(filename) + 1);
 231     memcpy(result, base_path, len);
 232     strcpy(result + len, filename);
 233
 234     return result;
 235 }
 236
 237 /*
 238  * Helper function for bdrv_parse_filename() implementations to remove optional
 239  * protocol prefixes (especially "file:") from a filename and for putting the
 240  * stripped filename into the options QDict if there is such a prefix.
 241  */
 242 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
 243                                       QDict *options)
 244 {
 245     if (strstart(filename, prefix, &filename)) {
 246         /* Stripping the explicit protocol prefix may result in a protocol
 247          * prefix being (wrongly) detected (if the filename contains a colon) */
 248         if (path_has_protocol(filename)) {
 249             GString *fat_filename;
 250
 251             /* This means there is some colon before the first slash; therefore,
 252              * this cannot be an absolute path */
 253             assert(!path_is_absolute(filename));
 254
 255             /* And we can thus fix the protocol detection issue by prefixing it
 256              * by "./" */
 257             fat_filename = g_string_new("./");
 258             g_string_append(fat_filename, filename);
 259
 260             assert(!path_has_protocol(fat_filename->str));
 261
 262             qdict_put(options, "filename",
 263                       qstring_from_gstring(fat_filename));
 264         } else {
 265             /* If no protocol prefix was detected, we can use the shortened
 266              * filename as-is */
 267             qdict_put_str(options, "filename", filename);
 268         }
 269     }
 270 }
 271
 272
 273 /* Returns whether the image file is opened as read-only. Note that this can
 274  * return false and writing to the image file is still not possible because the
 275  * image is inactivated. */
 276 bool bdrv_is_read_only(BlockDriverState *bs)
 277 {
 278     IO_CODE();
 279     return !(bs->open_flags & BDRV_O_RDWR);
 280 }
 281
 282 static int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
 283                                   bool ignore_allow_rdw, Error **errp)
 284 {
 285     IO_CODE();
 286
 287     /* Do not set read_only if copy_on_read is enabled */
 288     if (bs->copy_on_read && read_only) {
 289         error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
 290                    bdrv_get_device_or_node_name(bs));
 291         return -EINVAL;
 292     }
 293
 294     /* Do not clear read_only if it is prohibited */
 295     if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
 296         !ignore_allow_rdw)
 297     {
 298         error_setg(errp, "Node '%s' is read only",
 299                    bdrv_get_device_or_node_name(bs));
 300         return -EPERM;
 301     }
 302
 303     return 0;
 304 }
 305
 306 /*
 307  * Called by a driver that can only provide a read-only image.
 308  *
 309  * Returns 0 if the node is already read-only or it could switch the node to
 310  * read-only because BDRV_O_AUTO_RDONLY is set.
 311  *
 312  * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
 313  * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
 314  * is not NULL, it is used as the error message for the Error object.
 315  */
 316 int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
 317                               Error **errp)
 318 {
 319     int ret = 0;
 320     IO_CODE();
 321
 322     if (!(bs->open_flags & BDRV_O_RDWR)) {
 323         return 0;
 324     }
 325     if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) {
 326         goto fail;
 327     }
 328
 329     ret = bdrv_can_set_read_only(bs, true, false, NULL);
 330     if (ret < 0) {
 331         goto fail;
 332     }
 333
 334     bs->open_flags &= ~BDRV_O_RDWR;
 335
 336     return 0;
 337
 338 fail:
 339     error_setg(errp, "%s", errmsg ?: "Image is read-only");
 340     return -EACCES;
 341 }
 342
 343 /*
 344  * If @backing is empty, this function returns NULL without setting
 345  * @errp.  In all other cases, NULL will only be returned with @errp
 346  * set.
 347  *
 348  * Therefore, a return value of NULL without @errp set means that
 349  * there is no backing file; if @errp is set, there is one but its
 350  * absolute filename cannot be generated.
 351  */
 352 char *bdrv_get_full_backing_filename_from_filename(const char *backed,
 353                                                    const char *backing,
 354                                                    Error **errp)
 355 {
 356     if (backing[0] == '\0') {
 357         return NULL;
 358     } else if (path_has_protocol(backing) || path_is_absolute(backing)) {
 359         return g_strdup(backing);
 360     } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
 361         error_setg(errp, "Cannot use relative backing file names for '%s'",
 362                    backed);
 363         return NULL;
 364     } else {
 365         return path_combine(backed, backing);
 366     }
 367 }
 368
 369 /*
 370  * If @filename is empty or NULL, this function returns NULL without
 371  * setting @errp.  In all other cases, NULL will only be returned with
 372  * @errp set.
 373  */
 374 static char *bdrv_make_absolute_filename(BlockDriverState *relative_to,
 375                                          const char *filename, Error **errp)
 376 {
 377     char *dir, *full_name;
 378
 379     if (!filename || filename[0] == '\0') {
 380         return NULL;
 381     } else if (path_has_protocol(filename) || path_is_absolute(filename)) {
 382         return g_strdup(filename);
 383     }
 384
 385     dir = bdrv_dirname(relative_to, errp);
 386     if (!dir) {
 387         return NULL;
 388     }
 389
 390     full_name = g_strconcat(dir, filename, NULL);
 391     g_free(dir);
 392     return full_name;
 393 }
 394
 395 char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp)
 396 {
 397     GLOBAL_STATE_CODE();
 398     return bdrv_make_absolute_filename(bs, bs->backing_file, errp);
 399 }
 400
 401 void bdrv_register(BlockDriver *bdrv)
 402 {
 403     assert(bdrv->format_name);
 404     GLOBAL_STATE_CODE();
 405     QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
 406 }
 407
 408 BlockDriverState *bdrv_new(void)
 409 {
 410     BlockDriverState *bs;
 411     int i;
 412
 413     GLOBAL_STATE_CODE();
 414
 415     bs = g_new0(BlockDriverState, 1);
 416     QLIST_INIT(&bs->dirty_bitmaps);
 417     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
 418         QLIST_INIT(&bs->op_blockers[i]);
 419     }
 420     qemu_mutex_init(&bs->reqs_lock);
 421     qemu_mutex_init(&bs->dirty_bitmap_mutex);
 422     bs->refcnt = 1;
 423     bs->aio_context = qemu_get_aio_context();
 424
 425     qemu_co_queue_init(&bs->flush_queue);
 426
 427     qemu_co_mutex_init(&bs->bsc_modify_lock);
 428     bs->block_status_cache = g_new0(BdrvBlockStatusCache, 1);
 429
 430     for (i = 0; i < bdrv_drain_all_count; i++) {
 431         bdrv_drained_begin(bs);
 432     }
 433
 434     QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
 435
 436     return bs;
 437 }
 438
 439 static BlockDriver *bdrv_do_find_format(const char *format_name)
 440 {
 441     BlockDriver *drv1;
 442     GLOBAL_STATE_CODE();
 443
 444     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 445         if (!strcmp(drv1->format_name, format_name)) {
 446             return drv1;
 447         }
 448     }
 449
 450     return NULL;
 451 }
 452
 453 BlockDriver *bdrv_find_format(const char *format_name)
 454 {
 455     BlockDriver *drv1;
 456     int i;
 457
 458     GLOBAL_STATE_CODE();
 459
 460     drv1 = bdrv_do_find_format(format_name);
 461     if (drv1) {
 462         return drv1;
 463     }
 464
 465     /* The driver isn't registered, maybe we need to load a module */
 466     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
 467         if (!strcmp(block_driver_modules[i].format_name, format_name)) {
 468             Error *local_err = NULL;
 469             int rv = block_module_load(block_driver_modules[i].library_name,
 470                                        &local_err);
 471             if (rv > 0) {
 472                 return bdrv_do_find_format(format_name);
 473             } else if (rv < 0) {
 474                 error_report_err(local_err);
 475             }
 476             break;
 477         }
 478     }
 479     return NULL;
 480 }
 481
 482 static int bdrv_format_is_whitelisted(const char *format_name, bool read_only)
 483 {
 484     static const char *whitelist_rw[] = {
 485         CONFIG_BDRV_RW_WHITELIST
 486         NULL
 487     };
 488     static const char *whitelist_ro[] = {
 489         CONFIG_BDRV_RO_WHITELIST
 490         NULL
 491     };
 492     const char **p;
 493
 494     if (!whitelist_rw[0] && !whitelist_ro[0]) {
 495         return 1;               /* no whitelist, anything goes */
 496     }
 497
 498     for (p = whitelist_rw; *p; p++) {
 499         if (!strcmp(format_name, *p)) {
 500             return 1;
 501         }
 502     }
 503     if (read_only) {
 504         for (p = whitelist_ro; *p; p++) {
 505             if (!strcmp(format_name, *p)) {
 506                 return 1;
 507             }
 508         }
 509     }
 510     return 0;
 511 }
 512
 513 int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
 514 {
 515     GLOBAL_STATE_CODE();
 516     return bdrv_format_is_whitelisted(drv->format_name, read_only);
 517 }
 518
 519 bool bdrv_uses_whitelist(void)
 520 {
 521     return use_bdrv_whitelist;
 522 }
 523
 524 typedef struct CreateCo {
 525     BlockDriver *drv;
 526     char *filename;
 527     QemuOpts *opts;
 528     int ret;
 529     Error *err;
 530 } CreateCo;
 531
 532 int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
 533                                 QemuOpts *opts, Error **errp)
 534 {
 535     int ret;
 536     GLOBAL_STATE_CODE();
 537     ERRP_GUARD();
 538
 539     if (!drv->bdrv_co_create_opts) {
 540         error_setg(errp, "Driver '%s' does not support image creation",
 541                    drv->format_name);
 542         return -ENOTSUP;
 543     }
 544
 545     ret = drv->bdrv_co_create_opts(drv, filename, opts, errp);
 546     if (ret < 0 && !*errp) {
 547         error_setg_errno(errp, -ret, "Could not create image");
 548     }
 549
 550     return ret;
 551 }
 552
 553 /**
 554  * Helper function for bdrv_create_file_fallback(): Resize @blk to at
 555  * least the given @minimum_size.
 556  *
 557  * On success, return @blk's actual length.
 558  * Otherwise, return -errno.
 559  */
 560 static int64_t coroutine_fn GRAPH_UNLOCKED
 561 create_file_fallback_truncate(BlockBackend *blk, int64_t minimum_size,
 562                               Error **errp)
 563 {
 564     Error *local_err = NULL;
 565     int64_t size;
 566     int ret;
 567
 568     GLOBAL_STATE_CODE();
 569
 570     ret = blk_co_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
 571                           &local_err);
 572     if (ret < 0 && ret != -ENOTSUP) {
 573         error_propagate(errp, local_err);
 574         return ret;
 575     }
 576
 577     size = blk_co_getlength(blk);
 578     if (size < 0) {
 579         error_free(local_err);
 580         error_setg_errno(errp, -size,
 581                          "Failed to inquire the new image file's length");
 582         return size;
 583     }
 584
 585     if (size < minimum_size) {
 586         /* Need to grow the image, but we failed to do that */
 587         error_propagate(errp, local_err);
 588         return -ENOTSUP;
 589     }
 590
 591     error_free(local_err);
 592     local_err = NULL;
 593
 594     return size;
 595 }
 596
 597 /**
 598  * Helper function for bdrv_create_file_fallback(): Zero the first
 599  * sector to remove any potentially pre-existing image header.
 600  */
 601 static int coroutine_fn
 602 create_file_fallback_zero_first_sector(BlockBackend *blk,
 603                                        int64_t current_size,
 604                                        Error **errp)
 605 {
 606     int64_t bytes_to_clear;
 607     int ret;
 608
 609     GLOBAL_STATE_CODE();
 610
 611     bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
 612     if (bytes_to_clear) {
 613         ret = blk_co_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
 614         if (ret < 0) {
 615             error_setg_errno(errp, -ret,
 616                              "Failed to clear the new image's first sector");
 617             return ret;
 618         }
 619     }
 620
 621     return 0;
 622 }
 623
 624 /**
 625  * Simple implementation of bdrv_co_create_opts for protocol drivers
 626  * which only support creation via opening a file
 627  * (usually existing raw storage device)
 628  */
 629 int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv,
 630                                             const char *filename,
 631                                             QemuOpts *opts,
 632                                             Error **errp)
 633 {
 634     BlockBackend *blk;
 635     QDict *options;
 636     int64_t size = 0;
 637     char *buf = NULL;
 638     PreallocMode prealloc;
 639     Error *local_err = NULL;
 640     int ret;
 641
 642     GLOBAL_STATE_CODE();
 643
 644     size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 645     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
 646     prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
 647                                PREALLOC_MODE_OFF, &local_err);
 648     g_free(buf);
 649     if (local_err) {
 650         error_propagate(errp, local_err);
 651         return -EINVAL;
 652     }
 653
 654     if (prealloc != PREALLOC_MODE_OFF) {
 655         error_setg(errp, "Unsupported preallocation mode '%s'",
 656                    PreallocMode_str(prealloc));
 657         return -ENOTSUP;
 658     }
 659
 660     options = qdict_new();
 661     qdict_put_str(options, "driver", drv->format_name);
 662
 663     blk = blk_co_new_open(filename, NULL, options,
 664                           BDRV_O_RDWR | BDRV_O_RESIZE, errp);
 665     if (!blk) {
 666         error_prepend(errp, "Protocol driver '%s' does not support creating "
 667                       "new images, so an existing image must be selected as "
 668                       "the target; however, opening the given target as an "
 669                       "existing image failed: ",
 670                       drv->format_name);
 671         return -EINVAL;
 672     }
 673
 674     size = create_file_fallback_truncate(blk, size, errp);
 675     if (size < 0) {
 676         ret = size;
 677         goto out;
 678     }
 679
 680     ret = create_file_fallback_zero_first_sector(blk, size, errp);
 681     if (ret < 0) {
 682         goto out;
 683     }
 684
 685     ret = 0;
 686 out:
 687     blk_co_unref(blk);
 688     return ret;
 689 }
 690
 691 int coroutine_fn bdrv_co_create_file(const char *filename, QemuOpts *opts,
 692                                      Error **errp)
 693 {
 694     QemuOpts *protocol_opts;
 695     BlockDriver *drv;
 696     QDict *qdict;
 697     int ret;
 698
 699     GLOBAL_STATE_CODE();
 700
 701     drv = bdrv_find_protocol(filename, true, errp);
 702     if (drv == NULL) {
 703         return -ENOENT;
 704     }
 705
 706     if (!drv->create_opts) {
 707         error_setg(errp, "Driver '%s' does not support image creation",
 708                    drv->format_name);
 709         return -ENOTSUP;
 710     }
 711
 712     /*
 713      * 'opts' contains a QemuOptsList with a combination of format and protocol
 714      * default values.
 715      *
 716      * The format properly removes its options, but the default values remain
 717      * in 'opts->list'.  So if the protocol has options with the same name
 718      * (e.g. rbd has 'cluster_size' as qcow2), it will see the default values
 719      * of the format, since for overlapping options, the format wins.
 720      *
 721      * To avoid this issue, lets convert QemuOpts to QDict, in this way we take
 722      * only the set options, and then convert it back to QemuOpts, using the
 723      * create_opts of the protocol. So the new QemuOpts, will contain only the
 724      * protocol defaults.
 725      */
 726     qdict = qemu_opts_to_qdict(opts, NULL);
 727     protocol_opts = qemu_opts_from_qdict(drv->create_opts, qdict, errp);
 728     if (protocol_opts == NULL) {
 729         ret = -EINVAL;
 730         goto out;
 731     }
 732
 733     ret = bdrv_co_create(drv, filename, protocol_opts, errp);
 734 out:
 735     qemu_opts_del(protocol_opts);
 736     qobject_unref(qdict);
 737     return ret;
 738 }
 739
 740 int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)
 741 {
 742     Error *local_err = NULL;
 743     int ret;
 744
 745     IO_CODE();
 746     assert(bs != NULL);
 747     assert_bdrv_graph_readable();
 748
 749     if (!bs->drv) {
 750         error_setg(errp, "Block node '%s' is not opened", bs->filename);
 751         return -ENOMEDIUM;
 752     }
 753
 754     if (!bs->drv->bdrv_co_delete_file) {
 755         error_setg(errp, "Driver '%s' does not support image deletion",
 756                    bs->drv->format_name);
 757         return -ENOTSUP;
 758     }
 759
 760     ret = bs->drv->bdrv_co_delete_file(bs, &local_err);
 761     if (ret < 0) {
 762         error_propagate(errp, local_err);
 763     }
 764
 765     return ret;
 766 }
 767
 768 void coroutine_fn bdrv_co_delete_file_noerr(BlockDriverState *bs)
 769 {
 770     Error *local_err = NULL;
 771     int ret;
 772     IO_CODE();
 773
 774     if (!bs) {
 775         return;
 776     }
 777
 778     ret = bdrv_co_delete_file(bs, &local_err);
 779     /*
 780      * ENOTSUP will happen if the block driver doesn't support
 781      * the 'bdrv_co_delete_file' interface. This is a predictable
 782      * scenario and shouldn't be reported back to the user.
 783      */
 784     if (ret == -ENOTSUP) {
 785         error_free(local_err);
 786     } else if (ret < 0) {
 787         error_report_err(local_err);
 788     }
 789 }
 790
 791 /**
 792  * Try to get @bs's logical and physical block size.
 793  * On success, store them in @bsz struct and return 0.
 794  * On failure return -errno.
 795  * @bs must not be empty.
 796  */
 797 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 798 {
 799     BlockDriver *drv = bs->drv;
 800     BlockDriverState *filtered = bdrv_filter_bs(bs);
 801     GLOBAL_STATE_CODE();
 802
 803     if (drv && drv->bdrv_probe_blocksizes) {
 804         return drv->bdrv_probe_blocksizes(bs, bsz);
 805     } else if (filtered) {
 806         return bdrv_probe_blocksizes(filtered, bsz);
 807     }
 808
 809     return -ENOTSUP;
 810 }
 811
 812 /**
 813  * Try to get @bs's geometry (cyls, heads, sectors).
 814  * On success, store them in @geo struct and return 0.
 815  * On failure return -errno.
 816  * @bs must not be empty.
 817  */
 818 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 819 {
 820     BlockDriver *drv = bs->drv;
 821     BlockDriverState *filtered = bdrv_filter_bs(bs);
 822     GLOBAL_STATE_CODE();
 823
 824     if (drv && drv->bdrv_probe_geometry) {
 825         return drv->bdrv_probe_geometry(bs, geo);
 826     } else if (filtered) {
 827         return bdrv_probe_geometry(filtered, geo);
 828     }
 829
 830     return -ENOTSUP;
 831 }
 832
 833 /*
 834  * Create a uniquely-named empty temporary file.
 835  * Return the actual file name used upon success, otherwise NULL.
 836  * This string should be freed with g_free() when not needed any longer.
 837  *
 838  * Note: creating a temporary file for the caller to (re)open is
 839  * inherently racy. Use g_file_open_tmp() instead whenever practical.
 840  */
 841 char *create_tmp_file(Error **errp)
 842 {
 843     int fd;
 844     const char *tmpdir;
 845     g_autofree char *filename = NULL;
 846
 847     tmpdir = g_get_tmp_dir();
 848 #ifndef _WIN32
 849     /*
 850      * See commit 69bef79 ("block: use /var/tmp instead of /tmp for -snapshot")
 851      *
 852      * This function is used to create temporary disk images (like -snapshot),
 853      * so the files can become very large. /tmp is often a tmpfs where as
 854      * /var/tmp is usually on a disk, so more appropriate for disk images.
 855      */
 856     if (!g_strcmp0(tmpdir, "/tmp")) {
 857         tmpdir = "/var/tmp";
 858     }
 859 #endif
 860
 861     filename = g_strdup_printf("%s/vl.XXXXXX", tmpdir);
 862     fd = g_mkstemp(filename);
 863     if (fd < 0) {
 864         error_setg_errno(errp, errno, "Could not open temporary file '%s'",
 865                          filename);
 866         return NULL;
 867     }
 868     close(fd);
 869
 870     return g_steal_pointer(&filename);
 871 }
 872
 873 /*
 874  * Detect host devices. By convention, /dev/cdrom[N] is always
 875  * recognized as a host CDROM.
 876  */
 877 static BlockDriver *find_hdev_driver(const char *filename)
 878 {
 879     int score_max = 0, score;
 880     BlockDriver *drv = NULL, *d;
 881     GLOBAL_STATE_CODE();
 882
 883     QLIST_FOREACH(d, &bdrv_drivers, list) {
 884         if (d->bdrv_probe_device) {
 885             score = d->bdrv_probe_device(filename);
 886             if (score > score_max) {
 887                 score_max = score;
 888                 drv = d;
 889             }
 890         }
 891     }
 892
 893     return drv;
 894 }
 895
 896 static BlockDriver *bdrv_do_find_protocol(const char *protocol)
 897 {
 898     BlockDriver *drv1;
 899     GLOBAL_STATE_CODE();
 900
 901     QLIST_FOREACH(drv1, &bdrv_drivers, list) {
 902         if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
 903             return drv1;
 904         }
 905     }
 906
 907     return NULL;
 908 }
 909
 910 BlockDriver *bdrv_find_protocol(const char *filename,
 911                                 bool allow_protocol_prefix,
 912                                 Error **errp)
 913 {
 914     BlockDriver *drv1;
 915     char protocol[128];
 916     int len;
 917     const char *p;
 918     int i;
 919
 920     GLOBAL_STATE_CODE();
 921     /* TODO Drivers without bdrv_file_open must be specified explicitly */
 922
 923     /*
 924      * XXX(hch): we really should not let host device detection
 925      * override an explicit protocol specification, but moving this
 926      * later breaks access to device names with colons in them.
 927      * Thanks to the brain-dead persistent naming schemes on udev-
 928      * based Linux systems those actually are quite common.
 929      */
 930     drv1 = find_hdev_driver(filename);
 931     if (drv1) {
 932         return drv1;
 933     }
 934
 935     if (!path_has_protocol(filename) || !allow_protocol_prefix) {
 936         return &bdrv_file;
 937     }
 938
 939     p = strchr(filename, ':');
 940     assert(p != NULL);
 941     len = p - filename;
 942     if (len > sizeof(protocol) - 1)
 943         len = sizeof(protocol) - 1;
 944     memcpy(protocol, filename, len);
 945     protocol[len] = '\0';
 946
 947     drv1 = bdrv_do_find_protocol(protocol);
 948     if (drv1) {
 949         return drv1;
 950     }
 951
 952     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
 953         if (block_driver_modules[i].protocol_name &&
 954             !strcmp(block_driver_modules[i].protocol_name, protocol)) {
 955             int rv = block_module_load(block_driver_modules[i].library_name, errp);
 956             if (rv > 0) {
 957                 drv1 = bdrv_do_find_protocol(protocol);
 958             } else if (rv < 0) {
 959                 return NULL;
 960             }
 961             break;
 962         }
 963     }
 964
 965     if (!drv1) {
 966         error_setg(errp, "Unknown protocol '%s'", protocol);
 967     }
 968     return drv1;
 969 }
 970
 971 /*
 972  * Guess image format by probing its contents.
 973  * This is not a good idea when your image is raw (CVE-2008-2004), but
 974  * we do it anyway for backward compatibility.
 975  *
 976  * @buf         contains the image's first @buf_size bytes.
 977  * @buf_size    is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
 978  *              but can be smaller if the image file is smaller)
 979  * @filename    is its filename.
 980  *
 981  * For all block drivers, call the bdrv_probe() method to get its
 982  * probing score.
 983  * Return the first block driver with the highest probing score.
 984  */
 985 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
 986                             const char *filename)
 987 {
 988     int score_max = 0, score;
 989     BlockDriver *drv = NULL, *d;
 990     IO_CODE();
 991
 992     QLIST_FOREACH(d, &bdrv_drivers, list) {
 993         if (d->bdrv_probe) {
 994             score = d->bdrv_probe(buf, buf_size, filename);
 995             if (score > score_max) {
 996                 score_max = score;
 997                 drv = d;
 998             }
 999         }
1000     }
1001
1002     return drv;
1003 }
1004
1005 static int find_image_format(BlockBackend *file, const char *filename,
1006                              BlockDriver **pdrv, Error **errp)
1007 {
1008     BlockDriver *drv;
1009     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
1010     int ret = 0;
1011
1012     GLOBAL_STATE_CODE();
1013
1014     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
1015     if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
1016         *pdrv = &bdrv_raw;
1017         return ret;
1018     }
1019
1020     ret = blk_pread(file, 0, sizeof(buf), buf, 0);
1021     if (ret < 0) {
1022         error_setg_errno(errp, -ret, "Could not read image for determining its "
1023                          "format");
1024         *pdrv = NULL;
1025         return ret;
1026     }
1027
1028     drv = bdrv_probe_all(buf, sizeof(buf), filename);
1029     if (!drv) {
1030         error_setg(errp, "Could not determine image format: No compatible "
1031                    "driver found");
1032         *pdrv = NULL;
1033         return -ENOENT;
1034     }
1035
1036     *pdrv = drv;
1037     return 0;
1038 }
1039
1040 /**
1041  * Set the current 'total_sectors' value
1042  * Return 0 on success, -errno on error.
1043  */
1044 int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,
1045                                                int64_t hint)
1046 {
1047     BlockDriver *drv = bs->drv;
1048     IO_CODE();
1049     assert_bdrv_graph_readable();
1050
1051     if (!drv) {
1052         return -ENOMEDIUM;
1053     }
1054
1055     /* Do not attempt drv->bdrv_co_getlength() on scsi-generic devices */
1056     if (bdrv_is_sg(bs))
1057         return 0;
1058
1059     /* query actual device if possible, otherwise just trust the hint */
1060     if (drv->bdrv_co_getlength) {
1061         int64_t length = drv->bdrv_co_getlength(bs);
1062         if (length < 0) {
1063             return length;
1064         }
1065         hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
1066     }
1067
1068     bs->total_sectors = hint;
1069
1070     if (bs->total_sectors * BDRV_SECTOR_SIZE > BDRV_MAX_LENGTH) {
1071         return -EFBIG;
1072     }
1073
1074     return 0;
1075 }
1076
1077 /**
1078  * Combines a QDict of new block driver @options with any missing options taken
1079  * from @old_options, so that leaving out an option defaults to its old value.
1080  */
1081 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
1082                               QDict *old_options)
1083 {
1084     GLOBAL_STATE_CODE();
1085     if (bs->drv && bs->drv->bdrv_join_options) {
1086         bs->drv->bdrv_join_options(options, old_options);
1087     } else {
1088         qdict_join(options, old_options, false);
1089     }
1090 }
1091
1092 static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
1093                                                             int open_flags,
1094                                                             Error **errp)
1095 {
1096     Error *local_err = NULL;
1097     char *value = qemu_opt_get_del(opts, "detect-zeroes");
1098     BlockdevDetectZeroesOptions detect_zeroes =
1099         qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value,
1100                         BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err);
1101     GLOBAL_STATE_CODE();
1102     g_free(value);
1103     if (local_err) {
1104         error_propagate(errp, local_err);
1105         return detect_zeroes;
1106     }
1107
1108     if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1109         !(open_flags & BDRV_O_UNMAP))
1110     {
1111         error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1112                    "without setting discard operation to unmap");
1113     }
1114
1115     return detect_zeroes;
1116 }
1117
1118 /**
1119  * Set open flags for aio engine
1120  *
1121  * Return 0 on success, -1 if the engine specified is invalid
1122  */
1123 int bdrv_parse_aio(const char *mode, int *flags)
1124 {
1125     if (!strcmp(mode, "threads")) {
1126         /* do nothing, default */
1127     } else if (!strcmp(mode, "native")) {
1128         *flags |= BDRV_O_NATIVE_AIO;
1129 #ifdef CONFIG_LINUX_IO_URING
1130     } else if (!strcmp(mode, "io_uring")) {
1131         *flags |= BDRV_O_IO_URING;
1132 #endif
1133     } else {
1134         return -1;
1135     }
1136
1137     return 0;
1138 }
1139
1140 /**
1141  * Set open flags for a given discard mode
1142  *
1143  * Return 0 on success, -1 if the discard mode was invalid.
1144  */
1145 int bdrv_parse_discard_flags(const char *mode, int *flags)
1146 {
1147     *flags &= ~BDRV_O_UNMAP;
1148
1149     if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
1150         /* do nothing */
1151     } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
1152         *flags |= BDRV_O_UNMAP;
1153     } else {
1154         return -1;
1155     }
1156
1157     return 0;
1158 }
1159
1160 /**
1161  * Set open flags for a given cache mode
1162  *
1163  * Return 0 on success, -1 if the cache mode was invalid.
1164  */
1165 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
1166 {
1167     *flags &= ~BDRV_O_CACHE_MASK;
1168
1169     if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
1170         *writethrough = false;
1171         *flags |= BDRV_O_NOCACHE;
1172     } else if (!strcmp(mode, "directsync")) {
1173         *writethrough = true;
1174         *flags |= BDRV_O_NOCACHE;
1175     } else if (!strcmp(mode, "writeback")) {
1176         *writethrough = false;
1177     } else if (!strcmp(mode, "unsafe")) {
1178         *writethrough = false;
1179         *flags |= BDRV_O_NO_FLUSH;
1180     } else if (!strcmp(mode, "writethrough")) {
1181         *writethrough = true;
1182     } else {
1183         return -1;
1184     }
1185
1186     return 0;
1187 }
1188
1189 static char *bdrv_child_get_parent_desc(BdrvChild *c)
1190 {
1191     BlockDriverState *parent = c->opaque;
1192     return g_strdup_printf("node '%s'", bdrv_get_node_name(parent));
1193 }
1194
1195 static void bdrv_child_cb_drained_begin(BdrvChild *child)
1196 {
1197     BlockDriverState *bs = child->opaque;
1198     bdrv_do_drained_begin_quiesce(bs, NULL);
1199 }
1200
1201 static bool bdrv_child_cb_drained_poll(BdrvChild *child)
1202 {
1203     BlockDriverState *bs = child->opaque;
1204     return bdrv_drain_poll(bs, NULL, false);
1205 }
1206
1207 static void bdrv_child_cb_drained_end(BdrvChild *child)
1208 {
1209     BlockDriverState *bs = child->opaque;
1210     bdrv_drained_end(bs);
1211 }
1212
1213 static int bdrv_child_cb_inactivate(BdrvChild *child)
1214 {
1215     BlockDriverState *bs = child->opaque;
1216     GLOBAL_STATE_CODE();
1217     assert(bs->open_flags & BDRV_O_INACTIVE);
1218     return 0;
1219 }
1220
1221 static bool bdrv_child_cb_change_aio_ctx(BdrvChild *child, AioContext *ctx,
1222                                          GHashTable *visited, Transaction *tran,
1223                                          Error **errp)
1224 {
1225     BlockDriverState *bs = child->opaque;
1226     return bdrv_change_aio_context(bs, ctx, visited, tran, errp);
1227 }
1228
1229 /*
1230  * Returns the options and flags that a temporary snapshot should get, based on
1231  * the originally requested flags (the originally requested image will have
1232  * flags like a backing file)
1233  */
1234 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
1235                                        int parent_flags, QDict *parent_options)
1236 {
1237     GLOBAL_STATE_CODE();
1238     *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
1239
1240     /* For temporary files, unconditional cache=unsafe is fine */
1241     qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
1242     qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
1243
1244     /* Copy the read-only and discard options from the parent */
1245     qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
1246     qdict_copy_default(child_options, parent_options, BDRV_OPT_DISCARD);
1247
1248     /* aio=native doesn't work for cache.direct=off, so disable it for the
1249      * temporary snapshot */
1250     *child_flags &= ~BDRV_O_NATIVE_AIO;
1251 }
1252
1253 static void bdrv_backing_attach(BdrvChild *c)
1254 {
1255     BlockDriverState *parent = c->opaque;
1256     BlockDriverState *backing_hd = c->bs;
1257
1258     GLOBAL_STATE_CODE();
1259     assert(!parent->backing_blocker);
1260     error_setg(&parent->backing_blocker,
1261                "node is used as backing hd of '%s'",
1262                bdrv_get_device_or_node_name(parent));
1263
1264     bdrv_refresh_filename(backing_hd);
1265
1266     parent->open_flags &= ~BDRV_O_NO_BACKING;
1267
1268     bdrv_op_block_all(backing_hd, parent->backing_blocker);
1269     /* Otherwise we won't be able to commit or stream */
1270     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1271                     parent->backing_blocker);
1272     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
1273                     parent->backing_blocker);
1274     /*
1275      * We do backup in 3 ways:
1276      * 1. drive backup
1277      *    The target bs is new opened, and the source is top BDS
1278      * 2. blockdev backup
1279      *    Both the source and the target are top BDSes.
1280      * 3. internal backup(used for block replication)
1281      *    Both the source and the target are backing file
1282      *
1283      * In case 1 and 2, neither the source nor the target is the backing file.
1284      * In case 3, we will block the top BDS, so there is only one block job
1285      * for the top BDS and its backing chain.
1286      */
1287     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
1288                     parent->backing_blocker);
1289     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
1290                     parent->backing_blocker);
1291 }
1292
1293 static void bdrv_backing_detach(BdrvChild *c)
1294 {
1295     BlockDriverState *parent = c->opaque;
1296
1297     GLOBAL_STATE_CODE();
1298     assert(parent->backing_blocker);
1299     bdrv_op_unblock_all(c->bs, parent->backing_blocker);
1300     error_free(parent->backing_blocker);
1301     parent->backing_blocker = NULL;
1302 }
1303
1304 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
1305                                         const char *filename, Error **errp)
1306 {
1307     BlockDriverState *parent = c->opaque;
1308     bool read_only = bdrv_is_read_only(parent);
1309     int ret;
1310     GLOBAL_STATE_CODE();
1311
1312     if (read_only) {
1313         ret = bdrv_reopen_set_read_only(parent, false, errp);
1314         if (ret < 0) {
1315             return ret;
1316         }
1317     }
1318
1319     ret = bdrv_change_backing_file(parent, filename,
1320                                    base->drv ? base->drv->format_name : "",
1321                                    false);
1322     if (ret < 0) {
1323         error_setg_errno(errp, -ret, "Could not update backing file link");
1324     }
1325
1326     if (read_only) {
1327         bdrv_reopen_set_read_only(parent, true, NULL);
1328     }
1329
1330     return ret;
1331 }
1332
1333 /*
1334  * Returns the options and flags that a generic child of a BDS should
1335  * get, based on the given options and flags for the parent BDS.
1336  */
1337 static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format,
1338                                    int *child_flags, QDict *child_options,
1339                                    int parent_flags, QDict *parent_options)
1340 {
1341     int flags = parent_flags;
1342     GLOBAL_STATE_CODE();
1343
1344     /*
1345      * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL.
1346      * Generally, the question to answer is: Should this child be
1347      * format-probed by default?
1348      */
1349
1350     /*
1351      * Pure and non-filtered data children of non-format nodes should
1352      * be probed by default (even when the node itself has BDRV_O_PROTOCOL
1353      * set).  This only affects a very limited set of drivers (namely
1354      * quorum and blkverify when this comment was written).
1355      * Force-clear BDRV_O_PROTOCOL then.
1356      */
1357     if (!parent_is_format &&
1358         (role & BDRV_CHILD_DATA) &&
1359         !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED)))
1360     {
1361         flags &= ~BDRV_O_PROTOCOL;
1362     }
1363
1364     /*
1365      * All children of format nodes (except for COW children) and all
1366      * metadata children in general should never be format-probed.
1367      * Force-set BDRV_O_PROTOCOL then.
1368      */
1369     if ((parent_is_format && !(role & BDRV_CHILD_COW)) ||
1370         (role & BDRV_CHILD_METADATA))
1371     {
1372         flags |= BDRV_O_PROTOCOL;
1373     }
1374
1375     /*
1376      * If the cache mode isn't explicitly set, inherit direct and no-flush from
1377      * the parent.
1378      */
1379     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
1380     qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
1381     qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
1382
1383     if (role & BDRV_CHILD_COW) {
1384         /* backing files are opened read-only by default */
1385         qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
1386         qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off");
1387     } else {
1388         /* Inherit the read-only option from the parent if it's not set */
1389         qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
1390         qdict_copy_default(child_options, parent_options,
1391                            BDRV_OPT_AUTO_READ_ONLY);
1392     }
1393
1394     /*
1395      * bdrv_co_pdiscard() respects unmap policy for the parent, so we
1396      * can default to enable it on lower layers regardless of the
1397      * parent option.
1398      */
1399     qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
1400
1401     /* Clear flags that only apply to the top layer */
1402     flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
1403
1404     if (role & BDRV_CHILD_METADATA) {
1405         flags &= ~BDRV_O_NO_IO;
1406     }
1407     if (role & BDRV_CHILD_COW) {
1408         flags &= ~BDRV_O_TEMPORARY;
1409     }
1410
1411     *child_flags = flags;
1412 }
1413
1414 static void GRAPH_WRLOCK bdrv_child_cb_attach(BdrvChild *child)
1415 {
1416     BlockDriverState *bs = child->opaque;
1417
1418     assert_bdrv_graph_writable();
1419     QLIST_INSERT_HEAD(&bs->children, child, next);
1420     if (bs->drv->is_filter || (child->role & BDRV_CHILD_FILTERED)) {
1421         /*
1422          * Here we handle filters and block/raw-format.c when it behave like
1423          * filter. They generally have a single PRIMARY child, which is also the
1424          * FILTERED child, and that they may have multiple more children, which
1425          * are neither PRIMARY nor FILTERED. And never we have a COW child here.
1426          * So bs->file will be the PRIMARY child, unless the PRIMARY child goes
1427          * into bs->backing on exceptional cases; and bs->backing will be
1428          * nothing else.
1429          */
1430         assert(!(child->role & BDRV_CHILD_COW));
1431         if (child->role & BDRV_CHILD_PRIMARY) {
1432             assert(child->role & BDRV_CHILD_FILTERED);
1433             assert(!bs->backing);
1434             assert(!bs->file);
1435
1436             if (bs->drv->filtered_child_is_backing) {
1437                 bs->backing = child;
1438             } else {
1439                 bs->file = child;
1440             }
1441         } else {
1442             assert(!(child->role & BDRV_CHILD_FILTERED));
1443         }
1444     } else if (child->role & BDRV_CHILD_COW) {
1445         assert(bs->drv->supports_backing);
1446         assert(!(child->role & BDRV_CHILD_PRIMARY));
1447         assert(!bs->backing);
1448         bs->backing = child;
1449         bdrv_backing_attach(child);
1450     } else if (child->role & BDRV_CHILD_PRIMARY) {
1451         assert(!bs->file);
1452         bs->file = child;
1453     }
1454 }
1455
1456 static void GRAPH_WRLOCK bdrv_child_cb_detach(BdrvChild *child)
1457 {
1458     BlockDriverState *bs = child->opaque;
1459
1460     if (child->role & BDRV_CHILD_COW) {
1461         bdrv_backing_detach(child);
1462     }
1463
1464     assert_bdrv_graph_writable();
1465     QLIST_REMOVE(child, next);
1466     if (child == bs->backing) {
1467         assert(child != bs->file);
1468         bs->backing = NULL;
1469     } else if (child == bs->file) {
1470         bs->file = NULL;
1471     }
1472 }
1473
1474 static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base,
1475                                          const char *filename, Error **errp)
1476 {
1477     if (c->role & BDRV_CHILD_COW) {
1478         return bdrv_backing_update_filename(c, base, filename, errp);
1479     }
1480     return 0;
1481 }
1482
1483 AioContext *child_of_bds_get_parent_aio_context(BdrvChild *c)
1484 {
1485     BlockDriverState *bs = c->opaque;
1486     IO_CODE();
1487
1488     return bdrv_get_aio_context(bs);
1489 }
1490
1491 const BdrvChildClass child_of_bds = {
1492     .parent_is_bds   = true,
1493     .get_parent_desc = bdrv_child_get_parent_desc,
1494     .inherit_options = bdrv_inherited_options,
1495     .drained_begin   = bdrv_child_cb_drained_begin,
1496     .drained_poll    = bdrv_child_cb_drained_poll,
1497     .drained_end     = bdrv_child_cb_drained_end,
1498     .attach          = bdrv_child_cb_attach,
1499     .detach          = bdrv_child_cb_detach,
1500     .inactivate      = bdrv_child_cb_inactivate,
1501     .change_aio_ctx  = bdrv_child_cb_change_aio_ctx,
1502     .update_filename = bdrv_child_cb_update_filename,
1503     .get_parent_aio_context = child_of_bds_get_parent_aio_context,
1504 };
1505
1506 AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)
1507 {
1508     IO_CODE();
1509     return c->klass->get_parent_aio_context(c);
1510 }
1511
1512 static int bdrv_open_flags(BlockDriverState *bs, int flags)
1513 {
1514     int open_flags = flags;
1515     GLOBAL_STATE_CODE();
1516
1517     /*
1518      * Clear flags that are internal to the block layer before opening the
1519      * image.
1520      */
1521     open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
1522
1523     return open_flags;
1524 }
1525
1526 static void update_flags_from_options(int *flags, QemuOpts *opts)
1527 {
1528     GLOBAL_STATE_CODE();
1529
1530     *flags &= ~(BDRV_O_CACHE_MASK | BDRV_O_RDWR | BDRV_O_AUTO_RDONLY);
1531
1532     if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
1533         *flags |= BDRV_O_NO_FLUSH;
1534     }
1535
1536     if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) {
1537         *flags |= BDRV_O_NOCACHE;
1538     }
1539
1540     if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) {
1541         *flags |= BDRV_O_RDWR;
1542     }
1543
1544     if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
1545         *flags |= BDRV_O_AUTO_RDONLY;
1546     }
1547 }
1548
1549 static void update_options_from_flags(QDict *options, int flags)
1550 {
1551     GLOBAL_STATE_CODE();
1552     if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
1553         qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
1554     }
1555     if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
1556         qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1557                        flags & BDRV_O_NO_FLUSH);
1558     }
1559     if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
1560         qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
1561     }
1562     if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) {
1563         qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY,
1564                        flags & BDRV_O_AUTO_RDONLY);
1565     }
1566 }
1567
1568 static void bdrv_assign_node_name(BlockDriverState *bs,
1569                                   const char *node_name,
1570                                   Error **errp)
1571 {
1572     char *gen_node_name = NULL;
1573     GLOBAL_STATE_CODE();
1574
1575     if (!node_name) {
1576         node_name = gen_node_name = id_generate(ID_BLOCK);
1577     } else if (!id_wellformed(node_name)) {
1578         /*
1579          * Check for empty string or invalid characters, but not if it is
1580          * generated (generated names use characters not available to the user)
1581          */
1582         error_setg(errp, "Invalid node-name: '%s'", node_name);
1583         return;
1584     }
1585
1586     /* takes care of avoiding namespaces collisions */
1587     if (blk_by_name(node_name)) {
1588         error_setg(errp, "node-name=%s is conflicting with a device id",
1589                    node_name);
1590         goto out;
1591     }
1592
1593     /* takes care of avoiding duplicates node names */
1594     if (bdrv_find_node(node_name)) {
1595         error_setg(errp, "Duplicate nodes with node-name='%s'", node_name);
1596         goto out;
1597     }
1598
1599     /* Make sure that the node name isn't truncated */
1600     if (strlen(node_name) >= sizeof(bs->node_name)) {
1601         error_setg(errp, "Node name too long");
1602         goto out;
1603     }
1604
1605     /* copy node name into the bs and insert it into the graph list */
1606     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1607     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
1608 out:
1609     g_free(gen_node_name);
1610 }
1611
1612 /*
1613  * The caller must always hold @bs AioContext lock, because this function calls
1614  * bdrv_refresh_total_sectors() which polls when called from non-coroutine
1615  * context.
1616  */
1617 static int no_coroutine_fn GRAPH_UNLOCKED
1618 bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, const char *node_name,
1619                  QDict *options, int open_flags, Error **errp)
1620 {
1621     AioContext *ctx;
1622     Error *local_err = NULL;
1623     int i, ret;
1624     GLOBAL_STATE_CODE();
1625
1626     bdrv_assign_node_name(bs, node_name, &local_err);
1627     if (local_err) {
1628         error_propagate(errp, local_err);
1629         return -EINVAL;
1630     }
1631
1632     bs->drv = drv;
1633     bs->opaque = g_malloc0(drv->instance_size);
1634
1635     if (drv->bdrv_file_open) {
1636         assert(!drv->bdrv_needs_filename || bs->filename[0]);
1637         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1638     } else if (drv->bdrv_open) {
1639         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1640     } else {
1641         ret = 0;
1642     }
1643
1644     if (ret < 0) {
1645         if (local_err) {
1646             error_propagate(errp, local_err);
1647         } else if (bs->filename[0]) {
1648             error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1649         } else {
1650             error_setg_errno(errp, -ret, "Could not open image");
1651         }
1652         goto open_failed;
1653     }
1654
1655     assert(!(bs->supported_read_flags & ~BDRV_REQ_MASK));
1656     assert(!(bs->supported_write_flags & ~BDRV_REQ_MASK));
1657
1658     /*
1659      * Always allow the BDRV_REQ_REGISTERED_BUF optimization hint. This saves
1660      * drivers that pass read/write requests through to a child the trouble of
1661      * declaring support explicitly.
1662      *
1663      * Drivers must not propagate this flag accidentally when they initiate I/O
1664      * to a bounce buffer. That case should be rare though.
1665      */
1666     bs->supported_read_flags |= BDRV_REQ_REGISTERED_BUF;
1667     bs->supported_write_flags |= BDRV_REQ_REGISTERED_BUF;
1668
1669     /* Get the context after .bdrv_open, it can change the context */
1670     ctx = bdrv_get_aio_context(bs);
1671     aio_context_acquire(ctx);
1672
1673     ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
1674     if (ret < 0) {
1675         error_setg_errno(errp, -ret, "Could not refresh total sector count");
1676         aio_context_release(ctx);
1677         return ret;
1678     }
1679
1680     bdrv_graph_rdlock_main_loop();
1681     bdrv_refresh_limits(bs, NULL, &local_err);
1682     bdrv_graph_rdunlock_main_loop();
1683     aio_context_release(ctx);
1684
1685     if (local_err) {
1686         error_propagate(errp, local_err);
1687         return -EINVAL;
1688     }
1689
1690     assert(bdrv_opt_mem_align(bs) != 0);
1691     assert(bdrv_min_mem_align(bs) != 0);
1692     assert(is_power_of_2(bs->bl.request_alignment));
1693
1694     for (i = 0; i < bs->quiesce_counter; i++) {
1695         if (drv->bdrv_drain_begin) {
1696             drv->bdrv_drain_begin(bs);
1697         }
1698     }
1699
1700     return 0;
1701 open_failed:
1702     bs->drv = NULL;
1703     if (bs->file != NULL) {
1704         bdrv_unref_child(bs, bs->file);
1705         assert(!bs->file);
1706     }
1707     g_free(bs->opaque);
1708     bs->opaque = NULL;
1709     return ret;
1710 }
1711
1712 /*
1713  * Create and open a block node.
1714  *
1715  * @options is a QDict of options to pass to the block drivers, or NULL for an
1716  * empty set of options. The reference to the QDict belongs to the block layer
1717  * after the call (even on failure), so if the caller intends to reuse the
1718  * dictionary, it needs to use qobject_ref() before calling bdrv_open.
1719  */
1720 BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,
1721                                             const char *node_name,
1722                                             QDict *options, int flags,
1723                                             Error **errp)
1724 {
1725     BlockDriverState *bs;
1726     int ret;
1727
1728     GLOBAL_STATE_CODE();
1729
1730     bs = bdrv_new();
1731     bs->open_flags = flags;
1732     bs->options = options ?: qdict_new();
1733     bs->explicit_options = qdict_clone_shallow(bs->options);
1734     bs->opaque = NULL;
1735
1736     update_options_from_flags(bs->options, flags);
1737
1738     ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1739     if (ret < 0) {
1740         qobject_unref(bs->explicit_options);
1741         bs->explicit_options = NULL;
1742         qobject_unref(bs->options);
1743         bs->options = NULL;
1744         bdrv_unref(bs);
1745         return NULL;
1746     }
1747
1748     return bs;
1749 }
1750
1751 /* Create and open a block node. */
1752 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1753                                        int flags, Error **errp)
1754 {
1755     GLOBAL_STATE_CODE();
1756     return bdrv_new_open_driver_opts(drv, node_name, NULL, flags, errp);
1757 }
1758
1759 QemuOptsList bdrv_runtime_opts = {
1760     .name = "bdrv_common",
1761     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1762     .desc = {
1763         {
1764             .name = "node-name",
1765             .type = QEMU_OPT_STRING,
1766             .help = "Node name of the block device node",
1767         },
1768         {
1769             .name = "driver",
1770             .type = QEMU_OPT_STRING,
1771             .help = "Block driver to use for the node",
1772         },
1773         {
1774             .name = BDRV_OPT_CACHE_DIRECT,
1775             .type = QEMU_OPT_BOOL,
1776             .help = "Bypass software writeback cache on the host",
1777         },
1778         {
1779             .name = BDRV_OPT_CACHE_NO_FLUSH,
1780             .type = QEMU_OPT_BOOL,
1781             .help = "Ignore flush requests",
1782         },
1783         {
1784             .name = BDRV_OPT_READ_ONLY,
1785             .type = QEMU_OPT_BOOL,
1786             .help = "Node is opened in read-only mode",
1787         },
1788         {
1789             .name = BDRV_OPT_AUTO_READ_ONLY,
1790             .type = QEMU_OPT_BOOL,
1791             .help = "Node can become read-only if opening read-write fails",
1792         },
1793         {
1794             .name = "detect-zeroes",
1795             .type = QEMU_OPT_STRING,
1796             .help = "try to optimize zero writes (off, on, unmap)",
1797         },
1798         {
1799             .name = BDRV_OPT_DISCARD,
1800             .type = QEMU_OPT_STRING,
1801             .help = "discard operation (ignore/off, unmap/on)",
1802         },
1803         {
1804             .name = BDRV_OPT_FORCE_SHARE,
1805             .type = QEMU_OPT_BOOL,
1806             .help = "always accept other writers (default: off)",
1807         },
1808         { /* end of list */ }
1809     },
1810 };
1811
1812 QemuOptsList bdrv_create_opts_simple = {
1813     .name = "simple-create-opts",
1814     .head = QTAILQ_HEAD_INITIALIZER(bdrv_create_opts_simple.head),
1815     .desc = {
1816         {
1817             .name = BLOCK_OPT_SIZE,
1818             .type = QEMU_OPT_SIZE,
1819             .help = "Virtual disk size"
1820         },
1821         {
1822             .name = BLOCK_OPT_PREALLOC,
1823             .type = QEMU_OPT_STRING,
1824             .help = "Preallocation mode (allowed values: off)"
1825         },
1826         { /* end of list */ }
1827     }
1828 };
1829
1830 /*
1831  * Common part for opening disk images and files
1832  *
1833  * Removes all processed options from *options.
1834  */
1835 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
1836                             QDict *options, Error **errp)
1837 {
1838     int ret, open_flags;
1839     const char *filename;
1840     const char *driver_name = NULL;
1841     const char *node_name = NULL;
1842     const char *discard;
1843     QemuOpts *opts;
1844     BlockDriver *drv;
1845     Error *local_err = NULL;
1846     bool ro;
1847
1848     assert(bs->file == NULL);
1849     assert(options != NULL && bs->options != options);
1850     GLOBAL_STATE_CODE();
1851
1852     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1853     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
1854         ret = -EINVAL;
1855         goto fail_opts;
1856     }
1857
1858     update_flags_from_options(&bs->open_flags, opts);
1859
1860     driver_name = qemu_opt_get(opts, "driver");
1861     drv = bdrv_find_format(driver_name);
1862     assert(drv != NULL);
1863
1864     bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1865
1866     if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1867         error_setg(errp,
1868                    BDRV_OPT_FORCE_SHARE
1869                    "=on can only be used with read-only images");
1870         ret = -EINVAL;
1871         goto fail_opts;
1872     }
1873
1874     if (file != NULL) {
1875         bdrv_refresh_filename(blk_bs(file));
1876         filename = blk_bs(file)->filename;
1877     } else {
1878         /*
1879          * Caution: while qdict_get_try_str() is fine, getting
1880          * non-string types would require more care.  When @options
1881          * come from -blockdev or blockdev_add, its members are typed
1882          * according to the QAPI schema, but when they come from
1883          * -drive, they're all QString.
1884          */
1885         filename = qdict_get_try_str(options, "filename");
1886     }
1887
1888     if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
1889         error_setg(errp, "The '%s' block driver requires a file name",
1890                    drv->format_name);
1891         ret = -EINVAL;
1892         goto fail_opts;
1893     }
1894
1895     trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1896                            drv->format_name);
1897
1898     ro = bdrv_is_read_only(bs);
1899
1900     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, ro)) {
1901         if (!ro && bdrv_is_whitelisted(drv, true)) {
1902             ret = bdrv_apply_auto_read_only(bs, NULL, NULL);
1903         } else {
1904             ret = -ENOTSUP;
1905         }
1906         if (ret < 0) {
1907             error_setg(errp,
1908                        !ro && bdrv_is_whitelisted(drv, true)
1909                        ? "Driver '%s' can only be used for read-only devices"
1910                        : "Driver '%s' is not whitelisted",
1911                        drv->format_name);
1912             goto fail_opts;
1913         }
1914     }
1915
1916     /* bdrv_new() and bdrv_close() make it so */
1917     assert(qatomic_read(&bs->copy_on_read) == 0);
1918
1919     if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1920         if (!ro) {
1921             bdrv_enable_copy_on_read(bs);
1922         } else {
1923             error_setg(errp, "Can't use copy-on-read on read-only device");
1924             ret = -EINVAL;
1925             goto fail_opts;
1926         }
1927     }
1928
1929     discard = qemu_opt_get(opts, BDRV_OPT_DISCARD);
1930     if (discard != NULL) {
1931         if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1932             error_setg(errp, "Invalid discard option");
1933             ret = -EINVAL;
1934             goto fail_opts;
1935         }
1936     }
1937
1938     bs->detect_zeroes =
1939         bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err);
1940     if (local_err) {
1941         error_propagate(errp, local_err);
1942         ret = -EINVAL;
1943         goto fail_opts;
1944     }
1945
1946     if (filename != NULL) {
1947         pstrcpy(bs->filename, sizeof(bs->filename), filename);
1948     } else {
1949         bs->filename[0] = '\0';
1950     }
1951     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1952
1953     /* Open the image, either directly or using a protocol */
1954     open_flags = bdrv_open_flags(bs, bs->open_flags);
1955     node_name = qemu_opt_get(opts, "node-name");
1956
1957     assert(!drv->bdrv_file_open || file == NULL);
1958     ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
1959     if (ret < 0) {
1960         goto fail_opts;
1961     }
1962
1963     qemu_opts_del(opts);
1964     return 0;
1965
1966 fail_opts:
1967     qemu_opts_del(opts);
1968     return ret;
1969 }
1970
1971 static QDict *parse_json_filename(const char *filename, Error **errp)
1972 {
1973     QObject *options_obj;
1974     QDict *options;
1975     int ret;
1976     GLOBAL_STATE_CODE();
1977
1978     ret = strstart(filename, "json:", &filename);
1979     assert(ret);
1980
1981     options_obj = qobject_from_json(filename, errp);
1982     if (!options_obj) {
1983         error_prepend(errp, "Could not parse the JSON options: ");
1984         return NULL;
1985     }
1986
1987     options = qobject_to(QDict, options_obj);
1988     if (!options) {
1989         qobject_unref(options_obj);
1990         error_setg(errp, "Invalid JSON object given");
1991         return NULL;
1992     }
1993
1994     qdict_flatten(options);
1995
1996     return options;
1997 }
1998
1999 static void parse_json_protocol(QDict *options, const char **pfilename,
2000                                 Error **errp)
2001 {
2002     QDict *json_options;
2003     Error *local_err = NULL;
2004     GLOBAL_STATE_CODE();
2005
2006     /* Parse json: pseudo-protocol */
2007     if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
2008         return;
2009     }
2010
2011     json_options = parse_json_filename(*pfilename, &local_err);
2012     if (local_err) {
2013         error_propagate(errp, local_err);
2014         return;
2015     }
2016
2017     /* Options given in the filename have lower priority than options
2018      * specified directly */
2019     qdict_join(options, json_options, false);
2020     qobject_unref(json_options);
2021     *pfilename = NULL;
2022 }
2023
2024 /*
2025  * Fills in default options for opening images and converts the legacy
2026  * filename/flags pair to option QDict entries.
2027  * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
2028  * block driver has been specified explicitly.
2029  */
2030 static int bdrv_fill_options(QDict **options, const char *filename,
2031                              int *flags, Error **errp)
2032 {
2033     const char *drvname;
2034     bool protocol = *flags & BDRV_O_PROTOCOL;
2035     bool parse_filename = false;
2036     BlockDriver *drv = NULL;
2037     Error *local_err = NULL;
2038
2039     GLOBAL_STATE_CODE();
2040
2041     /*
2042      * Caution: while qdict_get_try_str() is fine, getting non-string
2043      * types would require more care.  When @options come from
2044      * -blockdev or blockdev_add, its members are typed according to
2045      * the QAPI schema, but when they come from -drive, they're all
2046      * QString.
2047      */
2048     drvname = qdict_get_try_str(*options, "driver");
2049     if (drvname) {
2050         drv = bdrv_find_format(drvname);
2051         if (!drv) {
2052             error_setg(errp, "Unknown driver '%s'", drvname);
2053             return -ENOENT;
2054         }
2055         /* If the user has explicitly specified the driver, this choice should
2056          * override the BDRV_O_PROTOCOL flag */
2057         protocol = drv->bdrv_file_open;
2058     }
2059
2060     if (protocol) {
2061         *flags |= BDRV_O_PROTOCOL;
2062     } else {
2063         *flags &= ~BDRV_O_PROTOCOL;
2064     }
2065
2066     /* Translate cache options from flags into options */
2067     update_options_from_flags(*options, *flags);
2068
2069     /* Fetch the file name from the options QDict if necessary */
2070     if (protocol && filename) {
2071         if (!qdict_haskey(*options, "filename")) {
2072             qdict_put_str(*options, "filename", filename);
2073             parse_filename = true;
2074         } else {
2075             error_setg(errp, "Can't specify 'file' and 'filename' options at "
2076                              "the same time");
2077             return -EINVAL;
2078         }
2079     }
2080
2081     /* Find the right block driver */
2082     /* See cautionary note on accessing @options above */
2083     filename = qdict_get_try_str(*options, "filename");
2084
2085     if (!drvname && protocol) {
2086         if (filename) {
2087             drv = bdrv_find_protocol(filename, parse_filename, errp);
2088             if (!drv) {
2089                 return -EINVAL;
2090             }
2091
2092             drvname = drv->format_name;
2093             qdict_put_str(*options, "driver", drvname);
2094         } else {
2095             error_setg(errp, "Must specify either driver or file");
2096             return -EINVAL;
2097         }
2098     }
2099
2100     assert(drv || !protocol);
2101
2102     /* Driver-specific filename parsing */
2103     if (drv && drv->bdrv_parse_filename && parse_filename) {
2104         drv->bdrv_parse_filename(filename, *options, &local_err);
2105         if (local_err) {
2106             error_propagate(errp, local_err);
2107             return -EINVAL;
2108         }
2109
2110         if (!drv->bdrv_needs_filename) {
2111             qdict_del(*options, "filename");
2112         }
2113     }
2114
2115     return 0;
2116 }
2117
2118 typedef struct BlockReopenQueueEntry {
2119      bool prepared;
2120      BDRVReopenState state;
2121      QTAILQ_ENTRY(BlockReopenQueueEntry) entry;
2122 } BlockReopenQueueEntry;
2123
2124 /*
2125  * Return the flags that @bs will have after the reopens in @q have
2126  * successfully completed. If @q is NULL (or @bs is not contained in @q),
2127  * return the current flags.
2128  */
2129 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
2130 {
2131     BlockReopenQueueEntry *entry;
2132
2133     if (q != NULL) {
2134         QTAILQ_FOREACH(entry, q, entry) {
2135             if (entry->state.bs == bs) {
2136                 return entry->state.flags;
2137             }
2138         }
2139     }
2140
2141     return bs->open_flags;
2142 }
2143
2144 /* Returns whether the image file can be written to after the reopen queue @q
2145  * has been successfully applied, or right now if @q is NULL. */
2146 static bool bdrv_is_writable_after_reopen(BlockDriverState *bs,
2147                                           BlockReopenQueue *q)
2148 {
2149     int flags = bdrv_reopen_get_flags(q, bs);
2150
2151     return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
2152 }
2153
2154 /*
2155  * Return whether the BDS can be written to.  This is not necessarily
2156  * the same as !bdrv_is_read_only(bs), as inactivated images may not
2157  * be written to but do not count as read-only images.
2158  */
2159 bool bdrv_is_writable(BlockDriverState *bs)
2160 {
2161     IO_CODE();
2162     return bdrv_is_writable_after_reopen(bs, NULL);
2163 }
2164
2165 static char *bdrv_child_user_desc(BdrvChild *c)
2166 {
2167     GLOBAL_STATE_CODE();
2168     return c->klass->get_parent_desc(c);
2169 }
2170
2171 /*
2172  * Check that @a allows everything that @b needs. @a and @b must reference same
2173  * child node.
2174  */
2175 static bool bdrv_a_allow_b(BdrvChild *a, BdrvChild *b, Error **errp)
2176 {
2177     const char *child_bs_name;
2178     g_autofree char *a_user = NULL;
2179     g_autofree char *b_user = NULL;
2180     g_autofree char *perms = NULL;
2181
2182     assert(a->bs);
2183     assert(a->bs == b->bs);
2184     GLOBAL_STATE_CODE();
2185
2186     if ((b->perm & a->shared_perm) == b->perm) {
2187         return true;
2188     }
2189
2190     child_bs_name = bdrv_get_node_name(b->bs);
2191     a_user = bdrv_child_user_desc(a);
2192     b_user = bdrv_child_user_desc(b);
2193     perms = bdrv_perm_names(b->perm & ~a->shared_perm);
2194
2195     error_setg(errp, "Permission conflict on node '%s': permissions '%s' are "
2196                "both required by %s (uses node '%s' as '%s' child) and "
2197                "unshared by %s (uses node '%s' as '%s' child).",
2198                child_bs_name, perms,
2199                b_user, child_bs_name, b->name,
2200                a_user, child_bs_name, a->name);
2201
2202     return false;
2203 }
2204
2205 static bool bdrv_parent_perms_conflict(BlockDriverState *bs, Error **errp)
2206 {
2207     BdrvChild *a, *b;
2208     GLOBAL_STATE_CODE();
2209
2210     /*
2211      * During the loop we'll look at each pair twice. That's correct because
2212      * bdrv_a_allow_b() is asymmetric and we should check each pair in both
2213      * directions.
2214      */
2215     QLIST_FOREACH(a, &bs->parents, next_parent) {
2216         QLIST_FOREACH(b, &bs->parents, next_parent) {
2217             if (a == b) {
2218                 continue;
2219             }
2220
2221             if (!bdrv_a_allow_b(a, b, errp)) {
2222                 return true;
2223             }
2224         }
2225     }
2226
2227     return false;
2228 }
2229
2230 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
2231                             BdrvChild *c, BdrvChildRole role,
2232                             BlockReopenQueue *reopen_queue,
2233                             uint64_t parent_perm, uint64_t parent_shared,
2234                             uint64_t *nperm, uint64_t *nshared)
2235 {
2236     assert(bs->drv && bs->drv->bdrv_child_perm);
2237     GLOBAL_STATE_CODE();
2238     bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
2239                              parent_perm, parent_shared,
2240                              nperm, nshared);
2241     /* TODO Take force_share from reopen_queue */
2242     if (child_bs && child_bs->force_share) {
2243         *nshared = BLK_PERM_ALL;
2244     }
2245 }
2246
2247 /*
2248  * Adds the whole subtree of @bs (including @bs itself) to the @list (except for
2249  * nodes that are already in the @list, of course) so that final list is
2250  * topologically sorted. Return the result (GSList @list object is updated, so
2251  * don't use old reference after function call).
2252  *
2253  * On function start @list must be already topologically sorted and for any node
2254  * in the @list the whole subtree of the node must be in the @list as well. The
2255  * simplest way to satisfy this criteria: use only result of
2256  * bdrv_topological_dfs() or NULL as @list parameter.
2257  */
2258 static GSList *bdrv_topological_dfs(GSList *list, GHashTable *found,
2259                                     BlockDriverState *bs)
2260 {
2261     BdrvChild *child;
2262     g_autoptr(GHashTable) local_found = NULL;
2263
2264     GLOBAL_STATE_CODE();
2265
2266     if (!found) {
2267         assert(!list);
2268         found = local_found = g_hash_table_new(NULL, NULL);
2269     }
2270
2271     if (g_hash_table_contains(found, bs)) {
2272         return list;
2273     }
2274     g_hash_table_add(found, bs);
2275
2276     QLIST_FOREACH(child, &bs->children, next) {
2277         list = bdrv_topological_dfs(list, found, child->bs);
2278     }
2279
2280     return g_slist_prepend(list, bs);
2281 }
2282
2283 typedef struct BdrvChildSetPermState {
2284     BdrvChild *child;
2285     uint64_t old_perm;
2286     uint64_t old_shared_perm;
2287 } BdrvChildSetPermState;
2288
2289 static void bdrv_child_set_perm_abort(void *opaque)
2290 {
2291     BdrvChildSetPermState *s = opaque;
2292
2293     GLOBAL_STATE_CODE();
2294
2295     s->child->perm = s->old_perm;
2296     s->child->shared_perm = s->old_shared_perm;
2297 }
2298
2299 static TransactionActionDrv bdrv_child_set_pem_drv = {
2300     .abort = bdrv_child_set_perm_abort,
2301     .clean = g_free,
2302 };
2303
2304 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm,
2305                                 uint64_t shared, Transaction *tran)
2306 {
2307     BdrvChildSetPermState *s = g_new(BdrvChildSetPermState, 1);
2308     GLOBAL_STATE_CODE();
2309
2310     *s = (BdrvChildSetPermState) {
2311         .child = c,
2312         .old_perm = c->perm,
2313         .old_shared_perm = c->shared_perm,
2314     };
2315
2316     c->perm = perm;
2317     c->shared_perm = shared;
2318
2319     tran_add(tran, &bdrv_child_set_pem_drv, s);
2320 }
2321
2322 static void bdrv_drv_set_perm_commit(void *opaque)
2323 {
2324     BlockDriverState *bs = opaque;
2325     uint64_t cumulative_perms, cumulative_shared_perms;
2326     GLOBAL_STATE_CODE();
2327
2328     if (bs->drv->bdrv_set_perm) {
2329         bdrv_get_cumulative_perm(bs, &cumulative_perms,
2330                                  &cumulative_shared_perms);
2331         bs->drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
2332     }
2333 }
2334
2335 static void bdrv_drv_set_perm_abort(void *opaque)
2336 {
2337     BlockDriverState *bs = opaque;
2338     GLOBAL_STATE_CODE();
2339
2340     if (bs->drv->bdrv_abort_perm_update) {
2341         bs->drv->bdrv_abort_perm_update(bs);
2342     }
2343 }
2344
2345 TransactionActionDrv bdrv_drv_set_perm_drv = {
2346     .abort = bdrv_drv_set_perm_abort,
2347     .commit = bdrv_drv_set_perm_commit,
2348 };
2349
2350 static int bdrv_drv_set_perm(BlockDriverState *bs, uint64_t perm,
2351                              uint64_t shared_perm, Transaction *tran,
2352                              Error **errp)
2353 {
2354     GLOBAL_STATE_CODE();
2355     if (!bs->drv) {
2356         return 0;
2357     }
2358
2359     if (bs->drv->bdrv_check_perm) {
2360         int ret = bs->drv->bdrv_check_perm(bs, perm, shared_perm, errp);
2361         if (ret < 0) {
2362             return ret;
2363         }
2364     }
2365
2366     if (tran) {
2367         tran_add(tran, &bdrv_drv_set_perm_drv, bs);
2368     }
2369
2370     return 0;
2371 }
2372
2373 typedef struct BdrvReplaceChildState {
2374     BdrvChild *child;
2375     BlockDriverState *old_bs;
2376 } BdrvReplaceChildState;
2377
2378 static void GRAPH_WRLOCK bdrv_replace_child_commit(void *opaque)
2379 {
2380     BdrvReplaceChildState *s = opaque;
2381     GLOBAL_STATE_CODE();
2382
2383     bdrv_schedule_unref(s->old_bs);
2384 }
2385
2386 static void GRAPH_WRLOCK bdrv_replace_child_abort(void *opaque)
2387 {
2388     BdrvReplaceChildState *s = opaque;
2389     BlockDriverState *new_bs = s->child->bs;
2390
2391     GLOBAL_STATE_CODE();
2392     assert_bdrv_graph_writable();
2393
2394     /* old_bs reference is transparently moved from @s to @s->child */
2395     if (!s->child->bs) {
2396         /*
2397          * The parents were undrained when removing old_bs from the child. New
2398          * requests can't have been made, though, because the child was empty.
2399          *
2400          * TODO Make bdrv_replace_child_noperm() transactionable to avoid
2401          * undraining the parent in the first place. Once this is done, having
2402          * new_bs drained when calling bdrv_replace_child_tran() is not a
2403          * requirement any more.
2404          */
2405         bdrv_parent_drained_begin_single(s->child);
2406         assert(!bdrv_parent_drained_poll_single(s->child));
2407     }
2408     assert(s->child->quiesced_parent);
2409     bdrv_replace_child_noperm(s->child, s->old_bs);
2410
2411     bdrv_unref(new_bs);
2412 }
2413
2414 static TransactionActionDrv bdrv_replace_child_drv = {
2415     .commit = bdrv_replace_child_commit,
2416     .abort = bdrv_replace_child_abort,
2417     .clean = g_free,
2418 };
2419
2420 /*
2421  * bdrv_replace_child_tran
2422  *
2423  * Note: real unref of old_bs is done only on commit.
2424  *
2425  * Both @child->bs and @new_bs (if non-NULL) must be drained. @new_bs must be
2426  * kept drained until the transaction is completed.
2427  *
2428  * After calling this function, the transaction @tran may only be completed
2429  * while holding a writer lock for the graph.
2430  *
2431  * The function doesn't update permissions, caller is responsible for this.
2432  */
2433 static void GRAPH_WRLOCK
2434 bdrv_replace_child_tran(BdrvChild *child, BlockDriverState *new_bs,
2435                         Transaction *tran)
2436 {
2437     BdrvReplaceChildState *s = g_new(BdrvReplaceChildState, 1);
2438
2439     assert(child->quiesced_parent);
2440     assert(!new_bs || new_bs->quiesce_counter);
2441
2442     *s = (BdrvReplaceChildState) {
2443         .child = child,
2444         .old_bs = child->bs,
2445     };
2446     tran_add(tran, &bdrv_replace_child_drv, s);
2447
2448     if (new_bs) {
2449         bdrv_ref(new_bs);
2450     }
2451
2452     bdrv_replace_child_noperm(child, new_bs);
2453     /* old_bs reference is transparently moved from @child to @s */
2454 }
2455
2456 /*
2457  * Refresh permissions in @bs subtree. The function is intended to be called
2458  * after some graph modification that was done without permission update.
2459  */
2460 static int bdrv_node_refresh_perm(BlockDriverState *bs, BlockReopenQueue *q,
2461                                   Transaction *tran, Error **errp)
2462 {
2463     BlockDriver *drv = bs->drv;
2464     BdrvChild *c;
2465     int ret;
2466     uint64_t cumulative_perms, cumulative_shared_perms;
2467     GLOBAL_STATE_CODE();
2468
2469     bdrv_get_cumulative_perm(bs, &cumulative_perms, &cumulative_shared_perms);
2470
2471     /* Write permissions never work with read-only images */
2472     if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
2473         !bdrv_is_writable_after_reopen(bs, q))
2474     {
2475         if (!bdrv_is_writable_after_reopen(bs, NULL)) {
2476             error_setg(errp, "Block node is read-only");
2477         } else {
2478             error_setg(errp, "Read-only block node '%s' cannot support "
2479                        "read-write users", bdrv_get_node_name(bs));
2480         }
2481
2482         return -EPERM;
2483     }
2484
2485     /*
2486      * Unaligned requests will automatically be aligned to bl.request_alignment
2487      * and without RESIZE we can't extend requests to write to space beyond the
2488      * end of the image, so it's required that the image size is aligned.
2489      */
2490     if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
2491         !(cumulative_perms & BLK_PERM_RESIZE))
2492     {
2493         if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) {
2494             error_setg(errp, "Cannot get 'write' permission without 'resize': "
2495                              "Image size is not a multiple of request "
2496                              "alignment");
2497             return -EPERM;
2498         }
2499     }
2500
2501     /* Check this node */
2502     if (!drv) {
2503         return 0;
2504     }
2505
2506     ret = bdrv_drv_set_perm(bs, cumulative_perms, cumulative_shared_perms, tran,
2507                             errp);
2508     if (ret < 0) {
2509         return ret;
2510     }
2511
2512     /* Drivers that never have children can omit .bdrv_child_perm() */
2513     if (!drv->bdrv_child_perm) {
2514         assert(QLIST_EMPTY(&bs->children));
2515         return 0;
2516     }
2517
2518     /* Check all children */
2519     QLIST_FOREACH(c, &bs->children, next) {
2520         uint64_t cur_perm, cur_shared;
2521
2522         bdrv_child_perm(bs, c->bs, c, c->role, q,
2523                         cumulative_perms, cumulative_shared_perms,
2524                         &cur_perm, &cur_shared);
2525         bdrv_child_set_perm(c, cur_perm, cur_shared, tran);
2526     }
2527
2528     return 0;
2529 }
2530
2531 /*
2532  * @list is a product of bdrv_topological_dfs() (may be called several times) -
2533  * a topologically sorted subgraph.
2534  */
2535 static int bdrv_do_refresh_perms(GSList *list, BlockReopenQueue *q,
2536                                  Transaction *tran, Error **errp)
2537 {
2538     int ret;
2539     BlockDriverState *bs;
2540     GLOBAL_STATE_CODE();
2541
2542     for ( ; list; list = list->next) {
2543         bs = list->data;
2544
2545         if (bdrv_parent_perms_conflict(bs, errp)) {
2546             return -EINVAL;
2547         }
2548
2549         ret = bdrv_node_refresh_perm(bs, q, tran, errp);
2550         if (ret < 0) {
2551             return ret;
2552         }
2553     }
2554
2555     return 0;
2556 }
2557
2558 /*
2559  * @list is any list of nodes. List is completed by all subtrees and
2560  * topologically sorted. It's not a problem if some node occurs in the @list
2561  * several times.
2562  */
2563 static int bdrv_list_refresh_perms(GSList *list, BlockReopenQueue *q,
2564                                    Transaction *tran, Error **errp)
2565 {
2566     g_autoptr(GHashTable) found = g_hash_table_new(NULL, NULL);
2567     g_autoptr(GSList) refresh_list = NULL;
2568
2569     for ( ; list; list = list->next) {
2570         refresh_list = bdrv_topological_dfs(refresh_list, found, list->data);
2571     }
2572
2573     return bdrv_do_refresh_perms(refresh_list, q, tran, errp);
2574 }
2575
2576 void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
2577                               uint64_t *shared_perm)
2578 {
2579     BdrvChild *c;
2580     uint64_t cumulative_perms = 0;
2581     uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2582
2583     GLOBAL_STATE_CODE();
2584
2585     QLIST_FOREACH(c, &bs->parents, next_parent) {
2586         cumulative_perms |= c->perm;
2587         cumulative_shared_perms &= c->shared_perm;
2588     }
2589
2590     *perm = cumulative_perms;
2591     *shared_perm = cumulative_shared_perms;
2592 }
2593
2594 char *bdrv_perm_names(uint64_t perm)
2595 {
2596     struct perm_name {
2597         uint64_t perm;
2598         const char *name;
2599     } permissions[] = {
2600         { BLK_PERM_CONSISTENT_READ, "consistent read" },
2601         { BLK_PERM_WRITE,           "write" },
2602         { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
2603         { BLK_PERM_RESIZE,          "resize" },
2604         { 0, NULL }
2605     };
2606
2607     GString *result = g_string_sized_new(30);
2608     struct perm_name *p;
2609
2610     for (p = permissions; p->name; p++) {
2611         if (perm & p->perm) {
2612             if (result->len > 0) {
2613                 g_string_append(result, ", ");
2614             }
2615             g_string_append(result, p->name);
2616         }
2617     }
2618
2619     return g_string_free(result, FALSE);
2620 }
2621
2622
2623 /* @tran is allowed to be NULL. In this case no rollback is possible */
2624 static int bdrv_refresh_perms(BlockDriverState *bs, Transaction *tran,
2625                               Error **errp)
2626 {
2627     int ret;
2628     Transaction *local_tran = NULL;
2629     g_autoptr(GSList) list = bdrv_topological_dfs(NULL, NULL, bs);
2630     GLOBAL_STATE_CODE();
2631
2632     if (!tran) {
2633         tran = local_tran = tran_new();
2634     }
2635
2636     ret = bdrv_do_refresh_perms(list, NULL, tran, errp);
2637
2638     if (local_tran) {
2639         tran_finalize(local_tran, ret);
2640     }
2641
2642     return ret;
2643 }
2644
2645 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
2646                             Error **errp)
2647 {
2648     Error *local_err = NULL;
2649     Transaction *tran = tran_new();
2650     int ret;
2651
2652     GLOBAL_STATE_CODE();
2653
2654     bdrv_child_set_perm(c, perm, shared, tran);
2655
2656     ret = bdrv_refresh_perms(c->bs, tran, &local_err);
2657
2658     tran_finalize(tran, ret);
2659
2660     if (ret < 0) {
2661         if ((perm & ~c->perm) || (c->shared_perm & ~shared)) {
2662             /* tighten permissions */
2663             error_propagate(errp, local_err);
2664         } else {
2665             /*
2666              * Our caller may intend to only loosen restrictions and
2667              * does not expect this function to fail.  Errors are not
2668              * fatal in such a case, so we can just hide them from our
2669              * caller.
2670              */
2671             error_free(local_err);
2672             ret = 0;
2673         }
2674     }
2675
2676     return ret;
2677 }
2678
2679 int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp)
2680 {
2681     uint64_t parent_perms, parent_shared;
2682     uint64_t perms, shared;
2683
2684     GLOBAL_STATE_CODE();
2685
2686     bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared);
2687     bdrv_child_perm(bs, c->bs, c, c->role, NULL,
2688                     parent_perms, parent_shared, &perms, &shared);
2689
2690     return bdrv_child_try_set_perm(c, perms, shared, errp);
2691 }
2692
2693 /*
2694  * Default implementation for .bdrv_child_perm() for block filters:
2695  * Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED, and RESIZE to the
2696  * filtered child.
2697  */
2698 static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
2699                                       BdrvChildRole role,
2700                                       BlockReopenQueue *reopen_queue,
2701                                       uint64_t perm, uint64_t shared,
2702                                       uint64_t *nperm, uint64_t *nshared)
2703 {
2704     GLOBAL_STATE_CODE();
2705     *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
2706     *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
2707 }
2708
2709 static void bdrv_default_perms_for_cow(BlockDriverState *bs, BdrvChild *c,
2710                                        BdrvChildRole role,
2711                                        BlockReopenQueue *reopen_queue,
2712                                        uint64_t perm, uint64_t shared,
2713                                        uint64_t *nperm, uint64_t *nshared)
2714 {
2715     assert(role & BDRV_CHILD_COW);
2716     GLOBAL_STATE_CODE();
2717
2718     /*
2719      * We want consistent read from backing files if the parent needs it.
2720      * No other operations are performed on backing files.
2721      */
2722     perm &= BLK_PERM_CONSISTENT_READ;
2723
2724     /*
2725      * If the parent can deal with changing data, we're okay with a
2726      * writable and resizable backing file.
2727      * TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too?
2728      */
2729     if (shared & BLK_PERM_WRITE) {
2730         shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2731     } else {
2732         shared = 0;
2733     }
2734
2735     shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED;
2736
2737     if (bs->open_flags & BDRV_O_INACTIVE) {
2738         shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2739     }
2740
2741     *nperm = perm;
2742     *nshared = shared;
2743 }
2744
2745 static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c,
2746                                            BdrvChildRole role,
2747                                            BlockReopenQueue *reopen_queue,
2748                                            uint64_t perm, uint64_t shared,
2749                                            uint64_t *nperm, uint64_t *nshared)
2750 {
2751     int flags;
2752
2753     GLOBAL_STATE_CODE();
2754     assert(role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA));
2755
2756     flags = bdrv_reopen_get_flags(reopen_queue, bs);
2757
2758     /*
2759      * Apart from the modifications below, the same permissions are
2760      * forwarded and left alone as for filters
2761      */
2762     bdrv_filter_default_perms(bs, c, role, reopen_queue,
2763                               perm, shared, &perm, &shared);
2764
2765     if (role & BDRV_CHILD_METADATA) {
2766         /* Format drivers may touch metadata even if the guest doesn't write */
2767         if (bdrv_is_writable_after_reopen(bs, reopen_queue)) {
2768             perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2769         }
2770
2771         /*
2772          * bs->file always needs to be consistent because of the
2773          * metadata. We can never allow other users to resize or write
2774          * to it.
2775          */
2776         if (!(flags & BDRV_O_NO_IO)) {
2777             perm |= BLK_PERM_CONSISTENT_READ;
2778         }
2779         shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
2780     }
2781
2782     if (role & BDRV_CHILD_DATA) {
2783         /*
2784          * Technically, everything in this block is a subset of the
2785          * BDRV_CHILD_METADATA path taken above, and so this could
2786          * be an "else if" branch.  However, that is not obvious, and
2787          * this function is not performance critical, therefore we let
2788          * this be an independent "if".
2789          */
2790
2791         /*
2792          * We cannot allow other users to resize the file because the
2793          * format driver might have some assumptions about the size
2794          * (e.g. because it is stored in metadata, or because the file
2795          * is split into fixed-size data files).
2796          */
2797         shared &= ~BLK_PERM_RESIZE;
2798
2799         /*
2800          * WRITE_UNCHANGED often cannot be performed as such on the
2801          * data file.  For example, the qcow2 driver may still need to
2802          * write copied clusters on copy-on-read.
2803          */
2804         if (perm & BLK_PERM_WRITE_UNCHANGED) {
2805             perm |= BLK_PERM_WRITE;
2806         }
2807
2808         /*
2809          * If the data file is written to, the format driver may
2810          * expect to be able to resize it by writing beyond the EOF.
2811          */
2812         if (perm & BLK_PERM_WRITE) {
2813             perm |= BLK_PERM_RESIZE;
2814         }
2815     }
2816
2817     if (bs->open_flags & BDRV_O_INACTIVE) {
2818         shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
2819     }
2820
2821     *nperm = perm;
2822     *nshared = shared;
2823 }
2824
2825 void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c,
2826                         BdrvChildRole role, BlockReopenQueue *reopen_queue,
2827                         uint64_t perm, uint64_t shared,
2828                         uint64_t *nperm, uint64_t *nshared)
2829 {
2830     GLOBAL_STATE_CODE();
2831     if (role & BDRV_CHILD_FILTERED) {
2832         assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
2833                          BDRV_CHILD_COW)));
2834         bdrv_filter_default_perms(bs, c, role, reopen_queue,
2835                                   perm, shared, nperm, nshared);
2836     } else if (role & BDRV_CHILD_COW) {
2837         assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA)));
2838         bdrv_default_perms_for_cow(bs, c, role, reopen_queue,
2839                                    perm, shared, nperm, nshared);
2840     } else if (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA)) {
2841         bdrv_default_perms_for_storage(bs, c, role, reopen_queue,
2842                                        perm, shared, nperm, nshared);
2843     } else {
2844         g_assert_not_reached();
2845     }
2846 }
2847
2848 uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
2849 {
2850     static const uint64_t permissions[] = {
2851         [BLOCK_PERMISSION_CONSISTENT_READ]  = BLK_PERM_CONSISTENT_READ,
2852         [BLOCK_PERMISSION_WRITE]            = BLK_PERM_WRITE,
2853         [BLOCK_PERMISSION_WRITE_UNCHANGED]  = BLK_PERM_WRITE_UNCHANGED,
2854         [BLOCK_PERMISSION_RESIZE]           = BLK_PERM_RESIZE,
2855     };
2856
2857     QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX);
2858     QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1);
2859
2860     assert(qapi_perm < BLOCK_PERMISSION__MAX);
2861
2862     return permissions[qapi_perm];
2863 }
2864
2865 /*
2866  * Replaces the node that a BdrvChild points to without updating permissions.
2867  *
2868  * If @new_bs is non-NULL, the parent of @child must already be drained through
2869  * @child and the caller must hold the AioContext lock for @new_bs.
2870  */
2871 static void GRAPH_WRLOCK
2872 bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs)
2873 {
2874     BlockDriverState *old_bs = child->bs;
2875     int new_bs_quiesce_counter;
2876
2877     assert(!child->frozen);
2878
2879     /*
2880      * If we want to change the BdrvChild to point to a drained node as its new
2881      * child->bs, we need to make sure that its new parent is drained, too. In
2882      * other words, either child->quiesce_parent must already be true or we must
2883      * be able to set it and keep the parent's quiesce_counter consistent with
2884      * that, but without polling or starting new requests (this function
2885      * guarantees that it doesn't poll, and starting new requests would be
2886      * against the invariants of drain sections).
2887      *
2888      * To keep things simple, we pick the first option (child->quiesce_parent
2889      * must already be true). We also generalise the rule a bit to make it
2890      * easier to verify in callers and more likely to be covered in test cases:
2891      * The parent must be quiesced through this child even if new_bs isn't
2892      * currently drained.
2893      *
2894      * The only exception is for callers that always pass new_bs == NULL. In
2895      * this case, we obviously never need to consider the case of a drained
2896      * new_bs, so we can keep the callers simpler by allowing them not to drain
2897      * the parent.
2898      */
2899     assert(!new_bs || child->quiesced_parent);
2900     assert(old_bs != new_bs);
2901     GLOBAL_STATE_CODE();
2902
2903     if (old_bs && new_bs) {
2904         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
2905     }
2906
2907     if (old_bs) {
2908         if (child->klass->detach) {
2909             child->klass->detach(child);
2910         }
2911         QLIST_REMOVE(child, next_parent);
2912     }
2913
2914     child->bs = new_bs;
2915
2916     if (new_bs) {
2917         QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
2918         if (child->klass->attach) {
2919             child->klass->attach(child);
2920         }
2921     }
2922
2923     /*
2924      * If the parent was drained through this BdrvChild previously, but new_bs
2925      * is not drained, allow requests to come in only after the new node has
2926      * been attached.
2927      */
2928     new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
2929     if (!new_bs_quiesce_counter && child->quiesced_parent) {
2930         bdrv_parent_drained_end_single(child);
2931     }
2932 }
2933
2934 /**
2935  * Free the given @child.
2936  *
2937  * The child must be empty (i.e. `child->bs == NULL`) and it must be
2938  * unused (i.e. not in a children list).
2939  */
2940 static void bdrv_child_free(BdrvChild *child)
2941 {
2942     assert(!child->bs);
2943     GLOBAL_STATE_CODE();
2944     assert(!child->next.le_prev); /* not in children list */
2945
2946     g_free(child->name);
2947     g_free(child);
2948 }
2949
2950 typedef struct BdrvAttachChildCommonState {
2951     BdrvChild *child;
2952     AioContext *old_parent_ctx;
2953     AioContext *old_child_ctx;
2954 } BdrvAttachChildCommonState;
2955
2956 static void GRAPH_WRLOCK bdrv_attach_child_common_abort(void *opaque)
2957 {
2958     BdrvAttachChildCommonState *s = opaque;
2959     BlockDriverState *bs = s->child->bs;
2960
2961     GLOBAL_STATE_CODE();
2962     assert_bdrv_graph_writable();
2963
2964     bdrv_replace_child_noperm(s->child, NULL);
2965
2966     if (bdrv_get_aio_context(bs) != s->old_child_ctx) {
2967         bdrv_try_change_aio_context(bs, s->old_child_ctx, NULL, &error_abort);
2968     }
2969
2970     if (bdrv_child_get_parent_aio_context(s->child) != s->old_parent_ctx) {
2971         Transaction *tran;
2972         GHashTable *visited;
2973         bool ret;
2974
2975         tran = tran_new();
2976
2977         /* No need to visit `child`, because it has been detached already */
2978         visited = g_hash_table_new(NULL, NULL);
2979         ret = s->child->klass->change_aio_ctx(s->child, s->old_parent_ctx,
2980                                               visited, tran, &error_abort);
2981         g_hash_table_destroy(visited);
2982
2983         /* transaction is supposed to always succeed */
2984         assert(ret == true);
2985         tran_commit(tran);
2986     }
2987
2988     bdrv_schedule_unref(bs);
2989     bdrv_child_free(s->child);
2990 }
2991
2992 static TransactionActionDrv bdrv_attach_child_common_drv = {
2993     .abort = bdrv_attach_child_common_abort,
2994     .clean = g_free,
2995 };
2996
2997 /*
2998  * Common part of attaching bdrv child to bs or to blk or to job
2999  *
3000  * Function doesn't update permissions, caller is responsible for this.
3001  *
3002  * After calling this function, the transaction @tran may only be completed
3003  * while holding a writer lock for the graph.
3004  *
3005  * Returns new created child.
3006  *
3007  * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
3008  * @child_bs can move to a different AioContext in this function. Callers must
3009  * make sure that their AioContext locking is still correct after this.
3010  */
3011 static BdrvChild * GRAPH_WRLOCK
3012 bdrv_attach_child_common(BlockDriverState *child_bs,
3013                          const char *child_name,
3014                          const BdrvChildClass *child_class,
3015                          BdrvChildRole child_role,
3016                          uint64_t perm, uint64_t shared_perm,
3017                          void *opaque,
3018                          Transaction *tran, Error **errp)
3019 {
3020     BdrvChild *new_child;
3021     AioContext *parent_ctx, *new_child_ctx;
3022     AioContext *child_ctx = bdrv_get_aio_context(child_bs);
3023
3024     assert(child_class->get_parent_desc);
3025     GLOBAL_STATE_CODE();
3026
3027     new_child = g_new(BdrvChild, 1);
3028     *new_child = (BdrvChild) {
3029         .bs             = NULL,
3030         .name           = g_strdup(child_name),
3031         .klass          = child_class,
3032         .role           = child_role,
3033         .perm           = perm,
3034         .shared_perm    = shared_perm,
3035         .opaque         = opaque,
3036     };
3037
3038     /*
3039      * If the AioContexts don't match, first try to move the subtree of
3040      * child_bs into the AioContext of the new parent. If this doesn't work,
3041      * try moving the parent into the AioContext of child_bs instead.
3042      */
3043     parent_ctx = bdrv_child_get_parent_aio_context(new_child);
3044     if (child_ctx != parent_ctx) {
3045         Error *local_err = NULL;
3046         int ret = bdrv_try_change_aio_context(child_bs, parent_ctx, NULL,
3047                                               &local_err);
3048
3049         if (ret < 0 && child_class->change_aio_ctx) {
3050             Transaction *tran = tran_new();
3051             GHashTable *visited = g_hash_table_new(NULL, NULL);
3052             bool ret_child;
3053
3054             g_hash_table_add(visited, new_child);
3055             ret_child = child_class->change_aio_ctx(new_child, child_ctx,
3056                                                     visited, tran, NULL);
3057             if (ret_child == true) {
3058                 error_free(local_err);
3059                 ret = 0;
3060             }
3061             tran_finalize(tran, ret_child == true ? 0 : -1);
3062             g_hash_table_destroy(visited);
3063         }
3064
3065         if (ret < 0) {
3066             error_propagate(errp, local_err);
3067             bdrv_child_free(new_child);
3068             return NULL;
3069         }
3070     }
3071
3072     new_child_ctx = bdrv_get_aio_context(child_bs);
3073     if (new_child_ctx != child_ctx) {
3074         aio_context_release(child_ctx);
3075         aio_context_acquire(new_child_ctx);
3076     }
3077
3078     bdrv_ref(child_bs);
3079     /*
3080      * Let every new BdrvChild start with a drained parent. Inserting the child
3081      * in the graph with bdrv_replace_child_noperm() will undrain it if
3082      * @child_bs is not drained.
3083      *
3084      * The child was only just created and is not yet visible in global state
3085      * until bdrv_replace_child_noperm() inserts it into the graph, so nobody
3086      * could have sent requests and polling is not necessary.
3087      *
3088      * Note that this means that the parent isn't fully drained yet, we only
3089      * stop new requests from coming in. This is fine, we don't care about the
3090      * old requests here, they are not for this child. If another place enters a
3091      * drain section for the same parent, but wants it to be fully quiesced, it
3092      * will not run most of the the code in .drained_begin() again (which is not
3093      * a problem, we already did this), but it will still poll until the parent
3094      * is fully quiesced, so it will not be negatively affected either.
3095      */
3096     bdrv_parent_drained_begin_single(new_child);
3097     bdrv_replace_child_noperm(new_child, child_bs);
3098
3099     BdrvAttachChildCommonState *s = g_new(BdrvAttachChildCommonState, 1);
3100     *s = (BdrvAttachChildCommonState) {
3101         .child = new_child,
3102         .old_parent_ctx = parent_ctx,
3103         .old_child_ctx = child_ctx,
3104     };
3105     tran_add(tran, &bdrv_attach_child_common_drv, s);
3106
3107     if (new_child_ctx != child_ctx) {
3108         aio_context_release(new_child_ctx);
3109         aio_context_acquire(child_ctx);
3110     }
3111
3112     return new_child;
3113 }
3114
3115 /*
3116  * Function doesn't update permissions, caller is responsible for this.
3117  *
3118  * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
3119  * @child_bs can move to a different AioContext in this function. Callers must
3120  * make sure that their AioContext locking is still correct after this.
3121  *
3122  * After calling this function, the transaction @tran may only be completed
3123  * while holding a writer lock for the graph.
3124  */
3125 static BdrvChild * GRAPH_WRLOCK
3126 bdrv_attach_child_noperm(BlockDriverState *parent_bs,
3127                          BlockDriverState *child_bs,
3128                          const char *child_name,
3129                          const BdrvChildClass *child_class,
3130                          BdrvChildRole child_role,
3131                          Transaction *tran,
3132                          Error **errp)
3133 {
3134     uint64_t perm, shared_perm;
3135
3136     assert(parent_bs->drv);
3137     GLOBAL_STATE_CODE();
3138
3139     if (bdrv_recurse_has_child(child_bs, parent_bs)) {
3140         error_setg(errp, "Making '%s' a %s child of '%s' would create a cycle",
3141                    child_bs->node_name, child_name, parent_bs->node_name);
3142         return NULL;
3143     }
3144
3145     bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
3146     bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
3147                     perm, shared_perm, &perm, &shared_perm);
3148
3149     return bdrv_attach_child_common(child_bs, child_name, child_class,
3150                                     child_role, perm, shared_perm, parent_bs,
3151                                     tran, errp);
3152 }
3153
3154 /*
3155  * This function steals the reference to child_bs from the caller.
3156  * That reference is later dropped by bdrv_root_unref_child().
3157  *
3158  * On failure NULL is returned, errp is set and the reference to
3159  * child_bs is also dropped.
3160  *
3161  * The caller must hold the AioContext lock @child_bs, but not that of @ctx
3162  * (unless @child_bs is already in @ctx).
3163  */
3164 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
3165                                   const char *child_name,
3166                                   const BdrvChildClass *child_class,
3167                                   BdrvChildRole child_role,
3168                                   uint64_t perm, uint64_t shared_perm,
3169                                   void *opaque, Error **errp)
3170 {
3171     int ret;
3172     BdrvChild *child;
3173     Transaction *tran = tran_new();
3174
3175     GLOBAL_STATE_CODE();
3176
3177     bdrv_graph_wrlock(child_bs);
3178
3179     child = bdrv_attach_child_common(child_bs, child_name, child_class,
3180                                    child_role, perm, shared_perm, opaque,
3181                                    tran, errp);
3182     if (!child) {
3183         ret = -EINVAL;
3184         goto out;
3185     }
3186
3187     ret = bdrv_refresh_perms(child_bs, tran, errp);
3188
3189 out:
3190     tran_finalize(tran, ret);
3191     bdrv_graph_wrunlock();
3192
3193     bdrv_unref(child_bs);
3194
3195     return ret < 0 ? NULL : child;
3196 }
3197
3198 /*
3199  * This function transfers the reference to child_bs from the caller
3200  * to parent_bs. That reference is later dropped by parent_bs on
3201  * bdrv_close() or if someone calls bdrv_unref_child().
3202  *
3203  * On failure NULL is returned, errp is set and the reference to
3204  * child_bs is also dropped.
3205  *
3206  * If @parent_bs and @child_bs are in different AioContexts, the caller must
3207  * hold the AioContext lock for @child_bs, but not for @parent_bs.
3208  */
3209 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
3210                              BlockDriverState *child_bs,
3211                              const char *child_name,
3212                              const BdrvChildClass *child_class,
3213                              BdrvChildRole child_role,
3214                              Error **errp)
3215 {
3216     int ret;
3217     BdrvChild *child;
3218     Transaction *tran = tran_new();
3219
3220     GLOBAL_STATE_CODE();
3221
3222     child = bdrv_attach_child_noperm(parent_bs, child_bs, child_name,
3223                                      child_class, child_role, tran, errp);
3224     if (!child) {
3225         ret = -EINVAL;
3226         goto out;
3227     }
3228
3229     ret = bdrv_refresh_perms(parent_bs, tran, errp);
3230     if (ret < 0) {
3231         goto out;
3232     }
3233
3234 out:
3235     tran_finalize(tran, ret);
3236
3237     bdrv_schedule_unref(child_bs);
3238
3239     return ret < 0 ? NULL : child;
3240 }
3241
3242 /* Callers must ensure that child->frozen is false. */
3243 void bdrv_root_unref_child(BdrvChild *child)
3244 {
3245     BlockDriverState *child_bs = child->bs;
3246
3247     GLOBAL_STATE_CODE();
3248     bdrv_graph_wrlock(NULL);
3249     bdrv_replace_child_noperm(child, NULL);
3250     bdrv_graph_wrunlock();
3251     bdrv_child_free(child);
3252
3253     if (child_bs) {
3254         /*
3255          * Update permissions for old node. We're just taking a parent away, so
3256          * we're loosening restrictions. Errors of permission update are not
3257          * fatal in this case, ignore them.
3258          */
3259         bdrv_refresh_perms(child_bs, NULL, NULL);
3260
3261         /*
3262          * When the parent requiring a non-default AioContext is removed, the
3263          * node moves back to the main AioContext
3264          */
3265         bdrv_try_change_aio_context(child_bs, qemu_get_aio_context(), NULL,
3266                                     NULL);
3267     }
3268
3269     bdrv_unref(child_bs);
3270 }
3271
3272 typedef struct BdrvSetInheritsFrom {
3273     BlockDriverState *bs;
3274     BlockDriverState *old_inherits_from;
3275 } BdrvSetInheritsFrom;
3276
3277 static void bdrv_set_inherits_from_abort(void *opaque)
3278 {
3279     BdrvSetInheritsFrom *s = opaque;
3280
3281     s->bs->inherits_from = s->old_inherits_from;
3282 }
3283
3284 static TransactionActionDrv bdrv_set_inherits_from_drv = {
3285     .abort = bdrv_set_inherits_from_abort,
3286     .clean = g_free,
3287 };
3288
3289 /* @tran is allowed to be NULL. In this case no rollback is possible */
3290 static void bdrv_set_inherits_from(BlockDriverState *bs,
3291                                    BlockDriverState *new_inherits_from,
3292                                    Transaction *tran)
3293 {
3294     if (tran) {
3295         BdrvSetInheritsFrom *s = g_new(BdrvSetInheritsFrom, 1);
3296
3297         *s = (BdrvSetInheritsFrom) {
3298             .bs = bs,
3299             .old_inherits_from = bs->inherits_from,
3300         };
3301
3302         tran_add(tran, &bdrv_set_inherits_from_drv, s);
3303     }
3304
3305     bs->inherits_from = new_inherits_from;
3306 }
3307
3308 /**
3309  * Clear all inherits_from pointers from children and grandchildren of
3310  * @root that point to @root, where necessary.
3311  * @tran is allowed to be NULL. In this case no rollback is possible
3312  */
3313 static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child,
3314                                      Transaction *tran)
3315 {
3316     BdrvChild *c;
3317
3318     if (child->bs->inherits_from == root) {
3319         /*
3320          * Remove inherits_from only when the last reference between root and
3321          * child->bs goes away.
3322          */
3323         QLIST_FOREACH(c, &root->children, next) {
3324             if (c != child && c->bs == child->bs) {
3325                 break;
3326             }
3327         }
3328         if (c == NULL) {
3329             bdrv_set_inherits_from(child->bs, NULL, tran);
3330         }
3331     }
3332
3333     QLIST_FOREACH(c, &child->bs->children, next) {
3334         bdrv_unset_inherits_from(root, c, tran);
3335     }
3336 }
3337
3338 /* Callers must ensure that child->frozen is false. */
3339 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
3340 {
3341     GLOBAL_STATE_CODE();
3342     if (child == NULL) {
3343         return;
3344     }
3345
3346     bdrv_unset_inherits_from(parent, child, NULL);
3347     bdrv_root_unref_child(child);
3348 }
3349
3350
3351 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
3352 {
3353     BdrvChild *c;
3354     GLOBAL_STATE_CODE();
3355     QLIST_FOREACH(c, &bs->parents, next_parent) {
3356         if (c->klass->change_media) {
3357             c->klass->change_media(c, load);
3358         }
3359     }
3360 }
3361
3362 /* Return true if you can reach parent going through child->inherits_from
3363  * recursively. If parent or child are NULL, return false */
3364 static bool bdrv_inherits_from_recursive(BlockDriverState *child,
3365                                          BlockDriverState *parent)
3366 {
3367     while (child && child != parent) {
3368         child = child->inherits_from;
3369     }
3370
3371     return child != NULL;
3372 }
3373
3374 /*
3375  * Return the BdrvChildRole for @bs's backing child.  bs->backing is
3376  * mostly used for COW backing children (role = COW), but also for
3377  * filtered children (role = FILTERED | PRIMARY).
3378  */
3379 static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
3380 {
3381     if (bs->drv && bs->drv->is_filter) {
3382         return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
3383     } else {
3384         return BDRV_CHILD_COW;
3385     }
3386 }
3387
3388 /*
3389  * Sets the bs->backing or bs->file link of a BDS. A new reference is created;
3390  * callers which don't need their own reference any more must call bdrv_unref().
3391  *
3392  * If the respective child is already present (i.e. we're detaching a node),
3393  * that child node must be drained.
3394  *
3395  * Function doesn't update permissions, caller is responsible for this.
3396  *
3397  * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
3398  * @child_bs can move to a different AioContext in this function. Callers must
3399  * make sure that their AioContext locking is still correct after this.
3400  *
3401  * After calling this function, the transaction @tran may only be completed
3402  * while holding a writer lock for the graph.
3403  */
3404 static int GRAPH_WRLOCK
3405 bdrv_set_file_or_backing_noperm(BlockDriverState *parent_bs,
3406                                 BlockDriverState *child_bs,
3407                                 bool is_backing,
3408                                 Transaction *tran, Error **errp)
3409 {
3410     bool update_inherits_from =
3411         bdrv_inherits_from_recursive(child_bs, parent_bs);
3412     BdrvChild *child = is_backing ? parent_bs->backing : parent_bs->file;
3413     BdrvChildRole role;
3414
3415     GLOBAL_STATE_CODE();
3416
3417     if (!parent_bs->drv) {
3418         /*
3419          * Node without drv is an object without a class :/. TODO: finally fix
3420          * qcow2 driver to never clear bs->drv and implement format corruption
3421          * handling in other way.
3422          */
3423         error_setg(errp, "Node corrupted");
3424         return -EINVAL;
3425     }
3426
3427     if (child && child->frozen) {
3428         error_setg(errp, "Cannot change frozen '%s' link from '%s' to '%s'",
3429                    child->name, parent_bs->node_name, child->bs->node_name);
3430         return -EPERM;
3431     }
3432
3433     if (is_backing && !parent_bs->drv->is_filter &&
3434         !parent_bs->drv->supports_backing)
3435     {
3436         error_setg(errp, "Driver '%s' of node '%s' does not support backing "
3437                    "files", parent_bs->drv->format_name, parent_bs->node_name);
3438         return -EINVAL;
3439     }
3440
3441     if (parent_bs->drv->is_filter) {
3442         role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
3443     } else if (is_backing) {
3444         role = BDRV_CHILD_COW;
3445     } else {
3446         /*
3447          * We only can use same role as it is in existing child. We don't have
3448          * infrastructure to determine role of file child in generic way
3449          */
3450         if (!child) {
3451             error_setg(errp, "Cannot set file child to format node without "
3452                        "file child");
3453             return -EINVAL;
3454         }
3455         role = child->role;
3456     }
3457
3458     if (child) {
3459         assert(child->bs->quiesce_counter);
3460         bdrv_unset_inherits_from(parent_bs, child, tran);
3461         bdrv_remove_child(child, tran);
3462     }
3463
3464     if (!child_bs) {
3465         goto out;
3466     }
3467
3468     child = bdrv_attach_child_noperm(parent_bs, child_bs,
3469                                      is_backing ? "backing" : "file",
3470                                      &child_of_bds, role,
3471                                      tran, errp);
3472     if (!child) {
3473         return -EINVAL;
3474     }
3475
3476
3477     /*
3478      * If inherits_from pointed recursively to bs then let's update it to
3479      * point directly to bs (else it will become NULL).
3480      */
3481     if (update_inherits_from) {
3482         bdrv_set_inherits_from(child_bs, parent_bs, tran);
3483     }
3484
3485 out:
3486     bdrv_refresh_limits(parent_bs, tran, NULL);
3487
3488     return 0;
3489 }
3490
3491 /*
3492  * The caller must hold the AioContext lock for @backing_hd. Both @bs and
3493  * @backing_hd can move to a different AioContext in this function. Callers must
3494  * make sure that their AioContext locking is still correct after this.
3495  *
3496  * If a backing child is already present (i.e. we're detaching a node), that
3497  * child node must be drained.
3498  *
3499  * After calling this function, the transaction @tran may only be completed
3500  * while holding a writer lock for the graph.
3501  */
3502 static int GRAPH_WRLOCK
3503 bdrv_set_backing_noperm(BlockDriverState *bs,
3504                         BlockDriverState *backing_hd,
3505                         Transaction *tran, Error **errp)
3506 {
3507     GLOBAL_STATE_CODE();
3508     return bdrv_set_file_or_backing_noperm(bs, backing_hd, true, tran, errp);
3509 }
3510
3511 int bdrv_set_backing_hd_drained(BlockDriverState *bs,
3512                                 BlockDriverState *backing_hd,
3513                                 Error **errp)
3514 {
3515     int ret;
3516     Transaction *tran = tran_new();
3517
3518     GLOBAL_STATE_CODE();
3519     assert(bs->quiesce_counter > 0);
3520     if (bs->backing) {
3521         assert(bs->backing->bs->quiesce_counter > 0);
3522     }
3523     bdrv_graph_wrlock(backing_hd);
3524
3525     ret = bdrv_set_backing_noperm(bs, backing_hd, tran, errp);
3526     if (ret < 0) {
3527         goto out;
3528     }
3529
3530     ret = bdrv_refresh_perms(bs, tran, errp);
3531 out:
3532     tran_finalize(tran, ret);
3533     bdrv_graph_wrunlock();
3534     return ret;
3535 }
3536
3537 int bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
3538                         Error **errp)
3539 {
3540     BlockDriverState *drain_bs = bs->backing ? bs->backing->bs : bs;
3541     int ret;
3542     GLOBAL_STATE_CODE();
3543
3544     bdrv_ref(drain_bs);
3545     bdrv_drained_begin(drain_bs);
3546     ret = bdrv_set_backing_hd_drained(bs, backing_hd, errp);
3547     bdrv_drained_end(drain_bs);
3548     bdrv_unref(drain_bs);
3549
3550     return ret;
3551 }
3552
3553 /*
3554  * Opens the backing file for a BlockDriverState if not yet open
3555  *
3556  * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
3557  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3558  * itself, all options starting with "${bdref_key}." are considered part of the
3559  * BlockdevRef.
3560  *
3561  * The caller must hold the main AioContext lock.
3562  *
3563  * TODO Can this be unified with bdrv_open_image()?
3564  */
3565 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
3566                            const char *bdref_key, Error **errp)
3567 {
3568     char *backing_filename = NULL;
3569     char *bdref_key_dot;
3570     const char *reference = NULL;
3571     int ret = 0;
3572     bool implicit_backing = false;
3573     BlockDriverState *backing_hd;
3574     AioContext *backing_hd_ctx;
3575     QDict *options;
3576     QDict *tmp_parent_options = NULL;
3577     Error *local_err = NULL;
3578
3579     GLOBAL_STATE_CODE();
3580
3581     if (bs->backing != NULL) {
3582         goto free_exit;
3583     }
3584
3585     /* NULL means an empty set of options */
3586     if (parent_options == NULL) {
3587         tmp_parent_options = qdict_new();
3588         parent_options = tmp_parent_options;
3589     }
3590
3591     bs->open_flags &= ~BDRV_O_NO_BACKING;
3592
3593     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3594     qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
3595     g_free(bdref_key_dot);
3596
3597     /*
3598      * Caution: while qdict_get_try_str() is fine, getting non-string
3599      * types would require more care.  When @parent_options come from
3600      * -blockdev or blockdev_add, its members are typed according to
3601      * the QAPI schema, but when they come from -drive, they're all
3602      * QString.
3603      */
3604     reference = qdict_get_try_str(parent_options, bdref_key);
3605     if (reference || qdict_haskey(options, "file.filename")) {
3606         /* keep backing_filename NULL */
3607     } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
3608         qobject_unref(options);
3609         goto free_exit;
3610     } else {
3611         if (qdict_size(options) == 0) {
3612             /* If the user specifies options that do not modify the
3613              * backing file's behavior, we might still consider it the
3614              * implicit backing file.  But it's easier this way, and
3615              * just specifying some of the backing BDS's options is
3616              * only possible with -drive anyway (otherwise the QAPI
3617              * schema forces the user to specify everything). */
3618             implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file);
3619         }
3620
3621         backing_filename = bdrv_get_full_backing_filename(bs, &local_err);
3622         if (local_err) {
3623             ret = -EINVAL;
3624             error_propagate(errp, local_err);
3625             qobject_unref(options);
3626             goto free_exit;
3627         }
3628     }
3629
3630     if (!bs->drv || !bs->drv->supports_backing) {
3631         ret = -EINVAL;
3632         error_setg(errp, "Driver doesn't support backing files");
3633         qobject_unref(options);
3634         goto free_exit;
3635     }
3636
3637     if (!reference &&
3638         bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
3639         qdict_put_str(options, "driver", bs->backing_format);
3640     }
3641
3642     backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs,
3643                                    &child_of_bds, bdrv_backing_role(bs), errp);
3644     if (!backing_hd) {
3645         bs->open_flags |= BDRV_O_NO_BACKING;
3646         error_prepend(errp, "Could not open backing file: ");
3647         ret = -EINVAL;
3648         goto free_exit;
3649     }
3650
3651     if (implicit_backing) {
3652         bdrv_refresh_filename(backing_hd);
3653         pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3654                 backing_hd->filename);
3655     }
3656
3657     /* Hook up the backing file link; drop our reference, bs owns the
3658      * backing_hd reference now */
3659     backing_hd_ctx = bdrv_get_aio_context(backing_hd);
3660     aio_context_acquire(backing_hd_ctx);
3661     ret = bdrv_set_backing_hd(bs, backing_hd, errp);
3662     bdrv_unref(backing_hd);
3663     aio_context_release(backing_hd_ctx);
3664
3665     if (ret < 0) {
3666         goto free_exit;
3667     }
3668
3669     qdict_del(parent_options, bdref_key);
3670
3671 free_exit:
3672     g_free(backing_filename);
3673     qobject_unref(tmp_parent_options);
3674     return ret;
3675 }
3676
3677 static BlockDriverState *
3678 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
3679                    BlockDriverState *parent, const BdrvChildClass *child_class,
3680                    BdrvChildRole child_role, bool allow_none, Error **errp)
3681 {
3682     BlockDriverState *bs = NULL;
3683     QDict *image_options;
3684     char *bdref_key_dot;
3685     const char *reference;
3686
3687     assert(child_class != NULL);
3688
3689     bdref_key_dot = g_strdup_printf("%s.", bdref_key);
3690     qdict_extract_subqdict(options, &image_options, bdref_key_dot);
3691     g_free(bdref_key_dot);
3692
3693     /*
3694      * Caution: while qdict_get_try_str() is fine, getting non-string
3695      * types would require more care.  When @options come from
3696      * -blockdev or blockdev_add, its members are typed according to
3697      * the QAPI schema, but when they come from -drive, they're all
3698      * QString.
3699      */
3700     reference = qdict_get_try_str(options, bdref_key);
3701     if (!filename && !reference && !qdict_size(image_options)) {
3702         if (!allow_none) {
3703             error_setg(errp, "A block device must be specified for \"%s\"",
3704                        bdref_key);
3705         }
3706         qobject_unref(image_options);
3707         goto done;
3708     }
3709
3710     bs = bdrv_open_inherit(filename, reference, image_options, 0,
3711                            parent, child_class, child_role, errp);
3712     if (!bs) {
3713         goto done;
3714     }
3715
3716 done:
3717     qdict_del(options, bdref_key);
3718     return bs;
3719 }
3720
3721 /*
3722  * Opens a disk image whose options are given as BlockdevRef in another block
3723  * device's options.
3724  *
3725  * If allow_none is true, no image will be opened if filename is false and no
3726  * BlockdevRef is given. NULL will be returned, but errp remains unset.
3727  *
3728  * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
3729  * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
3730  * itself, all options starting with "${bdref_key}." are considered part of the
3731  * BlockdevRef.
3732  *
3733  * The BlockdevRef will be removed from the options QDict.
3734  *
3735  * The caller must hold the lock of the main AioContext and no other AioContext.
3736  * @parent can move to a different AioContext in this function. Callers must
3737  * make sure that their AioContext locking is still correct after this.
3738  */
3739 BdrvChild *bdrv_open_child(const char *filename,
3740                            QDict *options, const char *bdref_key,
3741                            BlockDriverState *parent,
3742                            const BdrvChildClass *child_class,
3743                            BdrvChildRole child_role,
3744                            bool allow_none, Error **errp)
3745 {
3746     BlockDriverState *bs;
3747     BdrvChild *child;
3748     AioContext *ctx;
3749
3750     GLOBAL_STATE_CODE();
3751
3752     bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class,
3753                             child_role, allow_none, errp);
3754     if (bs == NULL) {
3755         return NULL;
3756     }
3757
3758     bdrv_graph_wrlock(NULL);
3759     ctx = bdrv_get_aio_context(bs);
3760     aio_context_acquire(ctx);
3761     child = bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
3762                               errp);
3763     aio_context_release(ctx);
3764     bdrv_graph_wrunlock();
3765
3766     return child;
3767 }
3768
3769 /*
3770  * Wrapper on bdrv_open_child() for most popular case: open primary child of bs.
3771  *
3772  * The caller must hold the lock of the main AioContext and no other AioContext.
3773  * @parent can move to a different AioContext in this function. Callers must
3774  * make sure that their AioContext locking is still correct after this.
3775  */
3776 int bdrv_open_file_child(const char *filename,
3777                          QDict *options, const char *bdref_key,
3778                          BlockDriverState *parent, Error **errp)
3779 {
3780     BdrvChildRole role;
3781
3782     /* commit_top and mirror_top don't use this function */
3783     assert(!parent->drv->filtered_child_is_backing);
3784     role = parent->drv->is_filter ?
3785         (BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY) : BDRV_CHILD_IMAGE;
3786
3787     if (!bdrv_open_child(filename, options, bdref_key, parent,
3788                          &child_of_bds, role, false, errp))
3789     {
3790         return -EINVAL;
3791     }
3792
3793     return 0;
3794 }
3795
3796 /*
3797  * TODO Future callers may need to specify parent/child_class in order for
3798  * option inheritance to work. Existing callers use it for the root node.
3799  */
3800 BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
3801 {
3802     BlockDriverState *bs = NULL;
3803     QObject *obj = NULL;
3804     QDict *qdict = NULL;
3805     const char *reference = NULL;
3806     Visitor *v = NULL;
3807
3808     GLOBAL_STATE_CODE();
3809
3810     if (ref->type == QTYPE_QSTRING) {
3811         reference = ref->u.reference;
3812     } else {
3813         BlockdevOptions *options = &ref->u.definition;
3814         assert(ref->type == QTYPE_QDICT);
3815
3816         v = qobject_output_visitor_new(&obj);
3817         visit_type_BlockdevOptions(v, NULL, &options, &error_abort);
3818         visit_complete(v, &obj);
3819
3820         qdict = qobject_to(QDict, obj);
3821         qdict_flatten(qdict);
3822
3823         /* bdrv_open_inherit() defaults to the values in bdrv_flags (for
3824          * compatibility with other callers) rather than what we want as the
3825          * real defaults. Apply the defaults here instead. */
3826         qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
3827         qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
3828         qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off");
3829         qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off");
3830
3831     }
3832
3833     bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, 0, errp);
3834     obj = NULL;
3835     qobject_unref(obj);
3836     visit_free(v);
3837     return bs;
3838 }
3839
3840 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
3841                                                    int flags,
3842                                                    QDict *snapshot_options,
3843                                                    Error **errp)
3844 {
3845     g_autofree char *tmp_filename = NULL;
3846     int64_t total_size;
3847     QemuOpts *opts = NULL;
3848     BlockDriverState *bs_snapshot = NULL;
3849     AioContext *ctx = bdrv_get_aio_context(bs);
3850     int ret;
3851
3852     GLOBAL_STATE_CODE();
3853
3854     /* if snapshot, we create a temporary backing file and open it
3855        instead of opening 'filename' directly */
3856
3857     /* Get the required size from the image */
3858     aio_context_acquire(ctx);
3859     total_size = bdrv_getlength(bs);
3860     aio_context_release(ctx);
3861
3862     if (total_size < 0) {
3863         error_setg_errno(errp, -total_size, "Could not get image size");
3864         goto out;
3865     }
3866
3867     /* Create the temporary image */
3868     tmp_filename = create_tmp_file(errp);
3869     if (!tmp_filename) {
3870         goto out;
3871     }
3872
3873     opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
3874                             &error_abort);
3875     qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
3876     ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
3877     qemu_opts_del(opts);
3878     if (ret < 0) {
3879         error_prepend(errp, "Could not create temporary overlay '%s': ",
3880                       tmp_filename);
3881         goto out;
3882     }
3883
3884     /* Prepare options QDict for the temporary file */
3885     qdict_put_str(snapshot_options, "file.driver", "file");
3886     qdict_put_str(snapshot_options, "file.filename", tmp_filename);
3887     qdict_put_str(snapshot_options, "driver", "qcow2");
3888
3889     bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
3890     snapshot_options = NULL;
3891     if (!bs_snapshot) {
3892         goto out;
3893     }
3894
3895     aio_context_acquire(ctx);
3896     ret = bdrv_append(bs_snapshot, bs, errp);
3897     aio_context_release(ctx);
3898
3899     if (ret < 0) {
3900         bs_snapshot = NULL;
3901         goto out;
3902     }
3903
3904 out:
3905     qobject_unref(snapshot_options);
3906     return bs_snapshot;
3907 }
3908
3909 /*
3910  * Opens a disk image (raw, qcow2, vmdk, ...)
3911  *
3912  * options is a QDict of options to pass to the block drivers, or NULL for an
3913  * empty set of options. The reference to the QDict belongs to the block layer
3914  * after the call (even on failure), so if the caller intends to reuse the
3915  * dictionary, it needs to use qobject_ref() before calling bdrv_open.
3916  *
3917  * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
3918  * If it is not NULL, the referenced BDS will be reused.
3919  *
3920  * The reference parameter may be used to specify an existing block device which
3921  * should be opened. If specified, neither options nor a filename may be given,
3922  * nor can an existing BDS be reused (that is, *pbs has to be NULL).
3923  *
3924  * The caller must always hold the main AioContext lock.
3925  */
3926 static BlockDriverState * no_coroutine_fn
3927 bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
3928                   int flags, BlockDriverState *parent,
3929                   const BdrvChildClass *child_class, BdrvChildRole child_role,
3930                   Error **errp)
3931 {
3932     int ret;
3933     BlockBackend *file = NULL;
3934     BlockDriverState *bs;
3935     BlockDriver *drv = NULL;
3936     BdrvChild *child;
3937     const char *drvname;
3938     const char *backing;
3939     Error *local_err = NULL;
3940     QDict *snapshot_options = NULL;
3941     int snapshot_flags = 0;
3942     AioContext *ctx = qemu_get_aio_context();
3943
3944     assert(!child_class || !flags);
3945     assert(!child_class == !parent);
3946     GLOBAL_STATE_CODE();
3947     assert(!qemu_in_coroutine());
3948
3949     if (reference) {
3950         bool options_non_empty = options ? qdict_size(options) : false;
3951         qobject_unref(options);
3952
3953         if (filename || options_non_empty) {
3954             error_setg(errp, "Cannot reference an existing block device with "
3955                        "additional options or a new filename");
3956             return NULL;
3957         }
3958
3959         bs = bdrv_lookup_bs(reference, reference, errp);
3960         if (!bs) {
3961             return NULL;
3962         }
3963
3964         bdrv_ref(bs);
3965         return bs;
3966     }
3967
3968     bs = bdrv_new();
3969
3970     /* NULL means an empty set of options */
3971     if (options == NULL) {
3972         options = qdict_new();
3973     }
3974
3975     /* json: syntax counts as explicit options, as if in the QDict */
3976     parse_json_protocol(options, &filename, &local_err);
3977     if (local_err) {
3978         goto fail;
3979     }
3980
3981     bs->explicit_options = qdict_clone_shallow(options);
3982
3983     if (child_class) {
3984         bool parent_is_format;
3985
3986         if (parent->drv) {
3987             parent_is_format = parent->drv->is_format;
3988         } else {
3989             /*
3990              * parent->drv is not set yet because this node is opened for
3991              * (potential) format probing.  That means that @parent is going
3992              * to be a format node.
3993              */
3994             parent_is_format = true;
3995         }
3996
3997         bs->inherits_from = parent;
3998         child_class->inherit_options(child_role, parent_is_format,
3999                                      &flags, options,
4000                                      parent->open_flags, parent->options);
4001     }
4002
4003     ret = bdrv_fill_options(&options, filename, &flags, &local_err);
4004     if (ret < 0) {
4005         goto fail;
4006     }
4007
4008     /*
4009      * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
4010      * Caution: getting a boolean member of @options requires care.
4011      * When @options come from -blockdev or blockdev_add, members are
4012      * typed according to the QAPI schema, but when they come from
4013      * -drive, they're all QString.
4014      */
4015     if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
4016         !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
4017         flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
4018     } else {
4019         flags &= ~BDRV_O_RDWR;
4020     }
4021
4022     if (flags & BDRV_O_SNAPSHOT) {
4023         snapshot_options = qdict_new();
4024         bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
4025                                    flags, options);
4026         /* Let bdrv_backing_options() override "read-only" */
4027         qdict_del(options, BDRV_OPT_READ_ONLY);
4028         bdrv_inherited_options(BDRV_CHILD_COW, true,
4029                                &flags, options, flags, options);
4030     }
4031
4032     bs->open_flags = flags;
4033     bs->options = options;
4034     options = qdict_clone_shallow(options);
4035
4036     /* Find the right image format driver */
4037     /* See cautionary note on accessing @options above */
4038     drvname = qdict_get_try_str(options, "driver");
4039     if (drvname) {
4040         drv = bdrv_find_format(drvname);
4041         if (!drv) {
4042             error_setg(errp, "Unknown driver: '%s'", drvname);
4043             goto fail;
4044         }
4045     }
4046
4047     assert(drvname || !(flags & BDRV_O_PROTOCOL));
4048
4049     /* See cautionary note on accessing @options above */
4050     backing = qdict_get_try_str(options, "backing");
4051     if (qobject_to(QNull, qdict_get(options, "backing")) != NULL ||
4052         (backing && *backing == '\0'))
4053     {
4054         if (backing) {
4055             warn_report("Use of \"backing\": \"\" is deprecated; "
4056                         "use \"backing\": null instead");
4057         }
4058         flags |= BDRV_O_NO_BACKING;
4059         qdict_del(bs->explicit_options, "backing");
4060         qdict_del(bs->options, "backing");
4061         qdict_del(options, "backing");
4062     }
4063
4064     /* Open image file without format layer. This BlockBackend is only used for
4065      * probing, the block drivers will do their own bdrv_open_child() for the
4066      * same BDS, which is why we put the node name back into options. */
4067     if ((flags & BDRV_O_PROTOCOL) == 0) {
4068         BlockDriverState *file_bs;
4069
4070         file_bs = bdrv_open_child_bs(filename, options, "file", bs,
4071                                      &child_of_bds, BDRV_CHILD_IMAGE,
4072                                      true, &local_err);
4073         if (local_err) {
4074             goto fail;
4075         }
4076         if (file_bs != NULL) {
4077             /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
4078              * looking at the header to guess the image format. This works even
4079              * in cases where a guest would not see a consistent state. */
4080             ctx = bdrv_get_aio_context(file_bs);
4081             aio_context_acquire(ctx);
4082             file = blk_new(ctx, 0, BLK_PERM_ALL);
4083             blk_insert_bs(file, file_bs, &local_err);
4084             bdrv_unref(file_bs);
4085             aio_context_release(ctx);
4086
4087             if (local_err) {
4088                 goto fail;
4089             }
4090
4091             qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
4092         }
4093     }
4094
4095     /* Image format probing */
4096     bs->probed = !drv;
4097     if (!drv && file) {
4098         ret = find_image_format(file, filename, &drv, &local_err);
4099         if (ret < 0) {
4100             goto fail;
4101         }
4102         /*
4103          * This option update would logically belong in bdrv_fill_options(),
4104          * but we first need to open bs->file for the probing to work, while
4105          * opening bs->file already requires the (mostly) final set of options
4106          * so that cache mode etc. can be inherited.
4107          *
4108          * Adding the driver later is somewhat ugly, but it's not an option
4109          * that would ever be inherited, so it's correct. We just need to make
4110          * sure to update both bs->options (which has the full effective
4111          * options for bs) and options (which has file.* already removed).
4112          */
4113         qdict_put_str(bs->options, "driver", drv->format_name);
4114         qdict_put_str(options, "driver", drv->format_name);
4115     } else if (!drv) {
4116         error_setg(errp, "Must specify either driver or file");
4117         goto fail;
4118     }
4119
4120     /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
4121     assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
4122     /* file must be NULL if a protocol BDS is about to be created
4123      * (the inverse results in an error message from bdrv_open_common()) */
4124     assert(!(flags & BDRV_O_PROTOCOL) || !file);
4125
4126     /* Open the image */
4127     ret = bdrv_open_common(bs, file, options, &local_err);
4128     if (ret < 0) {
4129         goto fail;
4130     }
4131
4132     /* The AioContext could have changed during bdrv_open_common() */
4133     ctx = bdrv_get_aio_context(bs);
4134
4135     if (file) {
4136         aio_context_acquire(ctx);
4137         blk_unref(file);
4138         aio_context_release(ctx);
4139         file = NULL;
4140     }
4141
4142     /* If there is a backing file, use it */
4143     if ((flags & BDRV_O_NO_BACKING) == 0) {
4144         ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
4145         if (ret < 0) {
4146             goto close_and_fail;
4147         }
4148     }
4149
4150     /* Remove all children options and references
4151      * from bs->options and bs->explicit_options */
4152     QLIST_FOREACH(child, &bs->children, next) {
4153         char *child_key_dot;
4154         child_key_dot = g_strdup_printf("%s.", child->name);
4155         qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot);
4156         qdict_extract_subqdict(bs->options, NULL, child_key_dot);
4157         qdict_del(bs->explicit_options, child->name);
4158         qdict_del(bs->options, child->name);
4159         g_free(child_key_dot);
4160     }
4161
4162     /* Check if any unknown options were used */
4163     if (qdict_size(options) != 0) {
4164         const QDictEntry *entry = qdict_first(options);
4165         if (flags & BDRV_O_PROTOCOL) {
4166             error_setg(errp, "Block protocol '%s' doesn't support the option "
4167                        "'%s'", drv->format_name, entry->key);
4168         } else {
4169             error_setg(errp,
4170                        "Block format '%s' does not support the option '%s'",
4171                        drv->format_name, entry->key);
4172         }
4173
4174         goto close_and_fail;
4175     }
4176
4177     bdrv_parent_cb_change_media(bs, true);
4178
4179     qobject_unref(options);
4180     options = NULL;
4181
4182     /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
4183      * temporary snapshot afterwards. */
4184     if (snapshot_flags) {
4185         BlockDriverState *snapshot_bs;
4186         snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
4187                                                 snapshot_options, &local_err);
4188         snapshot_options = NULL;
4189         if (local_err) {
4190             goto close_and_fail;
4191         }
4192         /* We are not going to return bs but the overlay on top of it
4193          * (snapshot_bs); thus, we have to drop the strong reference to bs
4194          * (which we obtained by calling bdrv_new()). bs will not be deleted,
4195          * though, because the overlay still has a reference to it. */
4196         aio_context_acquire(ctx);
4197         bdrv_unref(bs);
4198         aio_context_release(ctx);
4199         bs = snapshot_bs;
4200     }
4201
4202     return bs;
4203
4204 fail:
4205     aio_context_acquire(ctx);
4206     blk_unref(file);
4207     qobject_unref(snapshot_options);
4208     qobject_unref(bs->explicit_options);
4209     qobject_unref(bs->options);
4210     qobject_unref(options);
4211     bs->options = NULL;
4212     bs->explicit_options = NULL;
4213     bdrv_unref(bs);
4214     aio_context_release(ctx);
4215     error_propagate(errp, local_err);
4216     return NULL;
4217
4218 close_and_fail:
4219     aio_context_acquire(ctx);
4220     bdrv_unref(bs);
4221     aio_context_release(ctx);
4222     qobject_unref(snapshot_options);
4223     qobject_unref(options);
4224     error_propagate(errp, local_err);
4225     return NULL;
4226 }
4227
4228 /* The caller must always hold the main AioContext lock. */
4229 BlockDriverState *bdrv_open(const char *filename, const char *reference,
4230                             QDict *options, int flags, Error **errp)
4231 {
4232     GLOBAL_STATE_CODE();
4233
4234     return bdrv_open_inherit(filename, reference, options, flags, NULL,
4235                              NULL, 0, errp);
4236 }
4237
4238 /* Return true if the NULL-terminated @list contains @str */
4239 static bool is_str_in_list(const char *str, const char *const *list)
4240 {
4241     if (str && list) {
4242         int i;
4243         for (i = 0; list[i] != NULL; i++) {
4244             if (!strcmp(str, list[i])) {
4245                 return true;
4246             }
4247         }
4248     }
4249     return false;
4250 }
4251
4252 /*
4253  * Check that every option set in @bs->options is also set in
4254  * @new_opts.
4255  *
4256  * Options listed in the common_options list and in
4257  * @bs->drv->mutable_opts are skipped.
4258  *
4259  * Return 0 on success, otherwise return -EINVAL and set @errp.
4260  */
4261 static int bdrv_reset_options_allowed(BlockDriverState *bs,
4262                                       const QDict *new_opts, Error **errp)
4263 {
4264     const QDictEntry *e;
4265     /* These options are common to all block drivers and are handled
4266      * in bdrv_reopen_prepare() so they can be left out of @new_opts */
4267     const char *const common_options[] = {
4268         "node-name", "discard", "cache.direct", "cache.no-flush",
4269         "read-only", "auto-read-only", "detect-zeroes", NULL
4270     };
4271
4272     for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
4273         if (!qdict_haskey(new_opts, e->key) &&
4274             !is_str_in_list(e->key, common_options) &&
4275             !is_str_in_list(e->key, bs->drv->mutable_opts)) {
4276             error_setg(errp, "Option '%s' cannot be reset "
4277                        "to its default value", e->key);
4278             return -EINVAL;
4279         }
4280     }
4281
4282     return 0;
4283 }
4284
4285 /*
4286  * Returns true if @child can be reached recursively from @bs
4287  */
4288 static bool bdrv_recurse_has_child(BlockDriverState *bs,
4289                                    BlockDriverState *child)
4290 {
4291     BdrvChild *c;
4292
4293     if (bs == child) {
4294         return true;
4295     }
4296
4297     QLIST_FOREACH(c, &bs->children, next) {
4298         if (bdrv_recurse_has_child(c->bs, child)) {
4299             return true;
4300         }
4301     }
4302
4303     return false;
4304 }
4305
4306 /*
4307  * Adds a BlockDriverState to a simple queue for an atomic, transactional
4308  * reopen of multiple devices.
4309  *
4310  * bs_queue can either be an existing BlockReopenQueue that has had QTAILQ_INIT
4311  * already performed, or alternatively may be NULL a new BlockReopenQueue will
4312  * be created and initialized. This newly created BlockReopenQueue should be
4313  * passed back in for subsequent calls that are intended to be of the same
4314  * atomic 'set'.
4315  *
4316  * bs is the BlockDriverState to add to the reopen queue.
4317  *
4318  * options contains the changed options for the associated bs
4319  * (the BlockReopenQueue takes ownership)
4320  *
4321  * flags contains the open flags for the associated bs
4322  *
4323  * returns a pointer to bs_queue, which is either the newly allocated
4324  * bs_queue, or the existing bs_queue being used.
4325  *
4326  * bs is drained here and undrained by bdrv_reopen_queue_free().
4327  *
4328  * To be called with bs->aio_context locked.
4329  */
4330 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
4331                                                  BlockDriverState *bs,
4332                                                  QDict *options,
4333                                                  const BdrvChildClass *klass,
4334                                                  BdrvChildRole role,
4335                                                  bool parent_is_format,
4336                                                  QDict *parent_options,
4337                                                  int parent_flags,
4338                                                  bool keep_old_opts)
4339 {
4340     assert(bs != NULL);
4341
4342     BlockReopenQueueEntry *bs_entry;
4343     BdrvChild *child;
4344     QDict *old_options, *explicit_options, *options_copy;
4345     int flags;
4346     QemuOpts *opts;
4347
4348     GLOBAL_STATE_CODE();
4349
4350     bdrv_drained_begin(bs);
4351
4352     if (bs_queue == NULL) {
4353         bs_queue = g_new0(BlockReopenQueue, 1);
4354         QTAILQ_INIT(bs_queue);
4355     }
4356
4357     if (!options) {
4358         options = qdict_new();
4359     }
4360
4361     /* Check if this BlockDriverState is already in the queue */
4362     QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4363         if (bs == bs_entry->state.bs) {
4364             break;
4365         }
4366     }
4367
4368     /*
4369      * Precedence of options:
4370      * 1. Explicitly passed in options (highest)
4371      * 2. Retained from explicitly set options of bs
4372      * 3. Inherited from parent node
4373      * 4. Retained from effective options of bs
4374      */
4375
4376     /* Old explicitly set values (don't overwrite by inherited value) */
4377     if (bs_entry || keep_old_opts) {
4378         old_options = qdict_clone_shallow(bs_entry ?
4379                                           bs_entry->state.explicit_options :
4380                                           bs->explicit_options);
4381         bdrv_join_options(bs, options, old_options);
4382         qobject_unref(old_options);
4383     }
4384
4385     explicit_options = qdict_clone_shallow(options);
4386
4387     /* Inherit from parent node */
4388     if (parent_options) {
4389         flags = 0;
4390         klass->inherit_options(role, parent_is_format, &flags, options,
4391                                parent_flags, parent_options);
4392     } else {
4393         flags = bdrv_get_flags(bs);
4394     }
4395
4396     if (keep_old_opts) {
4397         /* Old values are used for options that aren't set yet */
4398         old_options = qdict_clone_shallow(bs->options);
4399         bdrv_join_options(bs, options, old_options);
4400         qobject_unref(old_options);
4401     }
4402
4403     /* We have the final set of options so let's update the flags */
4404     options_copy = qdict_clone_shallow(options);
4405     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
4406     qemu_opts_absorb_qdict(opts, options_copy, NULL);
4407     update_flags_from_options(&flags, opts);
4408     qemu_opts_del(opts);
4409     qobject_unref(options_copy);
4410
4411     /* bdrv_open_inherit() sets and clears some additional flags internally */
4412     flags &= ~BDRV_O_PROTOCOL;
4413     if (flags & BDRV_O_RDWR) {
4414         flags |= BDRV_O_ALLOW_RDWR;
4415     }
4416
4417     if (!bs_entry) {
4418         bs_entry = g_new0(BlockReopenQueueEntry, 1);
4419         QTAILQ_INSERT_TAIL(bs_queue, bs_entry, entry);
4420     } else {
4421         qobject_unref(bs_entry->state.options);
4422         qobject_unref(bs_entry->state.explicit_options);
4423     }
4424
4425     bs_entry->state.bs = bs;
4426     bs_entry->state.options = options;
4427     bs_entry->state.explicit_options = explicit_options;
4428     bs_entry->state.flags = flags;
4429
4430     /*
4431      * If keep_old_opts is false then it means that unspecified
4432      * options must be reset to their original value. We don't allow
4433      * resetting 'backing' but we need to know if the option is
4434      * missing in order to decide if we have to return an error.
4435      */
4436     if (!keep_old_opts) {
4437         bs_entry->state.backing_missing =
4438             !qdict_haskey(options, "backing") &&
4439             !qdict_haskey(options, "backing.driver");
4440     }
4441
4442     QLIST_FOREACH(child, &bs->children, next) {
4443         QDict *new_child_options = NULL;
4444         bool child_keep_old = keep_old_opts;
4445
4446         /* reopen can only change the options of block devices that were
4447          * implicitly created and inherited options. For other (referenced)
4448          * block devices, a syntax like "backing.foo" results in an error. */
4449         if (child->bs->inherits_from != bs) {
4450             continue;
4451         }
4452
4453         /* Check if the options contain a child reference */
4454         if (qdict_haskey(options, child->name)) {
4455             const char *childref = qdict_get_try_str(options, child->name);
4456             /*
4457              * The current child must not be reopened if the child
4458              * reference is null or points to a different node.
4459              */
4460             if (g_strcmp0(childref, child->bs->node_name)) {
4461                 continue;
4462             }
4463             /*
4464              * If the child reference points to the current child then
4465              * reopen it with its existing set of options (note that
4466              * it can still inherit new options from the parent).
4467              */
4468             child_keep_old = true;
4469         } else {
4470             /* Extract child options ("child-name.*") */
4471             char *child_key_dot = g_strdup_printf("%s.", child->name);
4472             qdict_extract_subqdict(explicit_options, NULL, child_key_dot);
4473             qdict_extract_subqdict(options, &new_child_options, child_key_dot);
4474             g_free(child_key_dot);
4475         }
4476
4477         bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options,
4478                                 child->klass, child->role, bs->drv->is_format,
4479                                 options, flags, child_keep_old);
4480     }
4481
4482     return bs_queue;
4483 }
4484
4485 /* To be called with bs->aio_context locked */
4486 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
4487                                     BlockDriverState *bs,
4488                                     QDict *options, bool keep_old_opts)
4489 {
4490     GLOBAL_STATE_CODE();
4491
4492     return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, false,
4493                                    NULL, 0, keep_old_opts);
4494 }
4495
4496 void bdrv_reopen_queue_free(BlockReopenQueue *bs_queue)
4497 {
4498     GLOBAL_STATE_CODE();
4499     if (bs_queue) {
4500         BlockReopenQueueEntry *bs_entry, *next;
4501         QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
4502             AioContext *ctx = bdrv_get_aio_context(bs_entry->state.bs);
4503
4504             aio_context_acquire(ctx);
4505             bdrv_drained_end(bs_entry->state.bs);
4506             aio_context_release(ctx);
4507
4508             qobject_unref(bs_entry->state.explicit_options);
4509             qobject_unref(bs_entry->state.options);
4510             g_free(bs_entry);
4511         }
4512         g_free(bs_queue);
4513     }
4514 }
4515
4516 /*
4517  * Reopen multiple BlockDriverStates atomically & transactionally.
4518  *
4519  * The queue passed in (bs_queue) must have been built up previous
4520  * via bdrv_reopen_queue().
4521  *
4522  * Reopens all BDS specified in the queue, with the appropriate
4523  * flags.  All devices are prepared for reopen, and failure of any
4524  * device will cause all device changes to be abandoned, and intermediate
4525  * data cleaned up.
4526  *
4527  * If all devices prepare successfully, then the changes are committed
4528  * to all devices.
4529  *
4530  * All affected nodes must be drained between bdrv_reopen_queue() and
4531  * bdrv_reopen_multiple().
4532  *
4533  * To be called from the main thread, with all other AioContexts unlocked.
4534  */
4535 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
4536 {
4537     int ret = -1;
4538     BlockReopenQueueEntry *bs_entry, *next;
4539     AioContext *ctx;
4540     Transaction *tran = tran_new();
4541     g_autoptr(GSList) refresh_list = NULL;
4542
4543     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
4544     assert(bs_queue != NULL);
4545     GLOBAL_STATE_CODE();
4546
4547     QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4548         ctx = bdrv_get_aio_context(bs_entry->state.bs);
4549         aio_context_acquire(ctx);
4550         ret = bdrv_flush(bs_entry->state.bs);
4551         aio_context_release(ctx);
4552         if (ret < 0) {
4553             error_setg_errno(errp, -ret, "Error flushing drive");
4554             goto abort;
4555         }
4556     }
4557
4558     QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4559         assert(bs_entry->state.bs->quiesce_counter > 0);
4560         ctx = bdrv_get_aio_context(bs_entry->state.bs);
4561         aio_context_acquire(ctx);
4562         ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp);
4563         aio_context_release(ctx);
4564         if (ret < 0) {
4565             goto abort;
4566         }
4567         bs_entry->prepared = true;
4568     }
4569
4570     QTAILQ_FOREACH(bs_entry, bs_queue, entry) {
4571         BDRVReopenState *state = &bs_entry->state;
4572
4573         refresh_list = g_slist_prepend(refresh_list, state->bs);
4574         if (state->old_backing_bs) {
4575             refresh_list = g_slist_prepend(refresh_list, state->old_backing_bs);
4576         }
4577         if (state->old_file_bs) {
4578             refresh_list = g_slist_prepend(refresh_list, state->old_file_bs);
4579         }
4580     }
4581
4582     /*
4583      * Note that file-posix driver rely on permission update done during reopen
4584      * (even if no permission changed), because it wants "new" permissions for
4585      * reconfiguring the fd and that's why it does it in raw_check_perm(), not
4586      * in raw_reopen_prepare() which is called with "old" permissions.
4587      */
4588     ret = bdrv_list_refresh_perms(refresh_list, bs_queue, tran, errp);
4589     if (ret < 0) {
4590         goto abort;
4591     }
4592
4593     /*
4594      * If we reach this point, we have success and just need to apply the
4595      * changes.
4596      *
4597      * Reverse order is used to comfort qcow2 driver: on commit it need to write
4598      * IN_USE flag to the image, to mark bitmaps in the image as invalid. But
4599      * children are usually goes after parents in reopen-queue, so go from last
4600      * to first element.
4601      */
4602     QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
4603         ctx = bdrv_get_aio_context(bs_entry->state.bs);
4604         aio_context_acquire(ctx);
4605         bdrv_reopen_commit(&bs_entry->state);
4606         aio_context_release(ctx);
4607     }
4608
4609     bdrv_graph_wrlock(NULL);
4610     tran_commit(tran);
4611     bdrv_graph_wrunlock();
4612
4613     QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) {
4614         BlockDriverState *bs = bs_entry->state.bs;
4615
4616         if (bs->drv->bdrv_reopen_commit_post) {
4617             ctx = bdrv_get_aio_context(bs);
4618             aio_context_acquire(ctx);
4619             bs->drv->bdrv_reopen_commit_post(&bs_entry->state);
4620             aio_context_release(ctx);
4621         }
4622     }
4623
4624     ret = 0;
4625     goto cleanup;
4626
4627 abort:
4628     bdrv_graph_wrlock(NULL);
4629     tran_abort(tran);
4630     bdrv_graph_wrunlock();
4631
4632     QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
4633         if (bs_entry->prepared) {
4634             ctx = bdrv_get_aio_context(bs_entry->state.bs);
4635             aio_context_acquire(ctx);
4636             bdrv_reopen_abort(&bs_entry->state);
4637             aio_context_release(ctx);
4638         }
4639     }
4640
4641 cleanup:
4642     bdrv_reopen_queue_free(bs_queue);
4643
4644     return ret;
4645 }
4646
4647 int bdrv_reopen(BlockDriverState *bs, QDict *opts, bool keep_old_opts,
4648                 Error **errp)
4649 {
4650     AioContext *ctx = bdrv_get_aio_context(bs);
4651     BlockReopenQueue *queue;
4652     int ret;
4653
4654     GLOBAL_STATE_CODE();
4655
4656     queue = bdrv_reopen_queue(NULL, bs, opts, keep_old_opts);
4657
4658     if (ctx != qemu_get_aio_context()) {
4659         aio_context_release(ctx);
4660     }
4661     ret = bdrv_reopen_multiple(queue, errp);
4662
4663     if (ctx != qemu_get_aio_context()) {
4664         aio_context_acquire(ctx);
4665     }
4666
4667     return ret;
4668 }
4669
4670 int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
4671                               Error **errp)
4672 {
4673     QDict *opts = qdict_new();
4674
4675     GLOBAL_STATE_CODE();
4676
4677     qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only);
4678
4679     return bdrv_reopen(bs, opts, true, errp);
4680 }
4681
4682 /*
4683  * Take a BDRVReopenState and check if the value of 'backing' in the
4684  * reopen_state->options QDict is valid or not.
4685  *
4686  * If 'backing' is missing from the QDict then return 0.
4687  *
4688  * If 'backing' contains the node name of the backing file of
4689  * reopen_state->bs then return 0.
4690  *
4691  * If 'backing' contains a different node name (or is null) then check
4692  * whether the current backing file can be replaced with the new one.
4693  * If that's the case then reopen_state->replace_backing_bs is set to
4694  * true and reopen_state->new_backing_bs contains a pointer to the new
4695  * backing BlockDriverState (or NULL).
4696  *
4697  * After calling this function, the transaction @tran may only be completed
4698  * while holding a writer lock for the graph.
4699  *
4700  * Return 0 on success, otherwise return < 0 and set @errp.
4701  *
4702  * The caller must hold the AioContext lock of @reopen_state->bs.
4703  * @reopen_state->bs can move to a different AioContext in this function.
4704  * Callers must make sure that their AioContext locking is still correct after
4705  * this.
4706  */
4707 static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
4708                                              bool is_backing, Transaction *tran,
4709                                              Error **errp)
4710 {
4711     BlockDriverState *bs = reopen_state->bs;
4712     BlockDriverState *new_child_bs;
4713     BlockDriverState *old_child_bs = is_backing ? child_bs(bs->backing) :
4714                                                   child_bs(bs->file);
4715     const char *child_name = is_backing ? "backing" : "file";
4716     QObject *value;
4717     const char *str;
4718     AioContext *ctx, *old_ctx;
4719     int ret;
4720
4721     GLOBAL_STATE_CODE();
4722
4723     value = qdict_get(reopen_state->options, child_name);
4724     if (value == NULL) {
4725         return 0;
4726     }
4727
4728     switch (qobject_type(value)) {
4729     case QTYPE_QNULL:
4730         assert(is_backing); /* The 'file' option does not allow a null value */
4731         new_child_bs = NULL;
4732         break;
4733     case QTYPE_QSTRING:
4734         str = qstring_get_str(qobject_to(QString, value));
4735         new_child_bs = bdrv_lookup_bs(NULL, str, errp);
4736         if (new_child_bs == NULL) {
4737             return -EINVAL;
4738         } else if (bdrv_recurse_has_child(new_child_bs, bs)) {
4739             error_setg(errp, "Making '%s' a %s child of '%s' would create a "
4740                        "cycle", str, child_name, bs->node_name);
4741             return -EINVAL;
4742         }
4743         break;
4744     default:
4745         /*
4746          * The options QDict has been flattened, so 'backing' and 'file'
4747          * do not allow any other data type here.
4748          */
4749         g_assert_not_reached();
4750     }
4751
4752     if (old_child_bs == new_child_bs) {
4753         return 0;
4754     }
4755
4756     if (old_child_bs) {
4757         if (bdrv_skip_implicit_filters(old_child_bs) == new_child_bs) {
4758             return 0;
4759         }
4760
4761         if (old_child_bs->implicit) {
4762             error_setg(errp, "Cannot replace implicit %s child of %s",
4763                        child_name, bs->node_name);
4764             return -EPERM;
4765         }
4766     }
4767
4768     if (bs->drv->is_filter && !old_child_bs) {
4769         /*
4770          * Filters always have a file or a backing child, so we are trying to
4771          * change wrong child
4772          */
4773         error_setg(errp, "'%s' is a %s filter node that does not support a "
4774                    "%s child", bs->node_name, bs->drv->format_name, child_name);
4775         return -EINVAL;
4776     }
4777
4778     if (is_backing) {
4779         reopen_state->old_backing_bs = old_child_bs;
4780     } else {
4781         reopen_state->old_file_bs = old_child_bs;
4782     }
4783
4784     if (old_child_bs) {
4785         bdrv_ref(old_child_bs);
4786         bdrv_drained_begin(old_child_bs);
4787     }
4788
4789     old_ctx = bdrv_get_aio_context(bs);
4790     ctx = bdrv_get_aio_context(new_child_bs);
4791     if (old_ctx != ctx) {
4792         aio_context_release(old_ctx);
4793         aio_context_acquire(ctx);
4794     }
4795
4796     bdrv_graph_wrlock(new_child_bs);
4797
4798     ret = bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
4799                                           tran, errp);
4800
4801     bdrv_graph_wrunlock();
4802
4803     if (old_ctx != ctx) {
4804         aio_context_release(ctx);
4805         aio_context_acquire(old_ctx);
4806     }
4807
4808     if (old_child_bs) {
4809         bdrv_drained_end(old_child_bs);
4810         bdrv_unref(old_child_bs);
4811     }
4812
4813     return ret;
4814 }
4815
4816 /*
4817  * Prepares a BlockDriverState for reopen. All changes are staged in the
4818  * 'opaque' field of the BDRVReopenState, which is used and allocated by
4819  * the block driver layer .bdrv_reopen_prepare()
4820  *
4821  * bs is the BlockDriverState to reopen
4822  * flags are the new open flags
4823  * queue is the reopen queue
4824  *
4825  * Returns 0 on success, non-zero on error.  On error errp will be set
4826  * as well.
4827  *
4828  * On failure, bdrv_reopen_abort() will be called to clean up any data.
4829  * It is the responsibility of the caller to then call the abort() or
4830  * commit() for any other BDS that have been left in a prepare() state
4831  *
4832  * The caller must hold the AioContext lock of @reopen_state->bs.
4833  *
4834  * After calling this function, the transaction @change_child_tran may only be
4835  * completed while holding a writer lock for the graph.
4836  */
4837 static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
4838                                BlockReopenQueue *queue,
4839                                Transaction *change_child_tran, Error **errp)
4840 {
4841     int ret = -1;
4842     int old_flags;
4843     Error *local_err = NULL;
4844     BlockDriver *drv;
4845     QemuOpts *opts;
4846     QDict *orig_reopen_opts;
4847     char *discard = NULL;
4848     bool read_only;
4849     bool drv_prepared = false;
4850
4851     assert(reopen_state != NULL);
4852     assert(reopen_state->bs->drv != NULL);
4853     GLOBAL_STATE_CODE();
4854     drv = reopen_state->bs->drv;
4855
4856     /* This function and each driver's bdrv_reopen_prepare() remove
4857      * entries from reopen_state->options as they are processed, so
4858      * we need to make a copy of the original QDict. */
4859     orig_reopen_opts = qdict_clone_shallow(reopen_state->options);
4860
4861     /* Process generic block layer options */
4862     opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
4863     if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) {
4864         ret = -EINVAL;
4865         goto error;
4866     }
4867
4868     /* This was already called in bdrv_reopen_queue_child() so the flags
4869      * are up-to-date. This time we simply want to remove the options from
4870      * QemuOpts in order to indicate that they have been processed. */
4871     old_flags = reopen_state->flags;
4872     update_flags_from_options(&reopen_state->flags, opts);
4873     assert(old_flags == reopen_state->flags);
4874
4875     discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD);
4876     if (discard != NULL) {
4877         if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) {
4878             error_setg(errp, "Invalid discard option");
4879             ret = -EINVAL;
4880             goto error;
4881         }
4882     }
4883
4884     reopen_state->detect_zeroes =
4885         bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err);
4886     if (local_err) {
4887         error_propagate(errp, local_err);
4888         ret = -EINVAL;
4889         goto error;
4890     }
4891
4892     /* All other options (including node-name and driver) must be unchanged.
4893      * Put them back into the QDict, so that they are checked at the end
4894      * of this function. */
4895     qemu_opts_to_qdict(opts, reopen_state->options);
4896
4897     /* If we are to stay read-only, do not allow permission change
4898      * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
4899      * not set, or if the BDS still has copy_on_read enabled */
4900     read_only = !(reopen_state->flags & BDRV_O_RDWR);
4901     ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
4902     if (local_err) {
4903         error_propagate(errp, local_err);
4904         goto error;
4905     }
4906
4907     if (drv->bdrv_reopen_prepare) {
4908         /*
4909          * If a driver-specific option is missing, it means that we
4910          * should reset it to its default value.
4911          * But not all options allow that, so we need to check it first.
4912          */
4913         ret = bdrv_reset_options_allowed(reopen_state->bs,
4914                                          reopen_state->options, errp);
4915         if (ret) {
4916             goto error;
4917         }
4918
4919         ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
4920         if (ret) {
4921             if (local_err != NULL) {
4922                 error_propagate(errp, local_err);
4923             } else {
4924                 bdrv_refresh_filename(reopen_state->bs);
4925                 error_setg(errp, "failed while preparing to reopen image '%s'",
4926                            reopen_state->bs->filename);
4927             }
4928             goto error;
4929         }
4930     } else {
4931         /* It is currently mandatory to have a bdrv_reopen_prepare()
4932          * handler for each supported drv. */
4933         error_setg(errp, "Block format '%s' used by node '%s' "
4934                    "does not support reopening files", drv->format_name,
4935                    bdrv_get_device_or_node_name(reopen_state->bs));
4936         ret = -1;
4937         goto error;
4938     }
4939
4940     drv_prepared = true;
4941
4942     /*
4943      * We must provide the 'backing' option if the BDS has a backing
4944      * file or if the image file has a backing file name as part of
4945      * its metadata. Otherwise the 'backing' option can be omitted.
4946      */
4947     if (drv->supports_backing && reopen_state->backing_missing &&
4948         (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) {
4949         error_setg(errp, "backing is missing for '%s'",
4950                    reopen_state->bs->node_name);
4951         ret = -EINVAL;
4952         goto error;
4953     }
4954
4955     /*
4956      * Allow changing the 'backing' option. The new value can be
4957      * either a reference to an existing node (using its node name)
4958      * or NULL to simply detach the current backing file.
4959      */
4960     ret = bdrv_reopen_parse_file_or_backing(reopen_state, true,
4961                                             change_child_tran, errp);
4962     if (ret < 0) {
4963         goto error;
4964     }
4965     qdict_del(reopen_state->options, "backing");
4966
4967     /* Allow changing the 'file' option. In this case NULL is not allowed */
4968     ret = bdrv_reopen_parse_file_or_backing(reopen_state, false,
4969                                             change_child_tran, errp);
4970     if (ret < 0) {
4971         goto error;
4972     }
4973     qdict_del(reopen_state->options, "file");
4974
4975     /* Options that are not handled are only okay if they are unchanged
4976      * compared to the old state. It is expected that some options are only
4977      * used for the initial open, but not reopen (e.g. filename) */
4978     if (qdict_size(reopen_state->options)) {
4979         const QDictEntry *entry = qdict_first(reopen_state->options);
4980
4981         do {
4982             QObject *new = entry->value;
4983             QObject *old = qdict_get(reopen_state->bs->options, entry->key);
4984
4985             /* Allow child references (child_name=node_name) as long as they
4986              * point to the current child (i.e. everything stays the same). */
4987             if (qobject_type(new) == QTYPE_QSTRING) {
4988                 BdrvChild *child;
4989                 QLIST_FOREACH(child, &reopen_state->bs->children, next) {
4990                     if (!strcmp(child->name, entry->key)) {
4991                         break;
4992                     }
4993                 }
4994
4995                 if (child) {
4996                     if (!strcmp(child->bs->node_name,
4997                                 qstring_get_str(qobject_to(QString, new)))) {
4998                         continue; /* Found child with this name, skip option */
4999                     }
5000                 }
5001             }
5002
5003             /*
5004              * TODO: When using -drive to specify blockdev options, all values
5005              * will be strings; however, when using -blockdev, blockdev-add or
5006              * filenames using the json:{} pseudo-protocol, they will be
5007              * correctly typed.
5008              * In contrast, reopening options are (currently) always strings
5009              * (because you can only specify them through qemu-io; all other
5010              * callers do not specify any options).
5011              * Therefore, when using anything other than -drive to create a BDS,
5012              * this cannot detect non-string options as unchanged, because
5013              * qobject_is_equal() always returns false for objects of different
5014              * type.  In the future, this should be remedied by correctly typing
5015              * all options.  For now, this is not too big of an issue because
5016              * the user can simply omit options which cannot be changed anyway,
5017              * so they will stay unchanged.
5018              */
5019             if (!qobject_is_equal(new, old)) {
5020                 error_setg(errp, "Cannot change the option '%s'", entry->key);
5021                 ret = -EINVAL;
5022                 goto error;
5023             }
5024         } while ((entry = qdict_next(reopen_state->options, entry)));
5025     }
5026
5027     ret = 0;
5028
5029     /* Restore the original reopen_state->options QDict */
5030     qobject_unref(reopen_state->options);
5031     reopen_state->options = qobject_ref(orig_reopen_opts);
5032
5033 error:
5034     if (ret < 0 && drv_prepared) {
5035         /* drv->bdrv_reopen_prepare() has succeeded, so we need to
5036          * call drv->bdrv_reopen_abort() before signaling an error
5037          * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
5038          * when the respective bdrv_reopen_prepare() has failed) */
5039         if (drv->bdrv_reopen_abort) {
5040             drv->bdrv_reopen_abort(reopen_state);
5041         }
5042     }
5043     qemu_opts_del(opts);
5044     qobject_unref(orig_reopen_opts);
5045     g_free(discard);
5046     return ret;
5047 }
5048
5049 /*
5050  * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
5051  * makes them final by swapping the staging BlockDriverState contents into
5052  * the active BlockDriverState contents.
5053  */
5054 static void bdrv_reopen_commit(BDRVReopenState *reopen_state)
5055 {
5056     BlockDriver *drv;
5057     BlockDriverState *bs;
5058     BdrvChild *child;
5059
5060     assert(reopen_state != NULL);
5061     bs = reopen_state->bs;
5062     drv = bs->drv;
5063     assert(drv != NULL);
5064     GLOBAL_STATE_CODE();
5065
5066     /* If there are any driver level actions to take */
5067     if (drv->bdrv_reopen_commit) {
5068         drv->bdrv_reopen_commit(reopen_state);
5069     }
5070
5071     /* set BDS specific flags now */
5072     qobject_unref(bs->explicit_options);
5073     qobject_unref(bs->options);
5074     qobject_ref(reopen_state->explicit_options);
5075     qobject_ref(reopen_state->options);
5076
5077     bs->explicit_options   = reopen_state->explicit_options;
5078     bs->options            = reopen_state->options;
5079     bs->open_flags         = reopen_state->flags;
5080     bs->detect_zeroes      = reopen_state->detect_zeroes;
5081
5082     /* Remove child references from bs->options and bs->explicit_options.
5083      * Child options were already removed in bdrv_reopen_queue_child() */
5084     QLIST_FOREACH(child, &bs->children, next) {
5085         qdict_del(bs->explicit_options, child->name);
5086         qdict_del(bs->options, child->name);
5087     }
5088     /* backing is probably removed, so it's not handled by previous loop */
5089     qdict_del(bs->explicit_options, "backing");
5090     qdict_del(bs->options, "backing");
5091
5092     bdrv_graph_rdlock_main_loop();
5093     bdrv_refresh_limits(bs, NULL, NULL);
5094     bdrv_graph_rdunlock_main_loop();
5095     bdrv_refresh_total_sectors(bs, bs->total_sectors);
5096 }
5097
5098 /*
5099  * Abort the reopen, and delete and free the staged changes in
5100  * reopen_state
5101  */
5102 static void bdrv_reopen_abort(BDRVReopenState *reopen_state)
5103 {
5104     BlockDriver *drv;
5105
5106     assert(reopen_state != NULL);
5107     drv = reopen_state->bs->drv;
5108     assert(drv != NULL);
5109     GLOBAL_STATE_CODE();
5110
5111     if (drv->bdrv_reopen_abort) {
5112         drv->bdrv_reopen_abort(reopen_state);
5113     }
5114 }
5115
5116
5117 static void bdrv_close(BlockDriverState *bs)
5118 {
5119     BdrvAioNotifier *ban, *ban_next;
5120     BdrvChild *child, *next;
5121
5122     GLOBAL_STATE_CODE();
5123     assert(!bs->refcnt);
5124
5125     bdrv_drained_begin(bs); /* complete I/O */
5126     bdrv_flush(bs);
5127     bdrv_drain(bs); /* in case flush left pending I/O */
5128
5129     if (bs->drv) {
5130         if (bs->drv->bdrv_close) {
5131             /* Must unfreeze all children, so bdrv_unref_child() works */
5132             bs->drv->bdrv_close(bs);
5133         }
5134         bs->drv = NULL;
5135     }
5136
5137     QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
5138         bdrv_unref_child(bs, child);
5139     }
5140
5141     assert(!bs->backing);
5142     assert(!bs->file);
5143     g_free(bs->opaque);
5144     bs->opaque = NULL;
5145     qatomic_set(&bs->copy_on_read, 0);
5146     bs->backing_file[0] = '\0';
5147     bs->backing_format[0] = '\0';
5148     bs->total_sectors = 0;
5149     bs->encrypted = false;
5150     bs->sg = false;
5151     qobject_unref(bs->options);
5152     qobject_unref(bs->explicit_options);
5153     bs->options = NULL;
5154     bs->explicit_options = NULL;
5155     qobject_unref(bs->full_open_options);
5156     bs->full_open_options = NULL;
5157     g_free(bs->block_status_cache);
5158     bs->block_status_cache = NULL;
5159
5160     bdrv_release_named_dirty_bitmaps(bs);
5161     assert(QLIST_EMPTY(&bs->dirty_bitmaps));
5162
5163     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
5164         g_free(ban);
5165     }
5166     QLIST_INIT(&bs->aio_notifiers);
5167     bdrv_drained_end(bs);
5168
5169     /*
5170      * If we're still inside some bdrv_drain_all_begin()/end() sections, end
5171      * them now since this BDS won't exist anymore when bdrv_drain_all_end()
5172      * gets called.
5173      */
5174     if (bs->quiesce_counter) {
5175         bdrv_drain_all_end_quiesce(bs);
5176     }
5177 }
5178
5179 void bdrv_close_all(void)
5180 {
5181     GLOBAL_STATE_CODE();
5182     assert(job_next(NULL) == NULL);
5183
5184     /* Drop references from requests still in flight, such as canceled block
5185      * jobs whose AIO context has not been polled yet */
5186     bdrv_drain_all();
5187
5188     blk_remove_all_bs();
5189     blockdev_close_all_bdrv_states();
5190
5191     assert(QTAILQ_EMPTY(&all_bdrv_states));
5192 }
5193
5194 static bool GRAPH_RDLOCK should_update_child(BdrvChild *c, BlockDriverState *to)
5195 {
5196     GQueue *queue;
5197     GHashTable *found;
5198     bool ret;
5199
5200     if (c->klass->stay_at_node) {
5201         return false;
5202     }
5203
5204     /* If the child @c belongs to the BDS @to, replacing the current
5205      * c->bs by @to would mean to create a loop.
5206      *
5207      * Such a case occurs when appending a BDS to a backing chain.
5208      * For instance, imagine the following chain:
5209      *
5210      *   guest device -> node A -> further backing chain...
5211      *
5212      * Now we create a new BDS B which we want to put on top of this
5213      * chain, so we first attach A as its backing node:
5214      *
5215      *                   node B
5216      *                     |
5217      *                     v
5218      *   guest device -> node A -> further backing chain...
5219      *
5220      * Finally we want to replace A by B.  When doing that, we want to
5221      * replace all pointers to A by pointers to B -- except for the
5222      * pointer from B because (1) that would create a loop, and (2)
5223      * that pointer should simply stay intact:
5224      *
5225      *   guest device -> node B
5226      *                     |
5227      *                     v
5228      *                   node A -> further backing chain...
5229      *
5230      * In general, when replacing a node A (c->bs) by a node B (@to),
5231      * if A is a child of B, that means we cannot replace A by B there
5232      * because that would create a loop.  Silently detaching A from B
5233      * is also not really an option.  So overall just leaving A in
5234      * place there is the most sensible choice.
5235      *
5236      * We would also create a loop in any cases where @c is only
5237      * indirectly referenced by @to. Prevent this by returning false
5238      * if @c is found (by breadth-first search) anywhere in the whole
5239      * subtree of @to.
5240      */
5241
5242     ret = true;
5243     found = g_hash_table_new(NULL, NULL);
5244     g_hash_table_add(found, to);
5245     queue = g_queue_new();
5246     g_queue_push_tail(queue, to);
5247
5248     while (!g_queue_is_empty(queue)) {
5249         BlockDriverState *v = g_queue_pop_head(queue);
5250         BdrvChild *c2;
5251
5252         QLIST_FOREACH(c2, &v->children, next) {
5253             if (c2 == c) {
5254                 ret = false;
5255                 break;
5256             }
5257
5258             if (g_hash_table_contains(found, c2->bs)) {
5259                 continue;
5260             }
5261
5262             g_queue_push_tail(queue, c2->bs);
5263             g_hash_table_add(found, c2->bs);
5264         }
5265     }
5266
5267     g_queue_free(queue);
5268     g_hash_table_destroy(found);
5269
5270     return ret;
5271 }
5272
5273 static void bdrv_remove_child_commit(void *opaque)
5274 {
5275     GLOBAL_STATE_CODE();
5276     bdrv_child_free(opaque);
5277 }
5278
5279 static TransactionActionDrv bdrv_remove_child_drv = {
5280     .commit = bdrv_remove_child_commit,
5281 };
5282
5283 /*
5284  * Function doesn't update permissions, caller is responsible for this.
5285  *
5286  * @child->bs (if non-NULL) must be drained.
5287  *
5288  * After calling this function, the transaction @tran may only be completed
5289  * while holding a writer lock for the graph.
5290  */
5291 static void GRAPH_WRLOCK bdrv_remove_child(BdrvChild *child, Transaction *tran)
5292 {
5293     if (!child) {
5294         return;
5295     }
5296
5297     if (child->bs) {
5298         assert(child->quiesced_parent);
5299         bdrv_replace_child_tran(child, NULL, tran);
5300     }
5301
5302     tran_add(tran, &bdrv_remove_child_drv, child);
5303 }
5304
5305 /*
5306  * Both @from and @to (if non-NULL) must be drained. @to must be kept drained
5307  * until the transaction is completed.
5308  *
5309  * After calling this function, the transaction @tran may only be completed
5310  * while holding a writer lock for the graph.
5311  */
5312 static int GRAPH_WRLOCK
5313 bdrv_replace_node_noperm(BlockDriverState *from,
5314                          BlockDriverState *to,
5315                          bool auto_skip, Transaction *tran,
5316                          Error **errp)
5317 {
5318     BdrvChild *c, *next;
5319
5320     GLOBAL_STATE_CODE();
5321
5322     assert(from->quiesce_counter);
5323     assert(to->quiesce_counter);
5324
5325     QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
5326         assert(c->bs == from);
5327         if (!should_update_child(c, to)) {
5328             if (auto_skip) {
5329                 continue;
5330             }
5331             error_setg(errp, "Should not change '%s' link to '%s'",
5332                        c->name, from->node_name);
5333             return -EINVAL;
5334         }
5335         if (c->frozen) {
5336             error_setg(errp, "Cannot change '%s' link to '%s'",
5337                        c->name, from->node_name);
5338             return -EPERM;
5339         }
5340         bdrv_replace_child_tran(c, to, tran);
5341     }
5342
5343     return 0;
5344 }
5345
5346 /*
5347  * With auto_skip=true bdrv_replace_node_common skips updating from parents
5348  * if it creates a parent-child relation loop or if parent is block-job.
5349  *
5350  * With auto_skip=false the error is returned if from has a parent which should
5351  * not be updated.
5352  *
5353  * With @detach_subchain=true @to must be in a backing chain of @from. In this
5354  * case backing link of the cow-parent of @to is removed.
5355  */
5356 static int bdrv_replace_node_common(BlockDriverState *from,
5357                                     BlockDriverState *to,
5358                                     bool auto_skip, bool detach_subchain,
5359                                     Error **errp)
5360 {
5361     Transaction *tran = tran_new();
5362     g_autoptr(GSList) refresh_list = NULL;
5363     BlockDriverState *to_cow_parent = NULL;
5364     int ret;
5365
5366     GLOBAL_STATE_CODE();
5367
5368     if (detach_subchain) {
5369         assert(bdrv_chain_contains(from, to));
5370         assert(from != to);
5371         for (to_cow_parent = from;
5372              bdrv_filter_or_cow_bs(to_cow_parent) != to;
5373              to_cow_parent = bdrv_filter_or_cow_bs(to_cow_parent))
5374         {
5375             ;
5376         }
5377     }
5378
5379     /* Make sure that @from doesn't go away until we have successfully attached
5380      * all of its parents to @to. */
5381     bdrv_ref(from);
5382
5383     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
5384     assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));
5385     bdrv_drained_begin(from);
5386     bdrv_drained_begin(to);
5387
5388     bdrv_graph_wrlock(to);
5389
5390     /*
5391      * Do the replacement without permission update.
5392      * Replacement may influence the permissions, we should calculate new
5393      * permissions based on new graph. If we fail, we'll roll-back the
5394      * replacement.
5395      */
5396     ret = bdrv_replace_node_noperm(from, to, auto_skip, tran, errp);
5397     if (ret < 0) {
5398         goto out;
5399     }
5400
5401     if (detach_subchain) {
5402         /* to_cow_parent is already drained because from is drained */
5403         bdrv_remove_child(bdrv_filter_or_cow_child(to_cow_parent), tran);
5404     }
5405
5406     refresh_list = g_slist_prepend(refresh_list, to);
5407     refresh_list = g_slist_prepend(refresh_list, from);
5408
5409     ret = bdrv_list_refresh_perms(refresh_list, NULL, tran, errp);
5410     if (ret < 0) {
5411         goto out;
5412     }
5413
5414     ret = 0;
5415
5416 out:
5417     tran_finalize(tran, ret);
5418     bdrv_graph_wrunlock();
5419
5420     bdrv_drained_end(to);
5421     bdrv_drained_end(from);
5422     bdrv_unref(from);
5423
5424     return ret;
5425 }
5426
5427 int bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
5428                       Error **errp)
5429 {
5430     GLOBAL_STATE_CODE();
5431
5432     return bdrv_replace_node_common(from, to, true, false, errp);
5433 }
5434
5435 int bdrv_drop_filter(BlockDriverState *bs, Error **errp)
5436 {
5437     GLOBAL_STATE_CODE();
5438
5439     return bdrv_replace_node_common(bs, bdrv_filter_or_cow_bs(bs), true, true,
5440                                     errp);
5441 }
5442
5443 /*
5444  * Add new bs contents at the top of an image chain while the chain is
5445  * live, while keeping required fields on the top layer.
5446  *
5447  * This will modify the BlockDriverState fields, and swap contents
5448  * between bs_new and bs_top. Both bs_new and bs_top are modified.
5449  *
5450  * bs_new must not be attached to a BlockBackend and must not have backing
5451  * child.
5452  *
5453  * This function does not create any image files.
5454  *
5455  * The caller must hold the AioContext lock for @bs_top.
5456  */
5457 int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
5458                 Error **errp)
5459 {
5460     int ret;
5461     BdrvChild *child;
5462     Transaction *tran = tran_new();
5463     AioContext *old_context, *new_context = NULL;
5464
5465     GLOBAL_STATE_CODE();
5466
5467     assert(!bs_new->backing);
5468
5469     old_context = bdrv_get_aio_context(bs_top);
5470     bdrv_drained_begin(bs_top);
5471
5472     /*
5473      * bdrv_drained_begin() requires that only the AioContext of the drained
5474      * node is locked, and at this point it can still differ from the AioContext
5475      * of bs_top.
5476      */
5477     new_context = bdrv_get_aio_context(bs_new);
5478     aio_context_release(old_context);
5479     aio_context_acquire(new_context);
5480     bdrv_drained_begin(bs_new);
5481     aio_context_release(new_context);
5482     aio_context_acquire(old_context);
5483     new_context = NULL;
5484
5485     bdrv_graph_wrlock(bs_top);
5486
5487     child = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
5488                                      &child_of_bds, bdrv_backing_role(bs_new),
5489                                      tran, errp);
5490     if (!child) {
5491         ret = -EINVAL;
5492         goto out;
5493     }
5494
5495     /*
5496      * bdrv_attach_child_noperm could change the AioContext of bs_top and
5497      * bs_new, but at least they are in the same AioContext now. This is the
5498      * AioContext that we need to lock for the rest of the function.
5499      */
5500     new_context = bdrv_get_aio_context(bs_top);
5501
5502     if (old_context != new_context) {
5503         aio_context_release(old_context);
5504         aio_context_acquire(new_context);
5505     }
5506
5507     ret = bdrv_replace_node_noperm(bs_top, bs_new, true, tran, errp);
5508     if (ret < 0) {
5509         goto out;
5510     }
5511
5512     ret = bdrv_refresh_perms(bs_new, tran, errp);
5513 out:
5514     tran_finalize(tran, ret);
5515
5516     bdrv_refresh_limits(bs_top, NULL, NULL);
5517     bdrv_graph_wrunlock();
5518
5519     bdrv_drained_end(bs_top);
5520     bdrv_drained_end(bs_new);
5521
5522     if (new_context && old_context != new_context) {
5523         aio_context_release(new_context);
5524         aio_context_acquire(old_context);
5525     }
5526
5527     return ret;
5528 }
5529
5530 /* Not for empty child */
5531 int bdrv_replace_child_bs(BdrvChild *child, BlockDriverState *new_bs,
5532                           Error **errp)
5533 {
5534     int ret;
5535     Transaction *tran = tran_new();
5536     g_autoptr(GSList) refresh_list = NULL;
5537     BlockDriverState *old_bs = child->bs;
5538
5539     GLOBAL_STATE_CODE();
5540
5541     bdrv_ref(old_bs);
5542     bdrv_drained_begin(old_bs);
5543     bdrv_drained_begin(new_bs);
5544     bdrv_graph_wrlock(new_bs);
5545
5546     bdrv_replace_child_tran(child, new_bs, tran);
5547
5548     refresh_list = g_slist_prepend(refresh_list, old_bs);
5549     refresh_list = g_slist_prepend(refresh_list, new_bs);
5550
5551     ret = bdrv_list_refresh_perms(refresh_list, NULL, tran, errp);
5552
5553     tran_finalize(tran, ret);
5554
5555     bdrv_graph_wrunlock();
5556     bdrv_drained_end(old_bs);
5557     bdrv_drained_end(new_bs);
5558     bdrv_unref(old_bs);
5559
5560     return ret;
5561 }
5562
5563 static void bdrv_delete(BlockDriverState *bs)
5564 {
5565     assert(bdrv_op_blocker_is_empty(bs));
5566     assert(!bs->refcnt);
5567     GLOBAL_STATE_CODE();
5568
5569     /* remove from list, if necessary */
5570     if (bs->node_name[0] != '\0') {
5571         QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
5572     }
5573     QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
5574
5575     bdrv_close(bs);
5576
5577     qemu_mutex_destroy(&bs->reqs_lock);
5578
5579     g_free(bs);
5580 }
5581
5582
5583 /*
5584  * Replace @bs by newly created block node.
5585  *
5586  * @options is a QDict of options to pass to the block drivers, or NULL for an
5587  * empty set of options. The reference to the QDict belongs to the block layer
5588  * after the call (even on failure), so if the caller intends to reuse the
5589  * dictionary, it needs to use qobject_ref() before calling bdrv_open.
5590  *
5591  * The caller holds the AioContext lock for @bs. It must make sure that @bs
5592  * stays in the same AioContext, i.e. @options must not refer to nodes in a
5593  * different AioContext.
5594  */
5595 BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *options,
5596                                    int flags, Error **errp)
5597 {
5598     ERRP_GUARD();
5599     int ret;
5600     AioContext *ctx = bdrv_get_aio_context(bs);
5601     BlockDriverState *new_node_bs = NULL;
5602     const char *drvname, *node_name;
5603     BlockDriver *drv;
5604
5605     drvname = qdict_get_try_str(options, "driver");
5606     if (!drvname) {
5607         error_setg(errp, "driver is not specified");
5608         goto fail;
5609     }
5610
5611     drv = bdrv_find_format(drvname);
5612     if (!drv) {
5613         error_setg(errp, "Unknown driver: '%s'", drvname);
5614         goto fail;
5615     }
5616
5617     node_name = qdict_get_try_str(options, "node-name");
5618
5619     GLOBAL_STATE_CODE();
5620
5621     aio_context_release(ctx);
5622     aio_context_acquire(qemu_get_aio_context());
5623     new_node_bs = bdrv_new_open_driver_opts(drv, node_name, options, flags,
5624                                             errp);
5625     aio_context_release(qemu_get_aio_context());
5626     aio_context_acquire(ctx);
5627     assert(bdrv_get_aio_context(bs) == ctx);
5628
5629     options = NULL; /* bdrv_new_open_driver() eats options */
5630     if (!new_node_bs) {
5631         error_prepend(errp, "Could not create node: ");
5632         goto fail;
5633     }
5634
5635     bdrv_drained_begin(bs);
5636     ret = bdrv_replace_node(bs, new_node_bs, errp);
5637     bdrv_drained_end(bs);
5638
5639     if (ret < 0) {
5640         error_prepend(errp, "Could not replace node: ");
5641         goto fail;
5642     }
5643
5644     return new_node_bs;
5645
5646 fail:
5647     qobject_unref(options);
5648     bdrv_unref(new_node_bs);
5649     return NULL;
5650 }
5651
5652 /*
5653  * Run consistency checks on an image
5654  *
5655  * Returns 0 if the check could be completed (it doesn't mean that the image is
5656  * free of errors) or -errno when an internal error occurred. The results of the
5657  * check are stored in res.
5658  */
5659 int coroutine_fn bdrv_co_check(BlockDriverState *bs,
5660                                BdrvCheckResult *res, BdrvCheckMode fix)
5661 {
5662     IO_CODE();
5663     assert_bdrv_graph_readable();
5664     if (bs->drv == NULL) {
5665         return -ENOMEDIUM;
5666     }
5667     if (bs->drv->bdrv_co_check == NULL) {
5668         return -ENOTSUP;
5669     }
5670
5671     memset(res, 0, sizeof(*res));
5672     return bs->drv->bdrv_co_check(bs, res, fix);
5673 }
5674
5675 /*
5676  * Return values:
5677  * 0        - success
5678  * -EINVAL  - backing format specified, but no file
5679  * -ENOSPC  - can't update the backing file because no space is left in the
5680  *            image file header
5681  * -ENOTSUP - format driver doesn't support changing the backing file
5682  */
5683 int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,
5684                              const char *backing_fmt, bool require)
5685 {
5686     BlockDriver *drv = bs->drv;
5687     int ret;
5688
5689     GLOBAL_STATE_CODE();
5690
5691     if (!drv) {
5692         return -ENOMEDIUM;
5693     }
5694
5695     /* Backing file format doesn't make sense without a backing file */
5696     if (backing_fmt && !backing_file) {
5697         return -EINVAL;
5698     }
5699
5700     if (require && backing_file && !backing_fmt) {
5701         return -EINVAL;
5702     }
5703
5704     if (drv->bdrv_change_backing_file != NULL) {
5705         ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
5706     } else {
5707         ret = -ENOTSUP;
5708     }
5709
5710     if (ret == 0) {
5711         pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
5712         pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
5713         pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
5714                 backing_file ?: "");
5715     }
5716     return ret;
5717 }
5718
5719 /*
5720  * Finds the first non-filter node above bs in the chain between
5721  * active and bs.  The returned node is either an immediate parent of
5722  * bs, or there are only filter nodes between the two.
5723  *
5724  * Returns NULL if bs is not found in active's image chain,
5725  * or if active == bs.
5726  *
5727  * Returns the bottommost base image if bs == NULL.
5728  */
5729 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
5730                                     BlockDriverState *bs)
5731 {
5732
5733     GLOBAL_STATE_CODE();
5734
5735     bs = bdrv_skip_filters(bs);
5736     active = bdrv_skip_filters(active);
5737
5738     while (active) {
5739         BlockDriverState *next = bdrv_backing_chain_next(active);
5740         if (bs == next) {
5741             return active;
5742         }
5743         active = next;
5744     }
5745
5746     return NULL;
5747 }
5748
5749 /* Given a BDS, searches for the base layer. */
5750 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
5751 {
5752     GLOBAL_STATE_CODE();
5753
5754     return bdrv_find_overlay(bs, NULL);
5755 }
5756
5757 /*
5758  * Return true if at least one of the COW (backing) and filter links
5759  * between @bs and @base is frozen. @errp is set if that's the case.
5760  * @base must be reachable from @bs, or NULL.
5761  */
5762 bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
5763                                   Error **errp)
5764 {
5765     BlockDriverState *i;
5766     BdrvChild *child;
5767
5768     GLOBAL_STATE_CODE();
5769
5770     for (i = bs; i != base; i = child_bs(child)) {
5771         child = bdrv_filter_or_cow_child(i);
5772
5773         if (child && child->frozen) {
5774             error_setg(errp, "Cannot change '%s' link from '%s' to '%s'",
5775                        child->name, i->node_name, child->bs->node_name);
5776             return true;
5777         }
5778     }
5779
5780     return false;
5781 }
5782
5783 /*
5784  * Freeze all COW (backing) and filter links between @bs and @base.
5785  * If any of the links is already frozen the operation is aborted and
5786  * none of the links are modified.
5787  * @base must be reachable from @bs, or NULL.
5788  * Returns 0 on success. On failure returns < 0 and sets @errp.
5789  */
5790 int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
5791                               Error **errp)
5792 {
5793     BlockDriverState *i;
5794     BdrvChild *child;
5795
5796     GLOBAL_STATE_CODE();
5797
5798     if (bdrv_is_backing_chain_frozen(bs, base, errp)) {
5799         return -EPERM;
5800     }
5801
5802     for (i = bs; i != base; i = child_bs(child)) {
5803         child = bdrv_filter_or_cow_child(i);
5804         if (child && child->bs->never_freeze) {
5805             error_setg(errp, "Cannot freeze '%s' link to '%s'",
5806                        child->name, child->bs->node_name);
5807             return -EPERM;
5808         }
5809     }
5810
5811     for (i = bs; i != base; i = child_bs(child)) {
5812         child = bdrv_filter_or_cow_child(i);
5813         if (child) {
5814             child->frozen = true;
5815         }
5816     }
5817
5818     return 0;
5819 }
5820
5821 /*
5822  * Unfreeze all COW (backing) and filter links between @bs and @base.
5823  * The caller must ensure that all links are frozen before using this
5824  * function.
5825  * @base must be reachable from @bs, or NULL.
5826  */
5827 void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base)
5828 {
5829     BlockDriverState *i;
5830     BdrvChild *child;
5831
5832     GLOBAL_STATE_CODE();
5833
5834     for (i = bs; i != base; i = child_bs(child)) {
5835         child = bdrv_filter_or_cow_child(i);
5836         if (child) {
5837             assert(child->frozen);
5838             child->frozen = false;
5839         }
5840     }
5841 }
5842
5843 /*
5844  * Drops images above 'base' up to and including 'top', and sets the image
5845  * above 'top' to have base as its backing file.
5846  *
5847  * Requires that the overlay to 'top' is opened r/w, so that the backing file
5848  * information in 'bs' can be properly updated.
5849  *
5850  * E.g., this will convert the following chain:
5851  * bottom <- base <- intermediate <- top <- active
5852  *
5853  * to
5854  *
5855  * bottom <- base <- active
5856  *
5857  * It is allowed for bottom==base, in which case it converts:
5858  *
5859  * base <- intermediate <- top <- active
5860  *
5861  * to
5862  *
5863  * base <- active
5864  *
5865  * If backing_file_str is non-NULL, it will be used when modifying top's
5866  * overlay image metadata.
5867  *
5868  * Error conditions:
5869  *  if active == top, that is considered an error
5870  *
5871  */
5872 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
5873                            const char *backing_file_str)
5874 {
5875     BlockDriverState *explicit_top = top;
5876     bool update_inherits_from;
5877     BdrvChild *c;
5878     Error *local_err = NULL;
5879     int ret = -EIO;
5880     g_autoptr(GSList) updated_children = NULL;
5881     GSList *p;
5882
5883     GLOBAL_STATE_CODE();
5884
5885     bdrv_ref(top);
5886     bdrv_drained_begin(base);
5887
5888     if (!top->drv || !base->drv) {
5889         goto exit;
5890     }
5891
5892     /* Make sure that base is in the backing chain of top */
5893     if (!bdrv_chain_contains(top, base)) {
5894         goto exit;
5895     }
5896
5897     /* If 'base' recursively inherits from 'top' then we should set
5898      * base->inherits_from to top->inherits_from after 'top' and all
5899      * other intermediate nodes have been dropped.
5900      * If 'top' is an implicit node (e.g. "commit_top") we should skip
5901      * it because no one inherits from it. We use explicit_top for that. */
5902     explicit_top = bdrv_skip_implicit_filters(explicit_top);
5903     update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top);
5904
5905     /* success - we can delete the intermediate states, and link top->base */
5906     if (!backing_file_str) {
5907         bdrv_refresh_filename(base);
5908         backing_file_str = base->filename;
5909     }
5910
5911     QLIST_FOREACH(c, &top->parents, next_parent) {
5912         updated_children = g_slist_prepend(updated_children, c);
5913     }
5914
5915     /*
5916      * It seems correct to pass detach_subchain=true here, but it triggers
5917      * one more yet not fixed bug, when due to nested aio_poll loop we switch to
5918      * another drained section, which modify the graph (for example, removing
5919      * the child, which we keep in updated_children list). So, it's a TODO.
5920      *
5921      * Note, bug triggered if pass detach_subchain=true here and run
5922      * test-bdrv-drain. test_drop_intermediate_poll() test-case will crash.
5923      * That's a FIXME.
5924      */
5925     bdrv_replace_node_common(top, base, false, false, &local_err);
5926     if (local_err) {
5927         error_report_err(local_err);
5928         goto exit;
5929     }
5930
5931     for (p = updated_children; p; p = p->next) {
5932         c = p->data;
5933
5934         if (c->klass->update_filename) {
5935             ret = c->klass->update_filename(c, base, backing_file_str,
5936                                             &local_err);
5937             if (ret < 0) {
5938                 /*
5939                  * TODO: Actually, we want to rollback all previous iterations
5940                  * of this loop, and (which is almost impossible) previous
5941                  * bdrv_replace_node()...
5942                  *
5943                  * Note, that c->klass->update_filename may lead to permission
5944                  * update, so it's a bad idea to call it inside permission
5945                  * update transaction of bdrv_replace_node.
5946                  */
5947                 error_report_err(local_err);
5948                 goto exit;
5949             }
5950         }
5951     }
5952
5953     if (update_inherits_from) {
5954         base->inherits_from = explicit_top->inherits_from;
5955     }
5956
5957     ret = 0;
5958 exit:
5959     bdrv_drained_end(base);
5960     bdrv_unref(top);
5961     return ret;
5962 }
5963
5964 /**
5965  * Implementation of BlockDriver.bdrv_co_get_allocated_file_size() that
5966  * sums the size of all data-bearing children.  (This excludes backing
5967  * children.)
5968  */
5969 static int64_t coroutine_fn GRAPH_RDLOCK
5970 bdrv_sum_allocated_file_size(BlockDriverState *bs)
5971 {
5972     BdrvChild *child;
5973     int64_t child_size, sum = 0;
5974
5975     QLIST_FOREACH(child, &bs->children, next) {
5976         if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
5977                            BDRV_CHILD_FILTERED))
5978         {
5979             child_size = bdrv_co_get_allocated_file_size(child->bs);
5980             if (child_size < 0) {
5981                 return child_size;
5982             }
5983             sum += child_size;
5984         }
5985     }
5986
5987     return sum;
5988 }
5989
5990 /**
5991  * Length of a allocated file in bytes. Sparse files are counted by actual
5992  * allocated space. Return < 0 if error or unknown.
5993  */
5994 int64_t coroutine_fn bdrv_co_get_allocated_file_size(BlockDriverState *bs)
5995 {
5996     BlockDriver *drv = bs->drv;
5997     IO_CODE();
5998     assert_bdrv_graph_readable();
5999
6000     if (!drv) {
6001         return -ENOMEDIUM;
6002     }
6003     if (drv->bdrv_co_get_allocated_file_size) {
6004         return drv->bdrv_co_get_allocated_file_size(bs);
6005     }
6006
6007     if (drv->bdrv_file_open) {
6008         /*
6009          * Protocol drivers default to -ENOTSUP (most of their data is
6010          * not stored in any of their children (if they even have any),
6011          * so there is no generic way to figure it out).
6012          */
6013         return -ENOTSUP;
6014     } else if (drv->is_filter) {
6015         /* Filter drivers default to the size of their filtered child */
6016         return bdrv_co_get_allocated_file_size(bdrv_filter_bs(bs));
6017     } else {
6018         /* Other drivers default to summing their children's sizes */
6019         return bdrv_sum_allocated_file_size(bs);
6020     }
6021 }
6022
6023 /*
6024  * bdrv_measure:
6025  * @drv: Format driver
6026  * @opts: Creation options for new image
6027  * @in_bs: Existing image containing data for new image (may be NULL)
6028  * @errp: Error object
6029  * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
6030  *          or NULL on error
6031  *
6032  * Calculate file size required to create a new image.
6033  *
6034  * If @in_bs is given then space for allocated clusters and zero clusters
6035  * from that image are included in the calculation.  If @opts contains a
6036  * backing file that is shared by @in_bs then backing clusters may be omitted
6037  * from the calculation.
6038  *
6039  * If @in_bs is NULL then the calculation includes no allocated clusters
6040  * unless a preallocation option is given in @opts.
6041  *
6042  * Note that @in_bs may use a different BlockDriver from @drv.
6043  *
6044  * If an error occurs the @errp pointer is set.
6045  */
6046 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
6047                                BlockDriverState *in_bs, Error **errp)
6048 {
6049     IO_CODE();
6050     if (!drv->bdrv_measure) {
6051         error_setg(errp, "Block driver '%s' does not support size measurement",
6052                    drv->format_name);
6053         return NULL;
6054     }
6055
6056     return drv->bdrv_measure(opts, in_bs, errp);
6057 }
6058
6059 /**
6060  * Return number of sectors on success, -errno on error.
6061  */
6062 int64_t coroutine_fn bdrv_co_nb_sectors(BlockDriverState *bs)
6063 {
6064     BlockDriver *drv = bs->drv;
6065     IO_CODE();
6066     assert_bdrv_graph_readable();
6067
6068     if (!drv)
6069         return -ENOMEDIUM;
6070
6071     if (bs->bl.has_variable_length) {
6072         int ret = bdrv_co_refresh_total_sectors(bs, bs->total_sectors);
6073         if (ret < 0) {
6074             return ret;
6075         }
6076     }
6077     return bs->total_sectors;
6078 }
6079
6080 /*
6081  * This wrapper is written by hand because this function is in the hot I/O path,
6082  * via blk_get_geometry.
6083  */
6084 int64_t coroutine_mixed_fn bdrv_nb_sectors(BlockDriverState *bs)
6085 {
6086     BlockDriver *drv = bs->drv;
6087     IO_CODE();
6088
6089     if (!drv)
6090         return -ENOMEDIUM;
6091
6092     if (bs->bl.has_variable_length) {
6093         int ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
6094         if (ret < 0) {
6095             return ret;
6096         }
6097     }
6098
6099     return bs->total_sectors;
6100 }
6101
6102 /**
6103  * Return length in bytes on success, -errno on error.
6104  * The length is always a multiple of BDRV_SECTOR_SIZE.
6105  */
6106 int64_t coroutine_fn bdrv_co_getlength(BlockDriverState *bs)
6107 {
6108     int64_t ret;
6109     IO_CODE();
6110     assert_bdrv_graph_readable();
6111
6112     ret = bdrv_co_nb_sectors(bs);
6113     if (ret < 0) {
6114         return ret;
6115     }
6116     if (ret > INT64_MAX / BDRV_SECTOR_SIZE) {
6117         return -EFBIG;
6118     }
6119     return ret * BDRV_SECTOR_SIZE;
6120 }
6121
6122 bool bdrv_is_sg(BlockDriverState *bs)
6123 {
6124     IO_CODE();
6125     return bs->sg;
6126 }
6127
6128 /**
6129  * Return whether the given node supports compressed writes.
6130  */
6131 bool bdrv_supports_compressed_writes(BlockDriverState *bs)
6132 {
6133     BlockDriverState *filtered;
6134     IO_CODE();
6135
6136     if (!bs->drv || !block_driver_can_compress(bs->drv)) {
6137         return false;
6138     }
6139
6140     filtered = bdrv_filter_bs(bs);
6141     if (filtered) {
6142         /*
6143          * Filters can only forward compressed writes, so we have to
6144          * check the child.
6145          */
6146         return bdrv_supports_compressed_writes(filtered);
6147     }
6148
6149     return true;
6150 }
6151
6152 const char *bdrv_get_format_name(BlockDriverState *bs)
6153 {
6154     IO_CODE();
6155     return bs->drv ? bs->drv->format_name : NULL;
6156 }
6157
6158 static int qsort_strcmp(const void *a, const void *b)
6159 {
6160     return strcmp(*(char *const *)a, *(char *const *)b);
6161 }
6162
6163 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
6164                          void *opaque, bool read_only)
6165 {
6166     BlockDriver *drv;
6167     int count = 0;
6168     int i;
6169     const char **formats = NULL;
6170
6171     GLOBAL_STATE_CODE();
6172
6173     QLIST_FOREACH(drv, &bdrv_drivers, list) {
6174         if (drv->format_name) {
6175             bool found = false;
6176             int i = count;
6177
6178             if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) {
6179                 continue;
6180             }
6181
6182             while (formats && i && !found) {
6183                 found = !strcmp(formats[--i], drv->format_name);
6184             }
6185
6186             if (!found) {
6187                 formats = g_renew(const char *, formats, count + 1);
6188                 formats[count++] = drv->format_name;
6189             }
6190         }
6191     }
6192
6193     for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
6194         const char *format_name = block_driver_modules[i].format_name;
6195
6196         if (format_name) {
6197             bool found = false;
6198             int j = count;
6199
6200             if (use_bdrv_whitelist &&
6201                 !bdrv_format_is_whitelisted(format_name, read_only)) {
6202                 continue;
6203             }
6204
6205             while (formats && j && !found) {
6206                 found = !strcmp(formats[--j], format_name);
6207             }
6208
6209             if (!found) {
6210                 formats = g_renew(const char *, formats, count + 1);
6211                 formats[count++] = format_name;
6212             }
6213         }
6214     }
6215
6216     qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
6217
6218     for (i = 0; i < count; i++) {
6219         it(opaque, formats[i]);
6220     }
6221
6222     g_free(formats);
6223 }
6224
6225 /* This function is to find a node in the bs graph */
6226 BlockDriverState *bdrv_find_node(const char *node_name)
6227 {
6228     BlockDriverState *bs;
6229
6230     assert(node_name);
6231     GLOBAL_STATE_CODE();
6232
6233     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
6234         if (!strcmp(node_name, bs->node_name)) {
6235             return bs;
6236         }
6237     }
6238     return NULL;
6239 }
6240
6241 /* Put this QMP function here so it can access the static graph_bdrv_states. */
6242 BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
6243                                            Error **errp)
6244 {
6245     BlockDeviceInfoList *list;
6246     BlockDriverState *bs;
6247
6248     GLOBAL_STATE_CODE();
6249
6250     list = NULL;
6251     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
6252         BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
6253         if (!info) {
6254             qapi_free_BlockDeviceInfoList(list);
6255             return NULL;
6256         }
6257         QAPI_LIST_PREPEND(list, info);
6258     }
6259
6260     return list;
6261 }
6262
6263 typedef struct XDbgBlockGraphConstructor {
6264     XDbgBlockGraph *graph;
6265     GHashTable *graph_nodes;
6266 } XDbgBlockGraphConstructor;
6267
6268 static XDbgBlockGraphConstructor *xdbg_graph_new(void)
6269 {
6270     XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1);
6271
6272     gr->graph = g_new0(XDbgBlockGraph, 1);
6273     gr->graph_nodes = g_hash_table_new(NULL, NULL);
6274
6275     return gr;
6276 }
6277
6278 static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr)
6279 {
6280     XDbgBlockGraph *graph = gr->graph;
6281
6282     g_hash_table_destroy(gr->graph_nodes);
6283     g_free(gr);
6284
6285     return graph;
6286 }
6287
6288 static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node)
6289 {
6290     uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node);
6291
6292     if (ret != 0) {
6293         return ret;
6294     }
6295
6296     /*
6297      * Start counting from 1, not 0, because 0 interferes with not-found (NULL)
6298      * answer of g_hash_table_lookup.
6299      */
6300     ret = g_hash_table_size(gr->graph_nodes) + 1;
6301     g_hash_table_insert(gr->graph_nodes, node, (void *)ret);
6302
6303     return ret;
6304 }
6305
6306 static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node,
6307                                 XDbgBlockGraphNodeType type, const char *name)
6308 {
6309     XDbgBlockGraphNode *n;
6310
6311     n = g_new0(XDbgBlockGraphNode, 1);
6312
6313     n->id = xdbg_graph_node_num(gr, node);
6314     n->type = type;
6315     n->name = g_strdup(name);
6316
6317     QAPI_LIST_PREPEND(gr->graph->nodes, n);
6318 }
6319
6320 static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent,
6321                                 const BdrvChild *child)
6322 {
6323     BlockPermission qapi_perm;
6324     XDbgBlockGraphEdge *edge;
6325     GLOBAL_STATE_CODE();
6326
6327     edge = g_new0(XDbgBlockGraphEdge, 1);
6328
6329     edge->parent = xdbg_graph_node_num(gr, parent);
6330     edge->child = xdbg_graph_node_num(gr, child->bs);
6331     edge->name = g_strdup(child->name);
6332
6333     for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) {
6334         uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm);
6335
6336         if (flag & child->perm) {
6337             QAPI_LIST_PREPEND(edge->perm, qapi_perm);
6338         }
6339         if (flag & child->shared_perm) {
6340             QAPI_LIST_PREPEND(edge->shared_perm, qapi_perm);
6341         }
6342     }
6343
6344     QAPI_LIST_PREPEND(gr->graph->edges, edge);
6345 }
6346
6347
6348 XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp)
6349 {
6350     BlockBackend *blk;
6351     BlockJob *job;
6352     BlockDriverState *bs;
6353     BdrvChild *child;
6354     XDbgBlockGraphConstructor *gr = xdbg_graph_new();
6355
6356     GLOBAL_STATE_CODE();
6357
6358     for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {
6359         char *allocated_name = NULL;
6360         const char *name = blk_name(blk);
6361
6362         if (!*name) {
6363             name = allocated_name = blk_get_attached_dev_id(blk);
6364         }
6365         xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
6366                            name);
6367         g_free(allocated_name);
6368         if (blk_root(blk)) {
6369             xdbg_graph_add_edge(gr, blk, blk_root(blk));
6370         }
6371     }
6372
6373     WITH_JOB_LOCK_GUARD() {
6374         for (job = block_job_next_locked(NULL); job;
6375              job = block_job_next_locked(job)) {
6376             GSList *el;
6377
6378             xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
6379                                 job->job.id);
6380             for (el = job->nodes; el; el = el->next) {
6381                 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data);
6382             }
6383         }
6384     }
6385
6386     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
6387         xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
6388                            bs->node_name);
6389         QLIST_FOREACH(child, &bs->children, next) {
6390             xdbg_graph_add_edge(gr, bs, child);
6391         }
6392     }
6393
6394     return xdbg_graph_finalize(gr);
6395 }
6396
6397 BlockDriverState *bdrv_lookup_bs(const char *device,
6398                                  const char *node_name,
6399                                  Error **errp)
6400 {
6401     BlockBackend *blk;
6402     BlockDriverState *bs;
6403
6404     GLOBAL_STATE_CODE();
6405
6406     if (device) {
6407         blk = blk_by_name(device);
6408
6409         if (blk) {
6410             bs = blk_bs(blk);
6411             if (!bs) {
6412                 error_setg(errp, "Device '%s' has no medium", device);
6413             }
6414
6415             return bs;
6416         }
6417     }
6418
6419     if (node_name) {
6420         bs = bdrv_find_node(node_name);
6421
6422         if (bs) {
6423             return bs;
6424         }
6425     }
6426
6427     error_setg(errp, "Cannot find device=\'%s\' nor node-name=\'%s\'",
6428                      device ? device : "",
6429                      node_name ? node_name : "");
6430     return NULL;
6431 }
6432
6433 /* If 'base' is in the same chain as 'top', return true. Otherwise,
6434  * return false.  If either argument is NULL, return false. */
6435 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
6436 {
6437
6438     GLOBAL_STATE_CODE();
6439
6440     while (top && top != base) {
6441         top = bdrv_filter_or_cow_bs(top);
6442     }
6443
6444     return top != NULL;
6445 }
6446
6447 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
6448 {
6449     GLOBAL_STATE_CODE();
6450     if (!bs) {
6451         return QTAILQ_FIRST(&graph_bdrv_states);
6452     }
6453     return QTAILQ_NEXT(bs, node_list);
6454 }
6455
6456 BlockDriverState *bdrv_next_all_states(BlockDriverState *bs)
6457 {
6458     GLOBAL_STATE_CODE();
6459     if (!bs) {
6460         return QTAILQ_FIRST(&all_bdrv_states);
6461     }
6462     return QTAILQ_NEXT(bs, bs_list);
6463 }
6464
6465 const char *bdrv_get_node_name(const BlockDriverState *bs)
6466 {
6467     IO_CODE();
6468     return bs->node_name;
6469 }
6470
6471 const char *bdrv_get_parent_name(const BlockDriverState *bs)
6472 {
6473     BdrvChild *c;
6474     const char *name;
6475     IO_CODE();
6476
6477     /* If multiple parents have a name, just pick the first one. */
6478     QLIST_FOREACH(c, &bs->parents, next_parent) {
6479         if (c->klass->get_name) {
6480             name = c->klass->get_name(c);
6481             if (name && *name) {
6482                 return name;
6483             }
6484         }
6485     }
6486
6487     return NULL;
6488 }
6489
6490 /* TODO check what callers really want: bs->node_name or blk_name() */
6491 const char *bdrv_get_device_name(const BlockDriverState *bs)
6492 {
6493     IO_CODE();
6494     return bdrv_get_parent_name(bs) ?: "";
6495 }
6496
6497 /* This can be used to identify nodes that might not have a device
6498  * name associated. Since node and device names live in the same
6499  * namespace, the result is unambiguous. The exception is if both are
6500  * absent, then this returns an empty (non-null) string. */
6501 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
6502 {
6503     IO_CODE();
6504     return bdrv_get_parent_name(bs) ?: bs->node_name;
6505 }
6506
6507 int bdrv_get_flags(BlockDriverState *bs)
6508 {
6509     IO_CODE();
6510     return bs->open_flags;
6511 }
6512
6513 int bdrv_has_zero_init_1(BlockDriverState *bs)
6514 {
6515     GLOBAL_STATE_CODE();
6516     return 1;
6517 }
6518
6519 int bdrv_has_zero_init(BlockDriverState *bs)
6520 {
6521     BlockDriverState *filtered;
6522     GLOBAL_STATE_CODE();
6523
6524     if (!bs->drv) {
6525         return 0;
6526     }
6527
6528     /* If BS is a copy on write image, it is initialized to
6529        the contents of the base image, which may not be zeroes.  */
6530     if (bdrv_cow_child(bs)) {
6531         return 0;
6532     }
6533     if (bs->drv->bdrv_has_zero_init) {
6534         return bs->drv->bdrv_has_zero_init(bs);
6535     }
6536
6537     filtered = bdrv_filter_bs(bs);
6538     if (filtered) {
6539         return bdrv_has_zero_init(filtered);
6540     }
6541
6542     /* safe default */
6543     return 0;
6544 }
6545
6546 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
6547 {
6548     IO_CODE();
6549     if (!(bs->open_flags & BDRV_O_UNMAP)) {
6550         return false;
6551     }
6552
6553     return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP;
6554 }
6555
6556 void bdrv_get_backing_filename(BlockDriverState *bs,
6557                                char *filename, int filename_size)
6558 {
6559     IO_CODE();
6560     pstrcpy(filename, filename_size, bs->backing_file);
6561 }
6562
6563 int coroutine_fn bdrv_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
6564 {
6565     int ret;
6566     BlockDriver *drv = bs->drv;
6567     IO_CODE();
6568     assert_bdrv_graph_readable();
6569
6570     /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
6571     if (!drv) {
6572         return -ENOMEDIUM;
6573     }
6574     if (!drv->bdrv_co_get_info) {
6575         BlockDriverState *filtered = bdrv_filter_bs(bs);
6576         if (filtered) {
6577             return bdrv_co_get_info(filtered, bdi);
6578         }
6579         return -ENOTSUP;
6580     }
6581     memset(bdi, 0, sizeof(*bdi));
6582     ret = drv->bdrv_co_get_info(bs, bdi);
6583     if (bdi->subcluster_size == 0) {
6584         /*
6585          * If the driver left this unset, subclusters are not supported.
6586          * Then it is safe to treat each cluster as having only one subcluster.
6587          */
6588         bdi->subcluster_size = bdi->cluster_size;
6589     }
6590     if (ret < 0) {
6591         return ret;
6592     }
6593
6594     if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) {
6595         return -EINVAL;
6596     }
6597
6598     return 0;
6599 }
6600
6601 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs,
6602                                           Error **errp)
6603 {
6604     BlockDriver *drv = bs->drv;
6605     IO_CODE();
6606     if (drv && drv->bdrv_get_specific_info) {
6607         return drv->bdrv_get_specific_info(bs, errp);
6608     }
6609     return NULL;
6610 }
6611
6612 BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs)
6613 {
6614     BlockDriver *drv = bs->drv;
6615     IO_CODE();
6616     if (!drv || !drv->bdrv_get_specific_stats) {
6617         return NULL;
6618     }
6619     return drv->bdrv_get_specific_stats(bs);
6620 }
6621
6622 void coroutine_fn bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event)
6623 {
6624     IO_CODE();
6625     assert_bdrv_graph_readable();
6626
6627     if (!bs || !bs->drv || !bs->drv->bdrv_co_debug_event) {
6628         return;
6629     }
6630
6631     bs->drv->bdrv_co_debug_event(bs, event);
6632 }
6633
6634 static BlockDriverState *bdrv_find_debug_node(BlockDriverState *bs)
6635 {
6636     GLOBAL_STATE_CODE();
6637     while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
6638         bs = bdrv_primary_bs(bs);
6639     }
6640
6641     if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
6642         assert(bs->drv->bdrv_debug_remove_breakpoint);
6643         return bs;
6644     }
6645
6646     return NULL;
6647 }
6648
6649 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
6650                           const char *tag)
6651 {
6652     GLOBAL_STATE_CODE();
6653     bs = bdrv_find_debug_node(bs);
6654     if (bs) {
6655         return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
6656     }
6657
6658     return -ENOTSUP;
6659 }
6660
6661 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
6662 {
6663     GLOBAL_STATE_CODE();
6664     bs = bdrv_find_debug_node(bs);
6665     if (bs) {
6666         return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
6667     }
6668
6669     return -ENOTSUP;
6670 }
6671
6672 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
6673 {
6674     GLOBAL_STATE_CODE();
6675     while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
6676         bs = bdrv_primary_bs(bs);
6677     }
6678
6679     if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
6680         return bs->drv->bdrv_debug_resume(bs, tag);
6681     }
6682
6683     return -ENOTSUP;
6684 }
6685
6686 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
6687 {
6688     GLOBAL_STATE_CODE();
6689     while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
6690         bs = bdrv_primary_bs(bs);
6691     }
6692
6693     if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
6694         return bs->drv->bdrv_debug_is_suspended(bs, tag);
6695     }
6696
6697     return false;
6698 }
6699
6700 /* backing_file can either be relative, or absolute, or a protocol.  If it is
6701  * relative, it must be relative to the chain.  So, passing in bs->filename
6702  * from a BDS as backing_file should not be done, as that may be relative to
6703  * the CWD rather than the chain. */
6704 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
6705         const char *backing_file)
6706 {
6707     char *filename_full = NULL;
6708     char *backing_file_full = NULL;
6709     char *filename_tmp = NULL;
6710     int is_protocol = 0;
6711     bool filenames_refreshed = false;
6712     BlockDriverState *curr_bs = NULL;
6713     BlockDriverState *retval = NULL;
6714     BlockDriverState *bs_below;
6715
6716     GLOBAL_STATE_CODE();
6717
6718     if (!bs || !bs->drv || !backing_file) {
6719         return NULL;
6720     }
6721
6722     filename_full     = g_malloc(PATH_MAX);
6723     backing_file_full = g_malloc(PATH_MAX);
6724
6725     is_protocol = path_has_protocol(backing_file);
6726
6727     /*
6728      * Being largely a legacy function, skip any filters here
6729      * (because filters do not have normal filenames, so they cannot
6730      * match anyway; and allowing json:{} filenames is a bit out of
6731      * scope).
6732      */
6733     for (curr_bs = bdrv_skip_filters(bs);
6734          bdrv_cow_child(curr_bs) != NULL;
6735          curr_bs = bs_below)
6736     {
6737         bs_below = bdrv_backing_chain_next(curr_bs);
6738
6739         if (bdrv_backing_overridden(curr_bs)) {
6740             /*
6741              * If the backing file was overridden, we can only compare
6742              * directly against the backing node's filename.
6743              */
6744
6745             if (!filenames_refreshed) {
6746                 /*
6747                  * This will automatically refresh all of the
6748                  * filenames in the rest of the backing chain, so we
6749                  * only need to do this once.
6750                  */
6751                 bdrv_refresh_filename(bs_below);
6752                 filenames_refreshed = true;
6753             }
6754
6755             if (strcmp(backing_file, bs_below->filename) == 0) {
6756                 retval = bs_below;
6757                 break;
6758             }
6759         } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
6760             /*
6761              * If either of the filename paths is actually a protocol, then
6762              * compare unmodified paths; otherwise make paths relative.
6763              */
6764             char *backing_file_full_ret;
6765
6766             if (strcmp(backing_file, curr_bs->backing_file) == 0) {
6767                 retval = bs_below;
6768                 break;
6769             }
6770             /* Also check against the full backing filename for the image */
6771             backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs,
6772                                                                    NULL);
6773             if (backing_file_full_ret) {
6774                 bool equal = strcmp(backing_file, backing_file_full_ret) == 0;
6775                 g_free(backing_file_full_ret);
6776                 if (equal) {
6777                     retval = bs_below;
6778                     break;
6779                 }
6780             }
6781         } else {
6782             /* If not an absolute filename path, make it relative to the current
6783              * image's filename path */
6784             filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file,
6785                                                        NULL);
6786             /* We are going to compare canonicalized absolute pathnames */
6787             if (!filename_tmp || !realpath(filename_tmp, filename_full)) {
6788                 g_free(filename_tmp);
6789                 continue;
6790             }
6791             g_free(filename_tmp);
6792
6793             /* We need to make sure the backing filename we are comparing against
6794              * is relative to the current image filename (or absolute) */
6795             filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL);
6796             if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) {
6797                 g_free(filename_tmp);
6798                 continue;
6799             }
6800             g_free(filename_tmp);
6801
6802             if (strcmp(backing_file_full, filename_full) == 0) {
6803                 retval = bs_below;
6804                 break;
6805             }
6806         }
6807     }
6808
6809     g_free(filename_full);
6810     g_free(backing_file_full);
6811     return retval;
6812 }
6813
6814 void bdrv_init(void)
6815 {
6816 #ifdef CONFIG_BDRV_WHITELIST_TOOLS
6817     use_bdrv_whitelist = 1;
6818 #endif
6819     module_call_init(MODULE_INIT_BLOCK);
6820 }
6821
6822 void bdrv_init_with_whitelist(void)
6823 {
6824     use_bdrv_whitelist = 1;
6825     bdrv_init();
6826 }
6827
6828 int bdrv_activate(BlockDriverState *bs, Error **errp)
6829 {
6830     BdrvChild *child, *parent;
6831     Error *local_err = NULL;
6832     int ret;
6833     BdrvDirtyBitmap *bm;
6834
6835     GLOBAL_STATE_CODE();
6836
6837     if (!bs->drv)  {
6838         return -ENOMEDIUM;
6839     }
6840
6841     QLIST_FOREACH(child, &bs->children, next) {
6842         bdrv_activate(child->bs, &local_err);
6843         if (local_err) {
6844             error_propagate(errp, local_err);
6845             return -EINVAL;
6846         }
6847     }
6848
6849     /*
6850      * Update permissions, they may differ for inactive nodes.
6851      *
6852      * Note that the required permissions of inactive images are always a
6853      * subset of the permissions required after activating the image. This
6854      * allows us to just get the permissions upfront without restricting
6855      * bdrv_co_invalidate_cache().
6856      *
6857      * It also means that in error cases, we don't have to try and revert to
6858      * the old permissions (which is an operation that could fail, too). We can
6859      * just keep the extended permissions for the next time that an activation
6860      * of the image is tried.
6861      */
6862     if (bs->open_flags & BDRV_O_INACTIVE) {
6863         bs->open_flags &= ~BDRV_O_INACTIVE;
6864         ret = bdrv_refresh_perms(bs, NULL, errp);
6865         if (ret < 0) {
6866             bs->open_flags |= BDRV_O_INACTIVE;
6867             return ret;
6868         }
6869
6870         ret = bdrv_invalidate_cache(bs, errp);
6871         if (ret < 0) {
6872             bs->open_flags |= BDRV_O_INACTIVE;
6873             return ret;
6874         }
6875
6876         FOR_EACH_DIRTY_BITMAP(bs, bm) {
6877             bdrv_dirty_bitmap_skip_store(bm, false);
6878         }
6879
6880         ret = bdrv_refresh_total_sectors(bs, bs->total_sectors);
6881         if (ret < 0) {
6882             bs->open_flags |= BDRV_O_INACTIVE;
6883             error_setg_errno(errp, -ret, "Could not refresh total sector count");
6884             return ret;
6885         }
6886     }
6887
6888     QLIST_FOREACH(parent, &bs->parents, next_parent) {
6889         if (parent->klass->activate) {
6890             parent->klass->activate(parent, &local_err);
6891             if (local_err) {
6892                 bs->open_flags |= BDRV_O_INACTIVE;
6893                 error_propagate(errp, local_err);
6894                 return -EINVAL;
6895             }
6896         }
6897     }
6898
6899     return 0;
6900 }
6901
6902 int coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp)
6903 {
6904     Error *local_err = NULL;
6905     IO_CODE();
6906
6907     assert(!(bs->open_flags & BDRV_O_INACTIVE));
6908     assert_bdrv_graph_readable();
6909
6910     if (bs->drv->bdrv_co_invalidate_cache) {
6911         bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
6912         if (local_err) {
6913             error_propagate(errp, local_err);
6914             return -EINVAL;
6915         }
6916     }
6917
6918     return 0;
6919 }
6920
6921 void bdrv_activate_all(Error **errp)
6922 {
6923     BlockDriverState *bs;
6924     BdrvNextIterator it;
6925
6926     GLOBAL_STATE_CODE();
6927
6928     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
6929         AioContext *aio_context = bdrv_get_aio_context(bs);
6930         int ret;
6931
6932         aio_context_acquire(aio_context);
6933         ret = bdrv_activate(bs, errp);
6934         aio_context_release(aio_context);
6935         if (ret < 0) {
6936             bdrv_next_cleanup(&it);
6937             return;
6938         }
6939     }
6940 }
6941
6942 static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
6943 {
6944     BdrvChild *parent;
6945     GLOBAL_STATE_CODE();
6946
6947     QLIST_FOREACH(parent, &bs->parents, next_parent) {
6948         if (parent->klass->parent_is_bds) {
6949             BlockDriverState *parent_bs = parent->opaque;
6950             if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) {
6951                 return true;
6952             }
6953         }
6954     }
6955
6956     return false;
6957 }
6958
6959 static int bdrv_inactivate_recurse(BlockDriverState *bs)
6960 {
6961     BdrvChild *child, *parent;
6962     int ret;
6963     uint64_t cumulative_perms, cumulative_shared_perms;
6964
6965     GLOBAL_STATE_CODE();
6966
6967     if (!bs->drv) {
6968         return -ENOMEDIUM;
6969     }
6970
6971     /* Make sure that we don't inactivate a child before its parent.
6972      * It will be covered by recursion from the yet active parent. */
6973     if (bdrv_has_bds_parent(bs, true)) {
6974         return 0;
6975     }
6976
6977     assert(!(bs->open_flags & BDRV_O_INACTIVE));
6978
6979     /* Inactivate this node */
6980     if (bs->drv->bdrv_inactivate) {
6981         ret = bs->drv->bdrv_inactivate(bs);
6982         if (ret < 0) {
6983             return ret;
6984         }
6985     }
6986
6987     QLIST_FOREACH(parent, &bs->parents, next_parent) {
6988         if (parent->klass->inactivate) {
6989             ret = parent->klass->inactivate(parent);
6990             if (ret < 0) {
6991                 return ret;
6992             }
6993         }
6994     }
6995
6996     bdrv_get_cumulative_perm(bs, &cumulative_perms,
6997                              &cumulative_shared_perms);
6998     if (cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) {
6999         /* Our inactive parents still need write access. Inactivation failed. */
7000         return -EPERM;
7001     }
7002
7003     bs->open_flags |= BDRV_O_INACTIVE;
7004
7005     /*
7006      * Update permissions, they may differ for inactive nodes.
7007      * We only tried to loosen restrictions, so errors are not fatal, ignore
7008      * them.
7009      */
7010     bdrv_refresh_perms(bs, NULL, NULL);
7011
7012     /* Recursively inactivate children */
7013     QLIST_FOREACH(child, &bs->children, next) {
7014         ret = bdrv_inactivate_recurse(child->bs);
7015         if (ret < 0) {
7016             return ret;
7017         }
7018     }
7019
7020     return 0;
7021 }
7022
7023 int bdrv_inactivate_all(void)
7024 {
7025     BlockDriverState *bs = NULL;
7026     BdrvNextIterator it;
7027     int ret = 0;
7028     GSList *aio_ctxs = NULL, *ctx;
7029
7030     GLOBAL_STATE_CODE();
7031
7032     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
7033         AioContext *aio_context = bdrv_get_aio_context(bs);
7034
7035         if (!g_slist_find(aio_ctxs, aio_context)) {
7036             aio_ctxs = g_slist_prepend(aio_ctxs, aio_context);
7037             aio_context_acquire(aio_context);
7038         }
7039     }
7040
7041     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
7042         /* Nodes with BDS parents are covered by recursion from the last
7043          * parent that gets inactivated. Don't inactivate them a second
7044          * time if that has already happened. */
7045         if (bdrv_has_bds_parent(bs, false)) {
7046             continue;
7047         }
7048         ret = bdrv_inactivate_recurse(bs);
7049         if (ret < 0) {
7050             bdrv_next_cleanup(&it);
7051             goto out;
7052         }
7053     }
7054
7055 out:
7056     for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) {
7057         AioContext *aio_context = ctx->data;
7058         aio_context_release(aio_context);
7059     }
7060     g_slist_free(aio_ctxs);
7061
7062     return ret;
7063 }
7064
7065 /**************************************************************/
7066 /* removable device support */
7067
7068 /**
7069  * Return TRUE if the media is present
7070  */
7071 bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs)
7072 {
7073     BlockDriver *drv = bs->drv;
7074     BdrvChild *child;
7075     IO_CODE();
7076     assert_bdrv_graph_readable();
7077
7078     if (!drv) {
7079         return false;
7080     }
7081     if (drv->bdrv_co_is_inserted) {
7082         return drv->bdrv_co_is_inserted(bs);
7083     }
7084     QLIST_FOREACH(child, &bs->children, next) {
7085         if (!bdrv_co_is_inserted(child->bs)) {
7086             return false;
7087         }
7088     }
7089     return true;
7090 }
7091
7092 /**
7093  * If eject_flag is TRUE, eject the media. Otherwise, close the tray
7094  */
7095 void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag)
7096 {
7097     BlockDriver *drv = bs->drv;
7098     IO_CODE();
7099     assert_bdrv_graph_readable();
7100
7101     if (drv && drv->bdrv_co_eject) {
7102         drv->bdrv_co_eject(bs, eject_flag);
7103     }
7104 }
7105
7106 /**
7107  * Lock or unlock the media (if it is locked, the user won't be able
7108  * to eject it manually).
7109  */
7110 void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked)
7111 {
7112     BlockDriver *drv = bs->drv;
7113     IO_CODE();
7114     assert_bdrv_graph_readable();
7115     trace_bdrv_lock_medium(bs, locked);
7116
7117     if (drv && drv->bdrv_co_lock_medium) {
7118         drv->bdrv_co_lock_medium(bs, locked);
7119     }
7120 }
7121
7122 /* Get a reference to bs */
7123 void bdrv_ref(BlockDriverState *bs)
7124 {
7125     GLOBAL_STATE_CODE();
7126     bs->refcnt++;
7127 }
7128
7129 /* Release a previously grabbed reference to bs.
7130  * If after releasing, reference count is zero, the BlockDriverState is
7131  * deleted. */
7132 void bdrv_unref(BlockDriverState *bs)
7133 {
7134     GLOBAL_STATE_CODE();
7135     if (!bs) {
7136         return;
7137     }
7138     assert(bs->refcnt > 0);
7139     if (--bs->refcnt == 0) {
7140         bdrv_delete(bs);
7141     }
7142 }
7143
7144 /*
7145  * Release a BlockDriverState reference while holding the graph write lock.
7146  *
7147  * Calling bdrv_unref() directly is forbidden while holding the graph lock
7148  * because bdrv_close() both involves polling and taking the graph lock
7149  * internally. bdrv_schedule_unref() instead delays decreasing the refcount and
7150  * possibly closing @bs until the graph lock is released.
7151  */
7152 void bdrv_schedule_unref(BlockDriverState *bs)
7153 {
7154     if (!bs) {
7155         return;
7156     }
7157     aio_bh_schedule_oneshot(qemu_get_aio_context(),
7158                             (QEMUBHFunc *) bdrv_unref, bs);
7159 }
7160
7161 struct BdrvOpBlocker {
7162     Error *reason;
7163     QLIST_ENTRY(BdrvOpBlocker) list;
7164 };
7165
7166 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
7167 {
7168     BdrvOpBlocker *blocker;
7169     GLOBAL_STATE_CODE();
7170     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7171     if (!QLIST_EMPTY(&bs->op_blockers[op])) {
7172         blocker = QLIST_FIRST(&bs->op_blockers[op]);
7173         error_propagate_prepend(errp, error_copy(blocker->reason),
7174                                 "Node '%s' is busy: ",
7175                                 bdrv_get_device_or_node_name(bs));
7176         return true;
7177     }
7178     return false;
7179 }
7180
7181 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
7182 {
7183     BdrvOpBlocker *blocker;
7184     GLOBAL_STATE_CODE();
7185     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7186
7187     blocker = g_new0(BdrvOpBlocker, 1);
7188     blocker->reason = reason;
7189     QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
7190 }
7191
7192 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
7193 {
7194     BdrvOpBlocker *blocker, *next;
7195     GLOBAL_STATE_CODE();
7196     assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
7197     QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
7198         if (blocker->reason == reason) {
7199             QLIST_REMOVE(blocker, list);
7200             g_free(blocker);
7201         }
7202     }
7203 }
7204
7205 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
7206 {
7207     int i;
7208     GLOBAL_STATE_CODE();
7209     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7210         bdrv_op_block(bs, i, reason);
7211     }
7212 }
7213
7214 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
7215 {
7216     int i;
7217     GLOBAL_STATE_CODE();
7218     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7219         bdrv_op_unblock(bs, i, reason);
7220     }
7221 }
7222
7223 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
7224 {
7225     int i;
7226     GLOBAL_STATE_CODE();
7227     for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
7228         if (!QLIST_EMPTY(&bs->op_blockers[i])) {
7229             return false;
7230         }
7231     }
7232     return true;
7233 }
7234
7235 /*
7236  * Must not be called while holding the lock of an AioContext other than the
7237  * current one.
7238  */
7239 void bdrv_img_create(const char *filename, const char *fmt,
7240                      const char *base_filename, const char *base_fmt,
7241                      char *options, uint64_t img_size, int flags, bool quiet,
7242                      Error **errp)
7243 {
7244     QemuOptsList *create_opts = NULL;
7245     QemuOpts *opts = NULL;
7246     const char *backing_fmt, *backing_file;
7247     int64_t size;
7248     BlockDriver *drv, *proto_drv;
7249     Error *local_err = NULL;
7250     int ret = 0;
7251
7252     GLOBAL_STATE_CODE();
7253
7254     /* Find driver and parse its options */
7255     drv = bdrv_find_format(fmt);
7256     if (!drv) {
7257         error_setg(errp, "Unknown file format '%s'", fmt);
7258         return;
7259     }
7260
7261     proto_drv = bdrv_find_protocol(filename, true, errp);
7262     if (!proto_drv) {
7263         return;
7264     }
7265
7266     if (!drv->create_opts) {
7267         error_setg(errp, "Format driver '%s' does not support image creation",
7268                    drv->format_name);
7269         return;
7270     }
7271
7272     if (!proto_drv->create_opts) {
7273         error_setg(errp, "Protocol driver '%s' does not support image creation",
7274                    proto_drv->format_name);
7275         return;
7276     }
7277
7278     aio_context_acquire(qemu_get_aio_context());
7279
7280     /* Create parameter list */
7281     create_opts = qemu_opts_append(create_opts, drv->create_opts);
7282     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
7283
7284     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
7285
7286     /* Parse -o options */
7287     if (options) {
7288         if (!qemu_opts_do_parse(opts, options, NULL, errp)) {
7289             goto out;
7290         }
7291     }
7292
7293     if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
7294         qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
7295     } else if (img_size != UINT64_C(-1)) {
7296         error_setg(errp, "The image size must be specified only once");
7297         goto out;
7298     }
7299
7300     if (base_filename) {
7301         if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename,
7302                           NULL)) {
7303             error_setg(errp, "Backing file not supported for file format '%s'",
7304                        fmt);
7305             goto out;
7306         }
7307     }
7308
7309     if (base_fmt) {
7310         if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, NULL)) {
7311             error_setg(errp, "Backing file format not supported for file "
7312                              "format '%s'", fmt);
7313             goto out;
7314         }
7315     }
7316
7317     backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
7318     if (backing_file) {
7319         if (!strcmp(filename, backing_file)) {
7320             error_setg(errp, "Error: Trying to create an image with the "
7321                              "same filename as the backing file");
7322             goto out;
7323         }
7324         if (backing_file[0] == '\0') {
7325             error_setg(errp, "Expected backing file name, got empty string");
7326             goto out;
7327         }
7328     }
7329
7330     backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
7331
7332     /* The size for the image must always be specified, unless we have a backing
7333      * file and we have not been forbidden from opening it. */
7334     size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
7335     if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
7336         BlockDriverState *bs;
7337         char *full_backing;
7338         int back_flags;
7339         QDict *backing_options = NULL;
7340
7341         full_backing =
7342             bdrv_get_full_backing_filename_from_filename(filename, backing_file,
7343                                                          &local_err);
7344         if (local_err) {
7345             goto out;
7346         }
7347         assert(full_backing);
7348
7349         /*
7350          * No need to do I/O here, which allows us to open encrypted
7351          * backing images without needing the secret
7352          */
7353         back_flags = flags;
7354         back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
7355         back_flags |= BDRV_O_NO_IO;
7356
7357         backing_options = qdict_new();
7358         if (backing_fmt) {
7359             qdict_put_str(backing_options, "driver", backing_fmt);
7360         }
7361         qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
7362
7363         bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
7364                        &local_err);
7365         g_free(full_backing);
7366         if (!bs) {
7367             error_append_hint(&local_err, "Could not open backing image.\n");
7368             goto out;
7369         } else {
7370             if (!backing_fmt) {
7371                 error_setg(&local_err,
7372                            "Backing file specified without backing format");
7373                 error_append_hint(&local_err, "Detected format of %s.\n",
7374                                   bs->drv->format_name);
7375                 goto out;
7376             }
7377             if (size == -1) {
7378                 /* Opened BS, have no size */
7379                 size = bdrv_getlength(bs);
7380                 if (size < 0) {
7381                     error_setg_errno(errp, -size, "Could not get size of '%s'",
7382                                      backing_file);
7383                     bdrv_unref(bs);
7384                     goto out;
7385                 }
7386                 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
7387             }
7388             bdrv_unref(bs);
7389         }
7390         /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
7391     } else if (backing_file && !backing_fmt) {
7392         error_setg(&local_err,
7393                    "Backing file specified without backing format");
7394         goto out;
7395     }
7396
7397     if (size == -1) {
7398         error_setg(errp, "Image creation needs a size parameter");
7399         goto out;
7400     }
7401
7402     if (!quiet) {
7403         printf("Formatting '%s', fmt=%s ", filename, fmt);
7404         qemu_opts_print(opts, " ");
7405         puts("");
7406         fflush(stdout);
7407     }
7408
7409     ret = bdrv_create(drv, filename, opts, &local_err);
7410
7411     if (ret == -EFBIG) {
7412         /* This is generally a better message than whatever the driver would
7413          * deliver (especially because of the cluster_size_hint), since that
7414          * is most probably not much different from "image too large". */
7415         const char *cluster_size_hint = "";
7416         if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
7417             cluster_size_hint = " (try using a larger cluster size)";
7418         }
7419         error_setg(errp, "The image size is too large for file format '%s'"
7420                    "%s", fmt, cluster_size_hint);
7421         error_free(local_err);
7422         local_err = NULL;
7423     }
7424
7425 out:
7426     qemu_opts_del(opts);
7427     qemu_opts_free(create_opts);
7428     error_propagate(errp, local_err);
7429     aio_context_release(qemu_get_aio_context());
7430 }
7431
7432 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
7433 {
7434     IO_CODE();
7435     return bs ? bs->aio_context : qemu_get_aio_context();
7436 }
7437
7438 AioContext *coroutine_fn bdrv_co_enter(BlockDriverState *bs)
7439 {
7440     Coroutine *self = qemu_coroutine_self();
7441     AioContext *old_ctx = qemu_coroutine_get_aio_context(self);
7442     AioContext *new_ctx;
7443     IO_CODE();
7444
7445     /*
7446      * Increase bs->in_flight to ensure that this operation is completed before
7447      * moving the node to a different AioContext. Read new_ctx only afterwards.
7448      */
7449     bdrv_inc_in_flight(bs);
7450
7451     new_ctx = bdrv_get_aio_context(bs);
7452     aio_co_reschedule_self(new_ctx);
7453     return old_ctx;
7454 }
7455
7456 void coroutine_fn bdrv_co_leave(BlockDriverState *bs, AioContext *old_ctx)
7457 {
7458     IO_CODE();
7459     aio_co_reschedule_self(old_ctx);
7460     bdrv_dec_in_flight(bs);
7461 }
7462
7463 void coroutine_fn bdrv_co_lock(BlockDriverState *bs)
7464 {
7465     AioContext *ctx = bdrv_get_aio_context(bs);
7466
7467     /* In the main thread, bs->aio_context won't change concurrently */
7468     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
7469
7470     /*
7471      * We're in coroutine context, so we already hold the lock of the main
7472      * loop AioContext. Don't lock it twice to avoid deadlocks.
7473      */
7474     assert(qemu_in_coroutine());
7475     if (ctx != qemu_get_aio_context()) {
7476         aio_context_acquire(ctx);
7477     }
7478 }
7479
7480 void coroutine_fn bdrv_co_unlock(BlockDriverState *bs)
7481 {
7482     AioContext *ctx = bdrv_get_aio_context(bs);
7483
7484     assert(qemu_in_coroutine());
7485     if (ctx != qemu_get_aio_context()) {
7486         aio_context_release(ctx);
7487     }
7488 }
7489
7490 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
7491 {
7492     GLOBAL_STATE_CODE();
7493     QLIST_REMOVE(ban, list);
7494     g_free(ban);
7495 }
7496
7497 static void bdrv_detach_aio_context(BlockDriverState *bs)
7498 {
7499     BdrvAioNotifier *baf, *baf_tmp;
7500
7501     assert(!bs->walking_aio_notifiers);
7502     GLOBAL_STATE_CODE();
7503     bs->walking_aio_notifiers = true;
7504     QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
7505         if (baf->deleted) {
7506             bdrv_do_remove_aio_context_notifier(baf);
7507         } else {
7508             baf->detach_aio_context(baf->opaque);
7509         }
7510     }
7511     /* Never mind iterating again to check for ->deleted.  bdrv_close() will
7512      * remove remaining aio notifiers if we aren't called again.
7513      */
7514     bs->walking_aio_notifiers = false;
7515
7516     if (bs->drv && bs->drv->bdrv_detach_aio_context) {
7517         bs->drv->bdrv_detach_aio_context(bs);
7518     }
7519
7520     bs->aio_context = NULL;
7521 }
7522
7523 static void bdrv_attach_aio_context(BlockDriverState *bs,
7524                                     AioContext *new_context)
7525 {
7526     BdrvAioNotifier *ban, *ban_tmp;
7527     GLOBAL_STATE_CODE();
7528
7529     bs->aio_context = new_context;
7530
7531     if (bs->drv && bs->drv->bdrv_attach_aio_context) {
7532         bs->drv->bdrv_attach_aio_context(bs, new_context);
7533     }
7534
7535     assert(!bs->walking_aio_notifiers);
7536     bs->walking_aio_notifiers = true;
7537     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
7538         if (ban->deleted) {
7539             bdrv_do_remove_aio_context_notifier(ban);
7540         } else {
7541             ban->attached_aio_context(new_context, ban->opaque);
7542         }
7543     }
7544     bs->walking_aio_notifiers = false;
7545 }
7546
7547 typedef struct BdrvStateSetAioContext {
7548     AioContext *new_ctx;
7549     BlockDriverState *bs;
7550 } BdrvStateSetAioContext;
7551
7552 static bool bdrv_parent_change_aio_context(BdrvChild *c, AioContext *ctx,
7553                                            GHashTable *visited,
7554                                            Transaction *tran,
7555                                            Error **errp)
7556 {
7557     GLOBAL_STATE_CODE();
7558     if (g_hash_table_contains(visited, c)) {
7559         return true;
7560     }
7561     g_hash_table_add(visited, c);
7562
7563     /*
7564      * A BdrvChildClass that doesn't handle AioContext changes cannot
7565      * tolerate any AioContext changes
7566      */
7567     if (!c->klass->change_aio_ctx) {
7568         char *user = bdrv_child_user_desc(c);
7569         error_setg(errp, "Changing iothreads is not supported by %s", user);
7570         g_free(user);
7571         return false;
7572     }
7573     if (!c->klass->change_aio_ctx(c, ctx, visited, tran, errp)) {
7574         assert(!errp || *errp);
7575         return false;
7576     }
7577     return true;
7578 }
7579
7580 bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx,
7581                                    GHashTable *visited, Transaction *tran,
7582                                    Error **errp)
7583 {
7584     GLOBAL_STATE_CODE();
7585     if (g_hash_table_contains(visited, c)) {
7586         return true;
7587     }
7588     g_hash_table_add(visited, c);
7589     return bdrv_change_aio_context(c->bs, ctx, visited, tran, errp);
7590 }
7591
7592 static void bdrv_set_aio_context_clean(void *opaque)
7593 {
7594     BdrvStateSetAioContext *state = (BdrvStateSetAioContext *) opaque;
7595     BlockDriverState *bs = (BlockDriverState *) state->bs;
7596
7597     /* Paired with bdrv_drained_begin in bdrv_change_aio_context() */
7598     bdrv_drained_end(bs);
7599
7600     g_free(state);
7601 }
7602
7603 static void bdrv_set_aio_context_commit(void *opaque)
7604 {
7605     BdrvStateSetAioContext *state = (BdrvStateSetAioContext *) opaque;
7606     BlockDriverState *bs = (BlockDriverState *) state->bs;
7607     AioContext *new_context = state->new_ctx;
7608     AioContext *old_context = bdrv_get_aio_context(bs);
7609
7610     /*
7611      * Take the old AioContex when detaching it from bs.
7612      * At this point, new_context lock is already acquired, and we are now
7613      * also taking old_context. This is safe as long as bdrv_detach_aio_context
7614      * does not call AIO_POLL_WHILE().
7615      */
7616     if (old_context != qemu_get_aio_context()) {
7617         aio_context_acquire(old_context);
7618     }
7619     bdrv_detach_aio_context(bs);
7620     if (old_context != qemu_get_aio_context()) {
7621         aio_context_release(old_context);
7622     }
7623     bdrv_attach_aio_context(bs, new_context);
7624 }
7625
7626 static TransactionActionDrv set_aio_context = {
7627     .commit = bdrv_set_aio_context_commit,
7628     .clean = bdrv_set_aio_context_clean,
7629 };
7630
7631 /*
7632  * Changes the AioContext used for fd handlers, timers, and BHs by this
7633  * BlockDriverState and all its children and parents.
7634  *
7635  * Must be called from the main AioContext.
7636  *
7637  * The caller must own the AioContext lock for the old AioContext of bs, but it
7638  * must not own the AioContext lock for new_context (unless new_context is the
7639  * same as the current context of bs).
7640  *
7641  * @visited will accumulate all visited BdrvChild objects. The caller is
7642  * responsible for freeing the list afterwards.
7643  */
7644 static bool bdrv_change_aio_context(BlockDriverState *bs, AioContext *ctx,
7645                                     GHashTable *visited, Transaction *tran,
7646                                     Error **errp)
7647 {
7648     BdrvChild *c;
7649     BdrvStateSetAioContext *state;
7650
7651     GLOBAL_STATE_CODE();
7652
7653     if (bdrv_get_aio_context(bs) == ctx) {
7654         return true;
7655     }
7656
7657     QLIST_FOREACH(c, &bs->parents, next_parent) {
7658         if (!bdrv_parent_change_aio_context(c, ctx, visited, tran, errp)) {
7659             return false;
7660         }
7661     }
7662
7663     QLIST_FOREACH(c, &bs->children, next) {
7664         if (!bdrv_child_change_aio_context(c, ctx, visited, tran, errp)) {
7665             return false;
7666         }
7667     }
7668
7669     state = g_new(BdrvStateSetAioContext, 1);
7670     *state = (BdrvStateSetAioContext) {
7671         .new_ctx = ctx,
7672         .bs = bs,
7673     };
7674
7675     /* Paired with bdrv_drained_end in bdrv_set_aio_context_clean() */
7676     bdrv_drained_begin(bs);
7677
7678     tran_add(tran, &set_aio_context, state);
7679
7680     return true;
7681 }
7682
7683 /*
7684  * Change bs's and recursively all of its parents' and children's AioContext
7685  * to the given new context, returning an error if that isn't possible.
7686  *
7687  * If ignore_child is not NULL, that child (and its subgraph) will not
7688  * be touched.
7689  *
7690  * This function still requires the caller to take the bs current
7691  * AioContext lock, otherwise draining will fail since AIO_WAIT_WHILE
7692  * assumes the lock is always held if bs is in another AioContext.
7693  * For the same reason, it temporarily also holds the new AioContext, since
7694  * bdrv_drained_end calls BDRV_POLL_WHILE that assumes the lock is taken too.
7695  * Therefore the new AioContext lock must not be taken by the caller.
7696  */
7697 int bdrv_try_change_aio_context(BlockDriverState *bs, AioContext *ctx,
7698                                 BdrvChild *ignore_child, Error **errp)
7699 {
7700     Transaction *tran;
7701     GHashTable *visited;
7702     int ret;
7703     AioContext *old_context = bdrv_get_aio_context(bs);
7704     GLOBAL_STATE_CODE();
7705
7706     /*
7707      * Recursion phase: go through all nodes of the graph.
7708      * Take care of checking that all nodes support changing AioContext
7709      * and drain them, building a linear list of callbacks to run if everything
7710      * is successful (the transaction itself).
7711      */
7712     tran = tran_new();
7713     visited = g_hash_table_new(NULL, NULL);
7714     if (ignore_child) {
7715         g_hash_table_add(visited, ignore_child);
7716     }
7717     ret = bdrv_change_aio_context(bs, ctx, visited, tran, errp);
7718     g_hash_table_destroy(visited);
7719
7720     /*
7721      * Linear phase: go through all callbacks collected in the transaction.
7722      * Run all callbacks collected in the recursion to switch all nodes
7723      * AioContext lock (transaction commit), or undo all changes done in the
7724      * recursion (transaction abort).
7725      */
7726
7727     if (!ret) {
7728         /* Just run clean() callbacks. No AioContext changed. */
7729         tran_abort(tran);
7730         return -EPERM;
7731     }
7732
7733     /*
7734      * Release old AioContext, it won't be needed anymore, as all
7735      * bdrv_drained_begin() have been called already.
7736      */
7737     if (qemu_get_aio_context() != old_context) {
7738         aio_context_release(old_context);
7739     }
7740
7741     /*
7742      * Acquire new AioContext since bdrv_drained_end() is going to be called
7743      * after we switched all nodes in the new AioContext, and the function
7744      * assumes that the lock of the bs is always taken.
7745      */
7746     if (qemu_get_aio_context() != ctx) {
7747         aio_context_acquire(ctx);
7748     }
7749
7750     tran_commit(tran);
7751
7752     if (qemu_get_aio_context() != ctx) {
7753         aio_context_release(ctx);
7754     }
7755
7756     /* Re-acquire the old AioContext, since the caller takes and releases it. */
7757     if (qemu_get_aio_context() != old_context) {
7758         aio_context_acquire(old_context);
7759     }
7760
7761     return 0;
7762 }
7763
7764 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
7765         void (*attached_aio_context)(AioContext *new_context, void *opaque),
7766         void (*detach_aio_context)(void *opaque), void *opaque)
7767 {
7768     BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
7769     *ban = (BdrvAioNotifier){
7770         .attached_aio_context = attached_aio_context,
7771         .detach_aio_context   = detach_aio_context,
7772         .opaque               = opaque
7773     };
7774     GLOBAL_STATE_CODE();
7775
7776     QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
7777 }
7778
7779 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
7780                                       void (*attached_aio_context)(AioContext *,
7781                                                                    void *),
7782                                       void (*detach_aio_context)(void *),
7783                                       void *opaque)
7784 {
7785     BdrvAioNotifier *ban, *ban_next;
7786     GLOBAL_STATE_CODE();
7787
7788     QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
7789         if (ban->attached_aio_context == attached_aio_context &&
7790             ban->detach_aio_context   == detach_aio_context   &&
7791             ban->opaque               == opaque               &&
7792             ban->deleted              == false)
7793         {
7794             if (bs->walking_aio_notifiers) {
7795                 ban->deleted = true;
7796             } else {
7797                 bdrv_do_remove_aio_context_notifier(ban);
7798             }
7799             return;
7800         }
7801     }
7802
7803     abort();
7804 }
7805
7806 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
7807                        BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
7808                        bool force,
7809                        Error **errp)
7810 {
7811     GLOBAL_STATE_CODE();
7812     if (!bs->drv) {
7813         error_setg(errp, "Node is ejected");
7814         return -ENOMEDIUM;
7815     }
7816     if (!bs->drv->bdrv_amend_options) {
7817         error_setg(errp, "Block driver '%s' does not support option amendment",
7818                    bs->drv->format_name);
7819         return -ENOTSUP;
7820     }
7821     return bs->drv->bdrv_amend_options(bs, opts, status_cb,
7822                                        cb_opaque, force, errp);
7823 }
7824
7825 /*
7826  * This function checks whether the given @to_replace is allowed to be
7827  * replaced by a node that always shows the same data as @bs.  This is
7828  * used for example to verify whether the mirror job can replace
7829  * @to_replace by the target mirrored from @bs.
7830  * To be replaceable, @bs and @to_replace may either be guaranteed to
7831  * always show the same data (because they are only connected through
7832  * filters), or some driver may allow replacing one of its children
7833  * because it can guarantee that this child's data is not visible at
7834  * all (for example, for dissenting quorum children that have no other
7835  * parents).
7836  */
7837 bool bdrv_recurse_can_replace(BlockDriverState *bs,
7838                               BlockDriverState *to_replace)
7839 {
7840     BlockDriverState *filtered;
7841
7842     GLOBAL_STATE_CODE();
7843
7844     if (!bs || !bs->drv) {
7845         return false;
7846     }
7847
7848     if (bs == to_replace) {
7849         return true;
7850     }
7851
7852     /* See what the driver can do */
7853     if (bs->drv->bdrv_recurse_can_replace) {
7854         return bs->drv->bdrv_recurse_can_replace(bs, to_replace);
7855     }
7856
7857     /* For filters without an own implementation, we can recurse on our own */
7858     filtered = bdrv_filter_bs(bs);
7859     if (filtered) {
7860         return bdrv_recurse_can_replace(filtered, to_replace);
7861     }
7862
7863     /* Safe default */
7864     return false;
7865 }
7866
7867 /*
7868  * Check whether the given @node_name can be replaced by a node that
7869  * has the same data as @parent_bs.  If so, return @node_name's BDS;
7870  * NULL otherwise.
7871  *
7872  * @node_name must be a (recursive) *child of @parent_bs (or this
7873  * function will return NULL).
7874  *
7875  * The result (whether the node can be replaced or not) is only valid
7876  * for as long as no graph or permission changes occur.
7877  */
7878 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
7879                                         const char *node_name, Error **errp)
7880 {
7881     BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
7882     AioContext *aio_context;
7883
7884     GLOBAL_STATE_CODE();
7885
7886     if (!to_replace_bs) {
7887         error_setg(errp, "Failed to find node with node-name='%s'", node_name);
7888         return NULL;
7889     }
7890
7891     aio_context = bdrv_get_aio_context(to_replace_bs);
7892     aio_context_acquire(aio_context);
7893
7894     if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
7895         to_replace_bs = NULL;
7896         goto out;
7897     }
7898
7899     /* We don't want arbitrary node of the BDS chain to be replaced only the top
7900      * most non filter in order to prevent data corruption.
7901      * Another benefit is that this tests exclude backing files which are
7902      * blocked by the backing blockers.
7903      */
7904     if (!bdrv_recurse_can_replace(parent_bs, to_replace_bs)) {
7905         error_setg(errp, "Cannot replace '%s' by a node mirrored from '%s', "
7906                    "because it cannot be guaranteed that doing so would not "
7907                    "lead to an abrupt change of visible data",
7908                    node_name, parent_bs->node_name);
7909         to_replace_bs = NULL;
7910         goto out;
7911     }
7912
7913 out:
7914     aio_context_release(aio_context);
7915     return to_replace_bs;
7916 }
7917
7918 /**
7919  * Iterates through the list of runtime option keys that are said to
7920  * be "strong" for a BDS.  An option is called "strong" if it changes
7921  * a BDS's data.  For example, the null block driver's "size" and
7922  * "read-zeroes" options are strong, but its "latency-ns" option is
7923  * not.
7924  *
7925  * If a key returned by this function ends with a dot, all options
7926  * starting with that prefix are strong.
7927  */
7928 static const char *const *strong_options(BlockDriverState *bs,
7929                                          const char *const *curopt)
7930 {
7931     static const char *const global_options[] = {
7932         "driver", "filename", NULL
7933     };
7934
7935     if (!curopt) {
7936         return &global_options[0];
7937     }
7938
7939     curopt++;
7940     if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) {
7941         curopt = bs->drv->strong_runtime_opts;
7942     }
7943
7944     return (curopt && *curopt) ? curopt : NULL;
7945 }
7946
7947 /**
7948  * Copies all strong runtime options from bs->options to the given
7949  * QDict.  The set of strong option keys is determined by invoking
7950  * strong_options().
7951  *
7952  * Returns true iff any strong option was present in bs->options (and
7953  * thus copied to the target QDict) with the exception of "filename"
7954  * and "driver".  The caller is expected to use this value to decide
7955  * whether the existence of strong options prevents the generation of
7956  * a plain filename.
7957  */
7958 static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)
7959 {
7960     bool found_any = false;
7961     const char *const *option_name = NULL;
7962
7963     if (!bs->drv) {
7964         return false;
7965     }
7966
7967     while ((option_name = strong_options(bs, option_name))) {
7968         bool option_given = false;
7969
7970         assert(strlen(*option_name) > 0);
7971         if ((*option_name)[strlen(*option_name) - 1] != '.') {
7972             QObject *entry = qdict_get(bs->options, *option_name);
7973             if (!entry) {
7974                 continue;
7975             }
7976
7977             qdict_put_obj(d, *option_name, qobject_ref(entry));
7978             option_given = true;
7979         } else {
7980             const QDictEntry *entry;
7981             for (entry = qdict_first(bs->options); entry;
7982                  entry = qdict_next(bs->options, entry))
7983             {
7984                 if (strstart(qdict_entry_key(entry), *option_name, NULL)) {
7985                     qdict_put_obj(d, qdict_entry_key(entry),
7986                                   qobject_ref(qdict_entry_value(entry)));
7987                     option_given = true;
7988                 }
7989             }
7990         }
7991
7992         /* While "driver" and "filename" need to be included in a JSON filename,
7993          * their existence does not prohibit generation of a plain filename. */
7994         if (!found_any && option_given &&
7995             strcmp(*option_name, "driver") && strcmp(*option_name, "filename"))
7996         {
7997             found_any = true;
7998         }
7999     }
8000
8001     if (!qdict_haskey(d, "driver")) {
8002         /* Drivers created with bdrv_new_open_driver() may not have a
8003          * @driver option.  Add it here. */
8004         qdict_put_str(d, "driver", bs->drv->format_name);
8005     }
8006
8007     return found_any;
8008 }
8009
8010 /* Note: This function may return false positives; it may return true
8011  * even if opening the backing file specified by bs's image header
8012  * would result in exactly bs->backing. */
8013 static bool bdrv_backing_overridden(BlockDriverState *bs)
8014 {
8015     GLOBAL_STATE_CODE();
8016     if (bs->backing) {
8017         return strcmp(bs->auto_backing_file,
8018                       bs->backing->bs->filename);
8019     } else {
8020         /* No backing BDS, so if the image header reports any backing
8021          * file, it must have been suppressed */
8022         return bs->auto_backing_file[0] != '\0';
8023     }
8024 }
8025
8026 /* Updates the following BDS fields:
8027  *  - exact_filename: A filename which may be used for opening a block device
8028  *                    which (mostly) equals the given BDS (even without any
8029  *                    other options; so reading and writing must return the same
8030  *                    results, but caching etc. may be different)
8031  *  - full_open_options: Options which, when given when opening a block device
8032  *                       (without a filename), result in a BDS (mostly)
8033  *                       equalling the given one
8034  *  - filename: If exact_filename is set, it is copied here. Otherwise,
8035  *              full_open_options is converted to a JSON object, prefixed with
8036  *              "json:" (for use through the JSON pseudo protocol) and put here.
8037  */
8038 void bdrv_refresh_filename(BlockDriverState *bs)
8039 {
8040     BlockDriver *drv = bs->drv;
8041     BdrvChild *child;
8042     BlockDriverState *primary_child_bs;
8043     QDict *opts;
8044     bool backing_overridden;
8045     bool generate_json_filename; /* Whether our default implementation should
8046                                     fill exact_filename (false) or not (true) */
8047
8048     GLOBAL_STATE_CODE();
8049
8050     if (!drv) {
8051         return;
8052     }
8053
8054     /* This BDS's file name may depend on any of its children's file names, so
8055      * refresh those first */
8056     QLIST_FOREACH(child, &bs->children, next) {
8057         bdrv_refresh_filename(child->bs);
8058     }
8059
8060     if (bs->implicit) {
8061         /* For implicit nodes, just copy everything from the single child */
8062         child = QLIST_FIRST(&bs->children);
8063         assert(QLIST_NEXT(child, next) == NULL);
8064
8065         pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
8066                 child->bs->exact_filename);
8067         pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename);
8068
8069         qobject_unref(bs->full_open_options);
8070         bs->full_open_options = qobject_ref(child->bs->full_open_options);
8071
8072         return;
8073     }
8074
8075     backing_overridden = bdrv_backing_overridden(bs);
8076
8077     if (bs->open_flags & BDRV_O_NO_IO) {
8078         /* Without I/O, the backing file does not change anything.
8079          * Therefore, in such a case (primarily qemu-img), we can
8080          * pretend the backing file has not been overridden even if
8081          * it technically has been. */
8082         backing_overridden = false;
8083     }
8084
8085     /* Gather the options QDict */
8086     opts = qdict_new();
8087     generate_json_filename = append_strong_runtime_options(opts, bs);
8088     generate_json_filename |= backing_overridden;
8089
8090     if (drv->bdrv_gather_child_options) {
8091         /* Some block drivers may not want to present all of their children's
8092          * options, or name them differently from BdrvChild.name */
8093         drv->bdrv_gather_child_options(bs, opts, backing_overridden);
8094     } else {
8095         QLIST_FOREACH(child, &bs->children, next) {
8096             if (child == bs->backing && !backing_overridden) {
8097                 /* We can skip the backing BDS if it has not been overridden */
8098                 continue;
8099             }
8100
8101             qdict_put(opts, child->name,
8102                       qobject_ref(child->bs->full_open_options));
8103         }
8104
8105         if (backing_overridden && !bs->backing) {
8106             /* Force no backing file */
8107             qdict_put_null(opts, "backing");
8108         }
8109     }
8110
8111     qobject_unref(bs->full_open_options);
8112     bs->full_open_options = opts;
8113
8114     primary_child_bs = bdrv_primary_bs(bs);
8115
8116     if (drv->bdrv_refresh_filename) {
8117         /* Obsolete information is of no use here, so drop the old file name
8118          * information before refreshing it */
8119         bs->exact_filename[0] = '\0';
8120
8121         drv->bdrv_refresh_filename(bs);
8122     } else if (primary_child_bs) {
8123         /*
8124          * Try to reconstruct valid information from the underlying
8125          * file -- this only works for format nodes (filter nodes
8126          * cannot be probed and as such must be selected by the user
8127          * either through an options dict, or through a special
8128          * filename which the filter driver must construct in its
8129          * .bdrv_refresh_filename() implementation).
8130          */
8131
8132         bs->exact_filename[0] = '\0';
8133
8134         /*
8135          * We can use the underlying file's filename if:
8136          * - it has a filename,
8137          * - the current BDS is not a filter,
8138          * - the file is a protocol BDS, and
8139          * - opening that file (as this BDS's format) will automatically create
8140          *   the BDS tree we have right now, that is:
8141          *   - the user did not significantly change this BDS's behavior with
8142          *     some explicit (strong) options
8143          *   - no non-file child of this BDS has been overridden by the user
8144          *   Both of these conditions are represented by generate_json_filename.
8145          */
8146         if (primary_child_bs->exact_filename[0] &&
8147             primary_child_bs->drv->bdrv_file_open &&
8148             !drv->is_filter && !generate_json_filename)
8149         {
8150             strcpy(bs->exact_filename, primary_child_bs->exact_filename);
8151         }
8152     }
8153
8154     if (bs->exact_filename[0]) {
8155         pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
8156     } else {
8157         GString *json = qobject_to_json(QOBJECT(bs->full_open_options));
8158         if (snprintf(bs->filename, sizeof(bs->filename), "json:%s",
8159                      json->str) >= sizeof(bs->filename)) {
8160             /* Give user a hint if we truncated things. */
8161             strcpy(bs->filename + sizeof(bs->filename) - 4, "...");
8162         }
8163         g_string_free(json, true);
8164     }
8165 }
8166
8167 char *bdrv_dirname(BlockDriverState *bs, Error **errp)
8168 {
8169     BlockDriver *drv = bs->drv;
8170     BlockDriverState *child_bs;
8171
8172     GLOBAL_STATE_CODE();
8173
8174     if (!drv) {
8175         error_setg(errp, "Node '%s' is ejected", bs->node_name);
8176         return NULL;
8177     }
8178
8179     if (drv->bdrv_dirname) {
8180         return drv->bdrv_dirname(bs, errp);
8181     }
8182
8183     child_bs = bdrv_primary_bs(bs);
8184     if (child_bs) {
8185         return bdrv_dirname(child_bs, errp);
8186     }
8187
8188     bdrv_refresh_filename(bs);
8189     if (bs->exact_filename[0] != '\0') {
8190         return path_combine(bs->exact_filename, "");
8191     }
8192
8193     error_setg(errp, "Cannot generate a base directory for %s nodes",
8194                drv->format_name);
8195     return NULL;
8196 }
8197
8198 /*
8199  * Hot add/remove a BDS's child. So the user can take a child offline when
8200  * it is broken and take a new child online
8201  */
8202 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
8203                     Error **errp)
8204 {
8205     GLOBAL_STATE_CODE();
8206     if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
8207         error_setg(errp, "The node %s does not support adding a child",
8208                    bdrv_get_device_or_node_name(parent_bs));
8209         return;
8210     }
8211
8212     /*
8213      * Non-zoned block drivers do not follow zoned storage constraints
8214      * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned
8215      * drivers in a graph.
8216      */
8217     if (!parent_bs->drv->supports_zoned_children &&
8218         child_bs->bl.zoned == BLK_Z_HM) {
8219         /*
8220          * The host-aware model allows zoned storage constraints and random
8221          * write. Allow mixing host-aware and non-zoned drivers. Using
8222          * host-aware device as a regular device.
8223          */
8224         error_setg(errp, "Cannot add a %s child to a %s parent",
8225                    child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned",
8226                    parent_bs->drv->supports_zoned_children ?
8227                    "support zoned children" : "not support zoned children");
8228         return;
8229     }
8230
8231     if (!QLIST_EMPTY(&child_bs->parents)) {
8232         error_setg(errp, "The node %s already has a parent",
8233                    child_bs->node_name);
8234         return;
8235     }
8236
8237     parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
8238 }
8239
8240 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
8241 {
8242     BdrvChild *tmp;
8243
8244     GLOBAL_STATE_CODE();
8245     if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
8246         error_setg(errp, "The node %s does not support removing a child",
8247                    bdrv_get_device_or_node_name(parent_bs));
8248         return;
8249     }
8250
8251     QLIST_FOREACH(tmp, &parent_bs->children, next) {
8252         if (tmp == child) {
8253             break;
8254         }
8255     }
8256
8257     if (!tmp) {
8258         error_setg(errp, "The node %s does not have a child named %s",
8259                    bdrv_get_device_or_node_name(parent_bs),
8260                    bdrv_get_device_or_node_name(child->bs));
8261         return;
8262     }
8263
8264     parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
8265 }
8266
8267 int bdrv_make_empty(BdrvChild *c, Error **errp)
8268 {
8269     BlockDriver *drv = c->bs->drv;
8270     int ret;
8271
8272     GLOBAL_STATE_CODE();
8273     assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED));
8274
8275     if (!drv->bdrv_make_empty) {
8276         error_setg(errp, "%s does not support emptying nodes",
8277                    drv->format_name);
8278         return -ENOTSUP;
8279     }
8280
8281     ret = drv->bdrv_make_empty(c->bs);
8282     if (ret < 0) {
8283         error_setg_errno(errp, -ret, "Failed to empty %s",
8284                          c->bs->filename);
8285         return ret;
8286     }
8287
8288     return 0;
8289 }
8290
8291 /*
8292  * Return the child that @bs acts as an overlay for, and from which data may be
8293  * copied in COW or COR operations.  Usually this is the backing file.
8294  */
8295 BdrvChild *bdrv_cow_child(BlockDriverState *bs)
8296 {
8297     IO_CODE();
8298
8299     if (!bs || !bs->drv) {
8300         return NULL;
8301     }
8302
8303     if (bs->drv->is_filter) {
8304         return NULL;
8305     }
8306
8307     if (!bs->backing) {
8308         return NULL;
8309     }
8310
8311     assert(bs->backing->role & BDRV_CHILD_COW);
8312     return bs->backing;
8313 }
8314
8315 /*
8316  * If @bs acts as a filter for exactly one of its children, return
8317  * that child.
8318  */
8319 BdrvChild *bdrv_filter_child(BlockDriverState *bs)
8320 {
8321     BdrvChild *c;
8322     IO_CODE();
8323
8324     if (!bs || !bs->drv) {
8325         return NULL;
8326     }
8327
8328     if (!bs->drv->is_filter) {
8329         return NULL;
8330     }
8331
8332     /* Only one of @backing or @file may be used */
8333     assert(!(bs->backing && bs->file));
8334
8335     c = bs->backing ?: bs->file;
8336     if (!c) {
8337         return NULL;
8338     }
8339
8340     assert(c->role & BDRV_CHILD_FILTERED);
8341     return c;
8342 }
8343
8344 /*
8345  * Return either the result of bdrv_cow_child() or bdrv_filter_child(),
8346  * whichever is non-NULL.
8347  *
8348  * Return NULL if both are NULL.
8349  */
8350 BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs)
8351 {
8352     BdrvChild *cow_child = bdrv_cow_child(bs);
8353     BdrvChild *filter_child = bdrv_filter_child(bs);
8354     IO_CODE();
8355
8356     /* Filter nodes cannot have COW backing files */
8357     assert(!(cow_child && filter_child));
8358
8359     return cow_child ?: filter_child;
8360 }
8361
8362 /*
8363  * Return the primary child of this node: For filters, that is the
8364  * filtered child.  For other nodes, that is usually the child storing
8365  * metadata.
8366  * (A generally more helpful description is that this is (usually) the
8367  * child that has the same filename as @bs.)
8368  *
8369  * Drivers do not necessarily have a primary child; for example quorum
8370  * does not.
8371  */
8372 BdrvChild *bdrv_primary_child(BlockDriverState *bs)
8373 {
8374     BdrvChild *c, *found = NULL;
8375     IO_CODE();
8376
8377     QLIST_FOREACH(c, &bs->children, next) {
8378         if (c->role & BDRV_CHILD_PRIMARY) {
8379             assert(!found);
8380             found = c;
8381         }
8382     }
8383
8384     return found;
8385 }
8386
8387 static BlockDriverState *bdrv_do_skip_filters(BlockDriverState *bs,
8388                                               bool stop_on_explicit_filter)
8389 {
8390     BdrvChild *c;
8391
8392     if (!bs) {
8393         return NULL;
8394     }
8395
8396     while (!(stop_on_explicit_filter && !bs->implicit)) {
8397         c = bdrv_filter_child(bs);
8398         if (!c) {
8399             /*
8400              * A filter that is embedded in a working block graph must
8401              * have a child.  Assert this here so this function does
8402              * not return a filter node that is not expected by the
8403              * caller.
8404              */
8405             assert(!bs->drv || !bs->drv->is_filter);
8406             break;
8407         }
8408         bs = c->bs;
8409     }
8410     /*
8411      * Note that this treats nodes with bs->drv == NULL as not being
8412      * filters (bs->drv == NULL should be replaced by something else
8413      * anyway).
8414      * The advantage of this behavior is that this function will thus
8415      * always return a non-NULL value (given a non-NULL @bs).
8416      */
8417
8418     return bs;
8419 }
8420
8421 /*
8422  * Return the first BDS that has not been added implicitly or that
8423  * does not have a filtered child down the chain starting from @bs
8424  * (including @bs itself).
8425  */
8426 BlockDriverState *bdrv_skip_implicit_filters(BlockDriverState *bs)
8427 {
8428     GLOBAL_STATE_CODE();
8429     return bdrv_do_skip_filters(bs, true);
8430 }
8431
8432 /*
8433  * Return the first BDS that does not have a filtered child down the
8434  * chain starting from @bs (including @bs itself).
8435  */
8436 BlockDriverState *bdrv_skip_filters(BlockDriverState *bs)
8437 {
8438     IO_CODE();
8439     return bdrv_do_skip_filters(bs, false);
8440 }
8441
8442 /*
8443  * For a backing chain, return the first non-filter backing image of
8444  * the first non-filter image.
8445  */
8446 BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs)
8447 {
8448     IO_CODE();
8449     return bdrv_skip_filters(bdrv_cow_bs(bdrv_skip_filters(bs)));
8450 }
8451
8452 /**
8453  * Check whether [offset, offset + bytes) overlaps with the cached
8454  * block-status data region.
8455  *
8456  * If so, and @pnum is not NULL, set *pnum to `bsc.data_end - offset`,
8457  * which is what bdrv_bsc_is_data()'s interface needs.
8458  * Otherwise, *pnum is not touched.
8459  */
8460 static bool bdrv_bsc_range_overlaps_locked(BlockDriverState *bs,
8461                                            int64_t offset, int64_t bytes,
8462                                            int64_t *pnum)
8463 {
8464     BdrvBlockStatusCache *bsc = qatomic_rcu_read(&bs->block_status_cache);
8465     bool overlaps;
8466
8467     overlaps =
8468         qatomic_read(&bsc->valid) &&
8469         ranges_overlap(offset, bytes, bsc->data_start,
8470                        bsc->data_end - bsc->data_start);
8471
8472     if (overlaps && pnum) {
8473         *pnum = bsc->data_end - offset;
8474     }
8475
8476     return overlaps;
8477 }
8478
8479 /**
8480  * See block_int.h for this function's documentation.
8481  */
8482 bool bdrv_bsc_is_data(BlockDriverState *bs, int64_t offset, int64_t *pnum)
8483 {
8484     IO_CODE();
8485     RCU_READ_LOCK_GUARD();
8486     return bdrv_bsc_range_overlaps_locked(bs, offset, 1, pnum);
8487 }
8488
8489 /**
8490  * See block_int.h for this function's documentation.
8491  */
8492 void bdrv_bsc_invalidate_range(BlockDriverState *bs,
8493                                int64_t offset, int64_t bytes)
8494 {
8495     IO_CODE();
8496     RCU_READ_LOCK_GUARD();
8497
8498     if (bdrv_bsc_range_overlaps_locked(bs, offset, bytes, NULL)) {
8499         qatomic_set(&bs->block_status_cache->valid, false);
8500     }
8501 }
8502
8503 /**
8504  * See block_int.h for this function's documentation.
8505  */
8506 void bdrv_bsc_fill(BlockDriverState *bs, int64_t offset, int64_t bytes)
8507 {
8508     BdrvBlockStatusCache *new_bsc = g_new(BdrvBlockStatusCache, 1);
8509     BdrvBlockStatusCache *old_bsc;
8510     IO_CODE();
8511
8512     *new_bsc = (BdrvBlockStatusCache) {
8513         .valid = true,
8514         .data_start = offset,
8515         .data_end = offset + bytes,
8516     };
8517
8518     QEMU_LOCK_GUARD(&bs->bsc_modify_lock);
8519
8520     old_bsc = qatomic_rcu_read(&bs->block_status_cache);
8521     qatomic_rcu_set(&bs->block_status_cache, new_bsc);
8522     if (old_bsc) {
8523         g_free_rcu(old_bsc, rcu);
8524     }
8525 }