2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "block/blockjob.h"
28 #include "qemu/error-report.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qerror.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
42 #include "qemu/cutils.h"
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
57 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
60 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
62 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
63 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
65 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
66 QLIST_HEAD_INITIALIZER(bdrv_drivers);
68 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
69 const char *reference, QDict *options, int flags,
70 BlockDriverState *parent,
71 const BdrvChildRole *child_role, Error **errp);
73 /* If non-zero, use only whitelisted block drivers */
74 static int use_bdrv_whitelist;
76 static void bdrv_close(BlockDriverState *bs);
79 static int is_windows_drive_prefix(const char *filename)
81 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
82 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
86 int is_windows_drive(const char *filename)
88 if (is_windows_drive_prefix(filename) &&
91 if (strstart(filename, "\\\\.\\", NULL) ||
92 strstart(filename, "//./", NULL))
98 size_t bdrv_opt_mem_align(BlockDriverState *bs)
100 if (!bs || !bs->drv) {
101 /* page size or 4k (hdd sector size) should be on the safe side */
102 return MAX(4096, getpagesize());
105 return bs->bl.opt_mem_alignment;
108 size_t bdrv_min_mem_align(BlockDriverState *bs)
110 if (!bs || !bs->drv) {
111 /* page size or 4k (hdd sector size) should be on the safe side */
112 return MAX(4096, getpagesize());
115 return bs->bl.min_mem_alignment;
118 /* check if the path starts with "<protocol>:" */
119 int path_has_protocol(const char *path)
124 if (is_windows_drive(path) ||
125 is_windows_drive_prefix(path)) {
128 p = path + strcspn(path, ":/\\");
130 p = path + strcspn(path, ":/");
136 int path_is_absolute(const char *path)
139 /* specific case for names like: "\\.\d:" */
140 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
143 return (*path == '/' || *path == '\\');
145 return (*path == '/');
149 /* if filename is absolute, just copy it to dest. Otherwise, build a
150 path to it by considering it is relative to base_path. URL are
152 void path_combine(char *dest, int dest_size,
153 const char *base_path,
154 const char *filename)
161 if (path_is_absolute(filename)) {
162 pstrcpy(dest, dest_size, filename);
164 p = strchr(base_path, ':');
169 p1 = strrchr(base_path, '/');
173 p2 = strrchr(base_path, '\\');
185 if (len > dest_size - 1)
187 memcpy(dest, base_path, len);
189 pstrcat(dest, dest_size, filename);
193 void bdrv_get_full_backing_filename_from_filename(const char *backed,
195 char *dest, size_t sz,
198 if (backing[0] == '\0' || path_has_protocol(backing) ||
199 path_is_absolute(backing))
201 pstrcpy(dest, sz, backing);
202 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
203 error_setg(errp, "Cannot use relative backing file names for '%s'",
206 path_combine(dest, sz, backed, backing);
210 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
213 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
215 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
219 void bdrv_register(BlockDriver *bdrv)
221 bdrv_setup_io_funcs(bdrv);
223 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
226 BlockDriverState *bdrv_new_root(void)
231 BlockDriverState *bdrv_new(void)
233 BlockDriverState *bs;
236 bs = g_new0(BlockDriverState, 1);
237 QLIST_INIT(&bs->dirty_bitmaps);
238 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
239 QLIST_INIT(&bs->op_blockers[i]);
241 notifier_with_return_list_init(&bs->before_write_notifiers);
242 qemu_co_queue_init(&bs->throttled_reqs[0]);
243 qemu_co_queue_init(&bs->throttled_reqs[1]);
245 bs->aio_context = qemu_get_aio_context();
247 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
252 BlockDriver *bdrv_find_format(const char *format_name)
255 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
256 if (!strcmp(drv1->format_name, format_name)) {
263 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
265 static const char *whitelist_rw[] = {
266 CONFIG_BDRV_RW_WHITELIST
268 static const char *whitelist_ro[] = {
269 CONFIG_BDRV_RO_WHITELIST
273 if (!whitelist_rw[0] && !whitelist_ro[0]) {
274 return 1; /* no whitelist, anything goes */
277 for (p = whitelist_rw; *p; p++) {
278 if (!strcmp(drv->format_name, *p)) {
283 for (p = whitelist_ro; *p; p++) {
284 if (!strcmp(drv->format_name, *p)) {
292 bool bdrv_uses_whitelist(void)
294 return use_bdrv_whitelist;
297 typedef struct CreateCo {
305 static void coroutine_fn bdrv_create_co_entry(void *opaque)
307 Error *local_err = NULL;
310 CreateCo *cco = opaque;
313 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
315 error_propagate(&cco->err, local_err);
320 int bdrv_create(BlockDriver *drv, const char* filename,
321 QemuOpts *opts, Error **errp)
328 .filename = g_strdup(filename),
334 if (!drv->bdrv_create) {
335 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
340 if (qemu_in_coroutine()) {
341 /* Fast-path if already in coroutine context */
342 bdrv_create_co_entry(&cco);
344 co = qemu_coroutine_create(bdrv_create_co_entry);
345 qemu_coroutine_enter(co, &cco);
346 while (cco.ret == NOT_DONE) {
347 aio_poll(qemu_get_aio_context(), true);
354 error_propagate(errp, cco.err);
356 error_setg_errno(errp, -ret, "Could not create image");
361 g_free(cco.filename);
365 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
368 Error *local_err = NULL;
371 drv = bdrv_find_protocol(filename, true, errp);
376 ret = bdrv_create(drv, filename, opts, &local_err);
378 error_propagate(errp, local_err);
384 * Try to get @bs's logical and physical block size.
385 * On success, store them in @bsz struct and return 0.
386 * On failure return -errno.
387 * @bs must not be empty.
389 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
391 BlockDriver *drv = bs->drv;
393 if (drv && drv->bdrv_probe_blocksizes) {
394 return drv->bdrv_probe_blocksizes(bs, bsz);
401 * Try to get @bs's geometry (cyls, heads, sectors).
402 * On success, store them in @geo struct and return 0.
403 * On failure return -errno.
404 * @bs must not be empty.
406 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
408 BlockDriver *drv = bs->drv;
410 if (drv && drv->bdrv_probe_geometry) {
411 return drv->bdrv_probe_geometry(bs, geo);
418 * Create a uniquely-named empty temporary file.
419 * Return 0 upon success, otherwise a negative errno value.
421 int get_tmp_filename(char *filename, int size)
424 char temp_dir[MAX_PATH];
425 /* GetTempFileName requires that its output buffer (4th param)
426 have length MAX_PATH or greater. */
427 assert(size >= MAX_PATH);
428 return (GetTempPath(MAX_PATH, temp_dir)
429 && GetTempFileName(temp_dir, "qem", 0, filename)
430 ? 0 : -GetLastError());
434 tmpdir = getenv("TMPDIR");
438 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
441 fd = mkstemp(filename);
445 if (close(fd) != 0) {
454 * Detect host devices. By convention, /dev/cdrom[N] is always
455 * recognized as a host CDROM.
457 static BlockDriver *find_hdev_driver(const char *filename)
459 int score_max = 0, score;
460 BlockDriver *drv = NULL, *d;
462 QLIST_FOREACH(d, &bdrv_drivers, list) {
463 if (d->bdrv_probe_device) {
464 score = d->bdrv_probe_device(filename);
465 if (score > score_max) {
475 BlockDriver *bdrv_find_protocol(const char *filename,
476 bool allow_protocol_prefix,
484 /* TODO Drivers without bdrv_file_open must be specified explicitly */
487 * XXX(hch): we really should not let host device detection
488 * override an explicit protocol specification, but moving this
489 * later breaks access to device names with colons in them.
490 * Thanks to the brain-dead persistent naming schemes on udev-
491 * based Linux systems those actually are quite common.
493 drv1 = find_hdev_driver(filename);
498 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
502 p = strchr(filename, ':');
505 if (len > sizeof(protocol) - 1)
506 len = sizeof(protocol) - 1;
507 memcpy(protocol, filename, len);
508 protocol[len] = '\0';
509 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
510 if (drv1->protocol_name &&
511 !strcmp(drv1->protocol_name, protocol)) {
516 error_setg(errp, "Unknown protocol '%s'", protocol);
521 * Guess image format by probing its contents.
522 * This is not a good idea when your image is raw (CVE-2008-2004), but
523 * we do it anyway for backward compatibility.
525 * @buf contains the image's first @buf_size bytes.
526 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
527 * but can be smaller if the image file is smaller)
528 * @filename is its filename.
530 * For all block drivers, call the bdrv_probe() method to get its
532 * Return the first block driver with the highest probing score.
534 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
535 const char *filename)
537 int score_max = 0, score;
538 BlockDriver *drv = NULL, *d;
540 QLIST_FOREACH(d, &bdrv_drivers, list) {
542 score = d->bdrv_probe(buf, buf_size, filename);
543 if (score > score_max) {
553 static int find_image_format(BlockDriverState *bs, const char *filename,
554 BlockDriver **pdrv, Error **errp)
557 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
560 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
561 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
566 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
568 error_setg_errno(errp, -ret, "Could not read image for determining its "
574 drv = bdrv_probe_all(buf, ret, filename);
576 error_setg(errp, "Could not determine image format: No compatible "
585 * Set the current 'total_sectors' value
586 * Return 0 on success, -errno on error.
588 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
590 BlockDriver *drv = bs->drv;
592 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
596 /* query actual device if possible, otherwise just trust the hint */
597 if (drv->bdrv_getlength) {
598 int64_t length = drv->bdrv_getlength(bs);
602 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
605 bs->total_sectors = hint;
610 * Combines a QDict of new block driver @options with any missing options taken
611 * from @old_options, so that leaving out an option defaults to its old value.
613 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
616 if (bs->drv && bs->drv->bdrv_join_options) {
617 bs->drv->bdrv_join_options(options, old_options);
619 qdict_join(options, old_options, false);
624 * Set open flags for a given discard mode
626 * Return 0 on success, -1 if the discard mode was invalid.
628 int bdrv_parse_discard_flags(const char *mode, int *flags)
630 *flags &= ~BDRV_O_UNMAP;
632 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
634 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
635 *flags |= BDRV_O_UNMAP;
644 * Set open flags for a given cache mode
646 * Return 0 on success, -1 if the cache mode was invalid.
648 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
650 *flags &= ~BDRV_O_CACHE_MASK;
652 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
653 *writethrough = false;
654 *flags |= BDRV_O_NOCACHE;
655 } else if (!strcmp(mode, "directsync")) {
656 *writethrough = true;
657 *flags |= BDRV_O_NOCACHE;
658 } else if (!strcmp(mode, "writeback")) {
659 *writethrough = false;
660 } else if (!strcmp(mode, "unsafe")) {
661 *writethrough = false;
662 *flags |= BDRV_O_NO_FLUSH;
663 } else if (!strcmp(mode, "writethrough")) {
664 *writethrough = true;
673 * Returns the options and flags that a temporary snapshot should get, based on
674 * the originally requested flags (the originally requested image will have
675 * flags like a backing file)
677 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
678 int parent_flags, QDict *parent_options)
680 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
682 /* For temporary files, unconditional cache=unsafe is fine */
683 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
684 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
688 * Returns the options and flags that bs->file should get if a protocol driver
689 * is expected, based on the given options and flags for the parent BDS
691 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
692 int parent_flags, QDict *parent_options)
694 int flags = parent_flags;
696 /* Enable protocol handling, disable format probing for bs->file */
697 flags |= BDRV_O_PROTOCOL;
699 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
701 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
702 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
704 /* Our block drivers take care to send flushes and respect unmap policy,
705 * so we can default to enable both on lower layers regardless of the
706 * corresponding parent options. */
707 flags |= BDRV_O_UNMAP;
709 /* Clear flags that only apply to the top layer */
710 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
713 *child_flags = flags;
716 const BdrvChildRole child_file = {
717 .inherit_options = bdrv_inherited_options,
721 * Returns the options and flags that bs->file should get if the use of formats
722 * (and not only protocols) is permitted for it, based on the given options and
723 * flags for the parent BDS
725 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
726 int parent_flags, QDict *parent_options)
728 child_file.inherit_options(child_flags, child_options,
729 parent_flags, parent_options);
731 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
734 const BdrvChildRole child_format = {
735 .inherit_options = bdrv_inherited_fmt_options,
739 * Returns the options and flags that bs->backing should get, based on the
740 * given options and flags for the parent BDS
742 static void bdrv_backing_options(int *child_flags, QDict *child_options,
743 int parent_flags, QDict *parent_options)
745 int flags = parent_flags;
747 /* The cache mode is inherited unmodified for backing files; except WCE,
748 * which is only applied on the top level (BlockBackend) */
749 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
750 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
752 /* backing files always opened read-only */
753 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
755 /* snapshot=on is handled on the top layer */
756 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
758 *child_flags = flags;
761 static const BdrvChildRole child_backing = {
762 .inherit_options = bdrv_backing_options,
765 static int bdrv_open_flags(BlockDriverState *bs, int flags)
767 int open_flags = flags;
770 * Clear flags that are internal to the block layer before opening the
773 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
776 * Snapshots should be writable.
778 if (flags & BDRV_O_TEMPORARY) {
779 open_flags |= BDRV_O_RDWR;
785 static void update_flags_from_options(int *flags, QemuOpts *opts)
787 *flags &= ~BDRV_O_CACHE_MASK;
789 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
790 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
791 *flags |= BDRV_O_NO_FLUSH;
794 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
795 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
796 *flags |= BDRV_O_NOCACHE;
800 static void update_options_from_flags(QDict *options, int flags)
802 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
803 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
804 qbool_from_bool(flags & BDRV_O_NOCACHE));
806 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
807 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
808 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
812 static void bdrv_assign_node_name(BlockDriverState *bs,
813 const char *node_name,
816 char *gen_node_name = NULL;
819 node_name = gen_node_name = id_generate(ID_BLOCK);
820 } else if (!id_wellformed(node_name)) {
822 * Check for empty string or invalid characters, but not if it is
823 * generated (generated names use characters not available to the user)
825 error_setg(errp, "Invalid node name");
829 /* takes care of avoiding namespaces collisions */
830 if (blk_by_name(node_name)) {
831 error_setg(errp, "node-name=%s is conflicting with a device id",
836 /* takes care of avoiding duplicates node names */
837 if (bdrv_find_node(node_name)) {
838 error_setg(errp, "Duplicate node name");
842 /* copy node name into the bs and insert it into the graph list */
843 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
844 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
846 g_free(gen_node_name);
849 static QemuOptsList bdrv_runtime_opts = {
850 .name = "bdrv_common",
851 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
855 .type = QEMU_OPT_STRING,
856 .help = "Node name of the block device node",
860 .type = QEMU_OPT_STRING,
861 .help = "Block driver to use for the node",
864 .name = BDRV_OPT_CACHE_DIRECT,
865 .type = QEMU_OPT_BOOL,
866 .help = "Bypass software writeback cache on the host",
869 .name = BDRV_OPT_CACHE_NO_FLUSH,
870 .type = QEMU_OPT_BOOL,
871 .help = "Ignore flush requests",
873 { /* end of list */ }
878 * Common part for opening disk images and files
880 * Removes all processed options from *options.
882 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
883 QDict *options, Error **errp)
886 const char *filename;
887 const char *driver_name = NULL;
888 const char *node_name = NULL;
891 Error *local_err = NULL;
893 assert(bs->file == NULL);
894 assert(options != NULL && bs->options != options);
896 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
897 qemu_opts_absorb_qdict(opts, options, &local_err);
899 error_propagate(errp, local_err);
904 driver_name = qemu_opt_get(opts, "driver");
905 drv = bdrv_find_format(driver_name);
909 filename = file->bs->filename;
911 filename = qdict_get_try_str(options, "filename");
914 if (drv->bdrv_needs_filename && !filename) {
915 error_setg(errp, "The '%s' block driver requires a file name",
921 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
924 node_name = qemu_opt_get(opts, "node-name");
925 bdrv_assign_node_name(bs, node_name, &local_err);
927 error_propagate(errp, local_err);
932 bs->request_alignment = 512;
933 bs->zero_beyond_eof = true;
934 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
936 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
938 !bs->read_only && bdrv_is_whitelisted(drv, true)
939 ? "Driver '%s' can only be used for read-only devices"
940 : "Driver '%s' is not whitelisted",
946 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
947 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
948 if (!bs->read_only) {
949 bdrv_enable_copy_on_read(bs);
951 error_setg(errp, "Can't use copy-on-read on read-only device");
957 if (filename != NULL) {
958 pstrcpy(bs->filename, sizeof(bs->filename), filename);
960 bs->filename[0] = '\0';
962 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
965 bs->opaque = g_malloc0(drv->instance_size);
967 /* Apply cache mode options */
968 update_flags_from_options(&bs->open_flags, opts);
970 /* Open the image, either directly or using a protocol */
971 open_flags = bdrv_open_flags(bs, bs->open_flags);
972 if (drv->bdrv_file_open) {
973 assert(file == NULL);
974 assert(!drv->bdrv_needs_filename || filename != NULL);
975 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
978 error_setg(errp, "Can't use '%s' as a block driver for the "
979 "protocol level", drv->format_name);
984 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
989 error_propagate(errp, local_err);
990 } else if (bs->filename[0]) {
991 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
993 error_setg_errno(errp, -ret, "Could not open image");
998 ret = refresh_total_sectors(bs, bs->total_sectors);
1000 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1004 bdrv_refresh_limits(bs, &local_err);
1006 error_propagate(errp, local_err);
1011 assert(bdrv_opt_mem_align(bs) != 0);
1012 assert(bdrv_min_mem_align(bs) != 0);
1013 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
1015 qemu_opts_del(opts);
1024 qemu_opts_del(opts);
1028 static QDict *parse_json_filename(const char *filename, Error **errp)
1030 QObject *options_obj;
1034 ret = strstart(filename, "json:", &filename);
1037 options_obj = qobject_from_json(filename);
1039 error_setg(errp, "Could not parse the JSON options");
1043 if (qobject_type(options_obj) != QTYPE_QDICT) {
1044 qobject_decref(options_obj);
1045 error_setg(errp, "Invalid JSON object given");
1049 options = qobject_to_qdict(options_obj);
1050 qdict_flatten(options);
1055 static void parse_json_protocol(QDict *options, const char **pfilename,
1058 QDict *json_options;
1059 Error *local_err = NULL;
1061 /* Parse json: pseudo-protocol */
1062 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1066 json_options = parse_json_filename(*pfilename, &local_err);
1068 error_propagate(errp, local_err);
1072 /* Options given in the filename have lower priority than options
1073 * specified directly */
1074 qdict_join(options, json_options, false);
1075 QDECREF(json_options);
1080 * Fills in default options for opening images and converts the legacy
1081 * filename/flags pair to option QDict entries.
1082 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1083 * block driver has been specified explicitly.
1085 static int bdrv_fill_options(QDict **options, const char *filename,
1086 int *flags, Error **errp)
1088 const char *drvname;
1089 bool protocol = *flags & BDRV_O_PROTOCOL;
1090 bool parse_filename = false;
1091 BlockDriver *drv = NULL;
1092 Error *local_err = NULL;
1094 drvname = qdict_get_try_str(*options, "driver");
1096 drv = bdrv_find_format(drvname);
1098 error_setg(errp, "Unknown driver '%s'", drvname);
1101 /* If the user has explicitly specified the driver, this choice should
1102 * override the BDRV_O_PROTOCOL flag */
1103 protocol = drv->bdrv_file_open;
1107 *flags |= BDRV_O_PROTOCOL;
1109 *flags &= ~BDRV_O_PROTOCOL;
1112 /* Translate cache options from flags into options */
1113 update_options_from_flags(*options, *flags);
1115 /* Fetch the file name from the options QDict if necessary */
1116 if (protocol && filename) {
1117 if (!qdict_haskey(*options, "filename")) {
1118 qdict_put(*options, "filename", qstring_from_str(filename));
1119 parse_filename = true;
1121 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1127 /* Find the right block driver */
1128 filename = qdict_get_try_str(*options, "filename");
1130 if (!drvname && protocol) {
1132 drv = bdrv_find_protocol(filename, parse_filename, errp);
1137 drvname = drv->format_name;
1138 qdict_put(*options, "driver", qstring_from_str(drvname));
1140 error_setg(errp, "Must specify either driver or file");
1145 assert(drv || !protocol);
1147 /* Driver-specific filename parsing */
1148 if (drv && drv->bdrv_parse_filename && parse_filename) {
1149 drv->bdrv_parse_filename(filename, *options, &local_err);
1151 error_propagate(errp, local_err);
1155 if (!drv->bdrv_needs_filename) {
1156 qdict_del(*options, "filename");
1163 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1164 const char *child_name,
1165 const BdrvChildRole *child_role)
1167 BdrvChild *child = g_new(BdrvChild, 1);
1168 *child = (BdrvChild) {
1170 .name = g_strdup(child_name),
1174 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1179 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1180 BlockDriverState *child_bs,
1181 const char *child_name,
1182 const BdrvChildRole *child_role)
1184 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role);
1185 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1189 static void bdrv_detach_child(BdrvChild *child)
1191 if (child->next.le_prev) {
1192 QLIST_REMOVE(child, next);
1193 child->next.le_prev = NULL;
1195 QLIST_REMOVE(child, next_parent);
1196 g_free(child->name);
1200 void bdrv_root_unref_child(BdrvChild *child)
1202 BlockDriverState *child_bs;
1204 child_bs = child->bs;
1205 bdrv_detach_child(child);
1206 bdrv_unref(child_bs);
1209 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1211 if (child == NULL) {
1215 if (child->bs->inherits_from == parent) {
1216 child->bs->inherits_from = NULL;
1219 bdrv_root_unref_child(child);
1223 * Sets the backing file link of a BDS. A new reference is created; callers
1224 * which don't need their own reference any more must call bdrv_unref().
1226 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1229 bdrv_ref(backing_hd);
1233 assert(bs->backing_blocker);
1234 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1235 bdrv_unref_child(bs, bs->backing);
1236 } else if (backing_hd) {
1237 error_setg(&bs->backing_blocker,
1238 "node is used as backing hd of '%s'",
1239 bdrv_get_device_or_node_name(bs));
1243 error_free(bs->backing_blocker);
1244 bs->backing_blocker = NULL;
1248 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
1249 bs->open_flags &= ~BDRV_O_NO_BACKING;
1250 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1251 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1252 backing_hd->drv ? backing_hd->drv->format_name : "");
1254 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1255 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1256 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1257 bs->backing_blocker);
1259 bdrv_refresh_limits(bs, NULL);
1263 * Opens the backing file for a BlockDriverState if not yet open
1265 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1266 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1267 * itself, all options starting with "${bdref_key}." are considered part of the
1270 * TODO Can this be unified with bdrv_open_image()?
1272 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1273 const char *bdref_key, Error **errp)
1275 char *backing_filename = g_malloc0(PATH_MAX);
1276 char *bdref_key_dot;
1277 const char *reference = NULL;
1279 BlockDriverState *backing_hd;
1281 QDict *tmp_parent_options = NULL;
1282 Error *local_err = NULL;
1284 if (bs->backing != NULL) {
1288 /* NULL means an empty set of options */
1289 if (parent_options == NULL) {
1290 tmp_parent_options = qdict_new();
1291 parent_options = tmp_parent_options;
1294 bs->open_flags &= ~BDRV_O_NO_BACKING;
1296 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1297 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1298 g_free(bdref_key_dot);
1300 reference = qdict_get_try_str(parent_options, bdref_key);
1301 if (reference || qdict_haskey(options, "file.filename")) {
1302 backing_filename[0] = '\0';
1303 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1307 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1311 error_propagate(errp, local_err);
1317 if (!bs->drv || !bs->drv->supports_backing) {
1319 error_setg(errp, "Driver doesn't support backing files");
1324 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1325 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1329 ret = bdrv_open_inherit(&backing_hd,
1330 *backing_filename ? backing_filename : NULL,
1331 reference, options, 0, bs, &child_backing,
1334 bs->open_flags |= BDRV_O_NO_BACKING;
1335 error_prepend(errp, "Could not open backing file: ");
1339 /* Hook up the backing file link; drop our reference, bs owns the
1340 * backing_hd reference now */
1341 bdrv_set_backing_hd(bs, backing_hd);
1342 bdrv_unref(backing_hd);
1344 qdict_del(parent_options, bdref_key);
1347 g_free(backing_filename);
1348 QDECREF(tmp_parent_options);
1353 * Opens a disk image whose options are given as BlockdevRef in another block
1356 * If allow_none is true, no image will be opened if filename is false and no
1357 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1359 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1360 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1361 * itself, all options starting with "${bdref_key}." are considered part of the
1364 * The BlockdevRef will be removed from the options QDict.
1366 BdrvChild *bdrv_open_child(const char *filename,
1367 QDict *options, const char *bdref_key,
1368 BlockDriverState* parent,
1369 const BdrvChildRole *child_role,
1370 bool allow_none, Error **errp)
1372 BdrvChild *c = NULL;
1373 BlockDriverState *bs;
1374 QDict *image_options;
1376 char *bdref_key_dot;
1377 const char *reference;
1379 assert(child_role != NULL);
1381 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1382 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1383 g_free(bdref_key_dot);
1385 reference = qdict_get_try_str(options, bdref_key);
1386 if (!filename && !reference && !qdict_size(image_options)) {
1388 error_setg(errp, "A block device must be specified for \"%s\"",
1391 QDECREF(image_options);
1396 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1397 parent, child_role, errp);
1402 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
1405 qdict_del(options, bdref_key);
1409 static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
1410 QDict *snapshot_options, Error **errp)
1412 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1413 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1415 QemuOpts *opts = NULL;
1416 BlockDriverState *bs_snapshot;
1417 Error *local_err = NULL;
1420 /* if snapshot, we create a temporary backing file and open it
1421 instead of opening 'filename' directly */
1423 /* Get the required size from the image */
1424 total_size = bdrv_getlength(bs);
1425 if (total_size < 0) {
1427 error_setg_errno(errp, -total_size, "Could not get image size");
1431 /* Create the temporary image */
1432 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1434 error_setg_errno(errp, -ret, "Could not get temporary filename");
1438 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1440 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1441 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
1442 qemu_opts_del(opts);
1444 error_prepend(errp, "Could not create temporary overlay '%s': ",
1449 /* Prepare options QDict for the temporary file */
1450 qdict_put(snapshot_options, "file.driver",
1451 qstring_from_str("file"));
1452 qdict_put(snapshot_options, "file.filename",
1453 qstring_from_str(tmp_filename));
1454 qdict_put(snapshot_options, "driver",
1455 qstring_from_str("qcow2"));
1457 bs_snapshot = bdrv_new();
1459 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1461 snapshot_options = NULL;
1463 error_propagate(errp, local_err);
1467 bdrv_append(bs_snapshot, bs);
1470 QDECREF(snapshot_options);
1471 g_free(tmp_filename);
1476 * Opens a disk image (raw, qcow2, vmdk, ...)
1478 * options is a QDict of options to pass to the block drivers, or NULL for an
1479 * empty set of options. The reference to the QDict belongs to the block layer
1480 * after the call (even on failure), so if the caller intends to reuse the
1481 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1483 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1484 * If it is not NULL, the referenced BDS will be reused.
1486 * The reference parameter may be used to specify an existing block device which
1487 * should be opened. If specified, neither options nor a filename may be given,
1488 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1490 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1491 const char *reference, QDict *options, int flags,
1492 BlockDriverState *parent,
1493 const BdrvChildRole *child_role, Error **errp)
1496 BdrvChild *file = NULL;
1497 BlockDriverState *bs;
1498 BlockDriver *drv = NULL;
1499 const char *drvname;
1500 const char *backing;
1501 Error *local_err = NULL;
1502 QDict *snapshot_options = NULL;
1503 int snapshot_flags = 0;
1506 assert(!child_role || !flags);
1507 assert(!child_role == !parent);
1510 bool options_non_empty = options ? qdict_size(options) : false;
1514 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1515 "another block device");
1519 if (filename || options_non_empty) {
1520 error_setg(errp, "Cannot reference an existing block device with "
1521 "additional options or a new filename");
1525 bs = bdrv_lookup_bs(reference, reference, errp);
1530 if (bs->throttle_state) {
1531 error_setg(errp, "Cannot reference an existing block device for "
1532 "which I/O throttling is enabled");
1547 /* NULL means an empty set of options */
1548 if (options == NULL) {
1549 options = qdict_new();
1552 /* json: syntax counts as explicit options, as if in the QDict */
1553 parse_json_protocol(options, &filename, &local_err);
1559 bs->explicit_options = qdict_clone_shallow(options);
1562 bs->inherits_from = parent;
1563 child_role->inherit_options(&flags, options,
1564 parent->open_flags, parent->options);
1567 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
1572 bs->open_flags = flags;
1573 bs->options = options;
1574 options = qdict_clone_shallow(options);
1576 /* Find the right image format driver */
1577 drvname = qdict_get_try_str(options, "driver");
1579 drv = bdrv_find_format(drvname);
1581 error_setg(errp, "Unknown driver: '%s'", drvname);
1587 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1589 backing = qdict_get_try_str(options, "backing");
1590 if (backing && *backing == '\0') {
1591 flags |= BDRV_O_NO_BACKING;
1592 qdict_del(options, "backing");
1595 /* Open image file without format layer */
1596 if ((flags & BDRV_O_PROTOCOL) == 0) {
1597 if (flags & BDRV_O_RDWR) {
1598 flags |= BDRV_O_ALLOW_RDWR;
1600 if (flags & BDRV_O_SNAPSHOT) {
1601 snapshot_options = qdict_new();
1602 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1604 bdrv_backing_options(&flags, options, flags, options);
1607 bs->open_flags = flags;
1609 file = bdrv_open_child(filename, options, "file", bs,
1610 &child_file, true, &local_err);
1617 /* Image format probing */
1620 ret = find_image_format(file->bs, filename, &drv, &local_err);
1625 * This option update would logically belong in bdrv_fill_options(),
1626 * but we first need to open bs->file for the probing to work, while
1627 * opening bs->file already requires the (mostly) final set of options
1628 * so that cache mode etc. can be inherited.
1630 * Adding the driver later is somewhat ugly, but it's not an option
1631 * that would ever be inherited, so it's correct. We just need to make
1632 * sure to update both bs->options (which has the full effective
1633 * options for bs) and options (which has file.* already removed).
1635 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1636 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1638 error_setg(errp, "Must specify either driver or file");
1643 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1644 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1645 /* file must be NULL if a protocol BDS is about to be created
1646 * (the inverse results in an error message from bdrv_open_common()) */
1647 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1649 /* Open the image */
1650 ret = bdrv_open_common(bs, file, options, &local_err);
1655 if (file && (bs->file != file)) {
1656 bdrv_unref_child(bs, file);
1660 /* If there is a backing file, use it */
1661 if ((flags & BDRV_O_NO_BACKING) == 0) {
1662 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
1664 goto close_and_fail;
1668 bdrv_refresh_filename(bs);
1670 /* Check if any unknown options were used */
1671 if (options && (qdict_size(options) != 0)) {
1672 const QDictEntry *entry = qdict_first(options);
1673 if (flags & BDRV_O_PROTOCOL) {
1674 error_setg(errp, "Block protocol '%s' doesn't support the option "
1675 "'%s'", drv->format_name, entry->key);
1678 "Block format '%s' does not support the option '%s'",
1679 drv->format_name, entry->key);
1683 goto close_and_fail;
1686 if (!bdrv_key_required(bs)) {
1688 blk_dev_change_media_cb(bs->blk, true);
1690 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1691 && !runstate_check(RUN_STATE_INMIGRATE)
1692 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1694 "Guest must be stopped for opening of encrypted image");
1696 goto close_and_fail;
1702 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1703 * temporary snapshot afterwards. */
1704 if (snapshot_flags) {
1705 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options,
1707 snapshot_options = NULL;
1709 goto close_and_fail;
1717 bdrv_unref_child(bs, file);
1719 QDECREF(snapshot_options);
1720 QDECREF(bs->explicit_options);
1721 QDECREF(bs->options);
1725 /* If *pbs is NULL, a new BDS has been created in this function and
1726 needs to be freed now. Otherwise, it does not need to be closed,
1727 since it has not really been opened yet. */
1731 error_propagate(errp, local_err);
1736 /* See fail path, but now the BDS has to be always closed */
1742 QDECREF(snapshot_options);
1745 error_propagate(errp, local_err);
1750 int bdrv_open(BlockDriverState **pbs, const char *filename,
1751 const char *reference, QDict *options, int flags, Error **errp)
1753 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1757 typedef struct BlockReopenQueueEntry {
1759 BDRVReopenState state;
1760 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1761 } BlockReopenQueueEntry;
1764 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1765 * reopen of multiple devices.
1767 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1768 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1769 * be created and initialized. This newly created BlockReopenQueue should be
1770 * passed back in for subsequent calls that are intended to be of the same
1773 * bs is the BlockDriverState to add to the reopen queue.
1775 * options contains the changed options for the associated bs
1776 * (the BlockReopenQueue takes ownership)
1778 * flags contains the open flags for the associated bs
1780 * returns a pointer to bs_queue, which is either the newly allocated
1781 * bs_queue, or the existing bs_queue being used.
1784 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1785 BlockDriverState *bs,
1788 const BdrvChildRole *role,
1789 QDict *parent_options,
1794 BlockReopenQueueEntry *bs_entry;
1796 QDict *old_options, *explicit_options;
1798 if (bs_queue == NULL) {
1799 bs_queue = g_new0(BlockReopenQueue, 1);
1800 QSIMPLEQ_INIT(bs_queue);
1804 options = qdict_new();
1808 * Precedence of options:
1809 * 1. Explicitly passed in options (highest)
1810 * 2. Set in flags (only for top level)
1811 * 3. Retained from explicitly set options of bs
1812 * 4. Inherited from parent node
1813 * 5. Retained from effective options of bs
1816 if (!parent_options) {
1818 * Any setting represented by flags is always updated. If the
1819 * corresponding QDict option is set, it takes precedence. Otherwise
1820 * the flag is translated into a QDict option. The old setting of bs is
1823 update_options_from_flags(options, flags);
1826 /* Old explicitly set values (don't overwrite by inherited value) */
1827 old_options = qdict_clone_shallow(bs->explicit_options);
1828 bdrv_join_options(bs, options, old_options);
1829 QDECREF(old_options);
1831 explicit_options = qdict_clone_shallow(options);
1833 /* Inherit from parent node */
1834 if (parent_options) {
1836 role->inherit_options(&flags, options, parent_flags, parent_options);
1839 /* Old values are used for options that aren't set yet */
1840 old_options = qdict_clone_shallow(bs->options);
1841 bdrv_join_options(bs, options, old_options);
1842 QDECREF(old_options);
1844 /* bdrv_open() masks this flag out */
1845 flags &= ~BDRV_O_PROTOCOL;
1847 QLIST_FOREACH(child, &bs->children, next) {
1848 QDict *new_child_options;
1849 char *child_key_dot;
1851 /* reopen can only change the options of block devices that were
1852 * implicitly created and inherited options. For other (referenced)
1853 * block devices, a syntax like "backing.foo" results in an error. */
1854 if (child->bs->inherits_from != bs) {
1858 child_key_dot = g_strdup_printf("%s.", child->name);
1859 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1860 g_free(child_key_dot);
1862 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1863 child->role, options, flags);
1866 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1867 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1869 bs_entry->state.bs = bs;
1870 bs_entry->state.options = options;
1871 bs_entry->state.explicit_options = explicit_options;
1872 bs_entry->state.flags = flags;
1877 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1878 BlockDriverState *bs,
1879 QDict *options, int flags)
1881 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1886 * Reopen multiple BlockDriverStates atomically & transactionally.
1888 * The queue passed in (bs_queue) must have been built up previous
1889 * via bdrv_reopen_queue().
1891 * Reopens all BDS specified in the queue, with the appropriate
1892 * flags. All devices are prepared for reopen, and failure of any
1893 * device will cause all device changes to be abandonded, and intermediate
1896 * If all devices prepare successfully, then the changes are committed
1900 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1903 BlockReopenQueueEntry *bs_entry, *next;
1904 Error *local_err = NULL;
1906 assert(bs_queue != NULL);
1910 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1911 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1912 error_propagate(errp, local_err);
1915 bs_entry->prepared = true;
1918 /* If we reach this point, we have success and just need to apply the
1921 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1922 bdrv_reopen_commit(&bs_entry->state);
1928 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1929 if (ret && bs_entry->prepared) {
1930 bdrv_reopen_abort(&bs_entry->state);
1932 QDECREF(bs_entry->state.explicit_options);
1934 QDECREF(bs_entry->state.options);
1942 /* Reopen a single BlockDriverState with the specified flags. */
1943 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1946 Error *local_err = NULL;
1947 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1949 ret = bdrv_reopen_multiple(queue, &local_err);
1950 if (local_err != NULL) {
1951 error_propagate(errp, local_err);
1958 * Prepares a BlockDriverState for reopen. All changes are staged in the
1959 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1960 * the block driver layer .bdrv_reopen_prepare()
1962 * bs is the BlockDriverState to reopen
1963 * flags are the new open flags
1964 * queue is the reopen queue
1966 * Returns 0 on success, non-zero on error. On error errp will be set
1969 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1970 * It is the responsibility of the caller to then call the abort() or
1971 * commit() for any other BDS that have been left in a prepare() state
1974 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1978 Error *local_err = NULL;
1983 assert(reopen_state != NULL);
1984 assert(reopen_state->bs->drv != NULL);
1985 drv = reopen_state->bs->drv;
1987 /* Process generic block layer options */
1988 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1989 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
1991 error_propagate(errp, local_err);
1996 update_flags_from_options(&reopen_state->flags, opts);
1998 /* node-name and driver must be unchanged. Put them back into the QDict, so
1999 * that they are checked at the end of this function. */
2000 value = qemu_opt_get(opts, "node-name");
2002 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2005 value = qemu_opt_get(opts, "driver");
2007 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2010 /* if we are to stay read-only, do not allow permission change
2012 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2013 reopen_state->flags & BDRV_O_RDWR) {
2014 error_setg(errp, "Node '%s' is read only",
2015 bdrv_get_device_or_node_name(reopen_state->bs));
2020 ret = bdrv_flush(reopen_state->bs);
2022 error_setg_errno(errp, -ret, "Error flushing drive");
2026 if (drv->bdrv_reopen_prepare) {
2027 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2029 if (local_err != NULL) {
2030 error_propagate(errp, local_err);
2032 error_setg(errp, "failed while preparing to reopen image '%s'",
2033 reopen_state->bs->filename);
2038 /* It is currently mandatory to have a bdrv_reopen_prepare()
2039 * handler for each supported drv. */
2040 error_setg(errp, "Block format '%s' used by node '%s' "
2041 "does not support reopening files", drv->format_name,
2042 bdrv_get_device_or_node_name(reopen_state->bs));
2047 /* Options that are not handled are only okay if they are unchanged
2048 * compared to the old state. It is expected that some options are only
2049 * used for the initial open, but not reopen (e.g. filename) */
2050 if (qdict_size(reopen_state->options)) {
2051 const QDictEntry *entry = qdict_first(reopen_state->options);
2054 QString *new_obj = qobject_to_qstring(entry->value);
2055 const char *new = qstring_get_str(new_obj);
2056 const char *old = qdict_get_try_str(reopen_state->bs->options,
2059 if (!old || strcmp(new, old)) {
2060 error_setg(errp, "Cannot change the option '%s'", entry->key);
2064 } while ((entry = qdict_next(reopen_state->options, entry)));
2070 qemu_opts_del(opts);
2075 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2076 * makes them final by swapping the staging BlockDriverState contents into
2077 * the active BlockDriverState contents.
2079 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2083 assert(reopen_state != NULL);
2084 drv = reopen_state->bs->drv;
2085 assert(drv != NULL);
2087 /* If there are any driver level actions to take */
2088 if (drv->bdrv_reopen_commit) {
2089 drv->bdrv_reopen_commit(reopen_state);
2092 /* set BDS specific flags now */
2093 QDECREF(reopen_state->bs->explicit_options);
2095 reopen_state->bs->explicit_options = reopen_state->explicit_options;
2096 reopen_state->bs->open_flags = reopen_state->flags;
2097 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
2099 bdrv_refresh_limits(reopen_state->bs, NULL);
2103 * Abort the reopen, and delete and free the staged changes in
2106 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2110 assert(reopen_state != NULL);
2111 drv = reopen_state->bs->drv;
2112 assert(drv != NULL);
2114 if (drv->bdrv_reopen_abort) {
2115 drv->bdrv_reopen_abort(reopen_state);
2118 QDECREF(reopen_state->explicit_options);
2122 static void bdrv_close(BlockDriverState *bs)
2124 BdrvAioNotifier *ban, *ban_next;
2128 /* Disable I/O limits and drain all pending throttled requests */
2129 if (bs->throttle_state) {
2130 bdrv_io_limits_disable(bs);
2133 bdrv_drained_begin(bs); /* complete I/O */
2135 bdrv_drain(bs); /* in case flush left pending I/O */
2137 bdrv_release_named_dirty_bitmaps(bs);
2138 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2141 blk_dev_change_media_cb(bs->blk, false);
2145 BdrvChild *child, *next;
2147 bs->drv->bdrv_close(bs);
2150 bdrv_set_backing_hd(bs, NULL);
2152 if (bs->file != NULL) {
2153 bdrv_unref_child(bs, bs->file);
2157 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
2158 /* TODO Remove bdrv_unref() from drivers' close function and use
2159 * bdrv_unref_child() here */
2160 if (child->bs->inherits_from == bs) {
2161 child->bs->inherits_from = NULL;
2163 bdrv_detach_child(child);
2168 bs->copy_on_read = 0;
2169 bs->backing_file[0] = '\0';
2170 bs->backing_format[0] = '\0';
2171 bs->total_sectors = 0;
2175 bs->zero_beyond_eof = false;
2176 QDECREF(bs->options);
2177 QDECREF(bs->explicit_options);
2179 QDECREF(bs->full_open_options);
2180 bs->full_open_options = NULL;
2183 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2186 QLIST_INIT(&bs->aio_notifiers);
2187 bdrv_drained_end(bs);
2190 void bdrv_close_all(void)
2192 BlockDriverState *bs;
2193 AioContext *aio_context;
2195 /* Drop references from requests still in flight, such as canceled block
2196 * jobs whose AIO context has not been polled yet */
2199 blk_remove_all_bs();
2200 blockdev_close_all_bdrv_states();
2202 /* Cancel all block jobs */
2203 while (!QTAILQ_EMPTY(&all_bdrv_states)) {
2204 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
2205 aio_context = bdrv_get_aio_context(bs);
2207 aio_context_acquire(aio_context);
2209 block_job_cancel_sync(bs->job);
2210 aio_context_release(aio_context);
2213 aio_context_release(aio_context);
2216 /* All the remaining BlockDriverStates are referenced directly or
2217 * indirectly from block jobs, so there needs to be at least one BDS
2218 * directly used by a block job */
2223 /* Fields that need to stay with the top-level BDS */
2224 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2225 BlockDriverState *bs_src)
2227 /* move some fields that need to stay attached to the device */
2230 static void change_parent_backing_link(BlockDriverState *from,
2231 BlockDriverState *to)
2233 BdrvChild *c, *next;
2236 /* FIXME We bypass blk_set_bs(), so we need to make these updates
2237 * manually. The root problem is not in this change function, but the
2238 * existence of BlockDriverState.blk. */
2239 to->blk = from->blk;
2243 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2244 assert(c->role != &child_backing);
2246 QLIST_REMOVE(c, next_parent);
2247 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2253 static void swap_feature_fields(BlockDriverState *bs_top,
2254 BlockDriverState *bs_new)
2256 BlockDriverState tmp;
2258 bdrv_move_feature_fields(&tmp, bs_top);
2259 bdrv_move_feature_fields(bs_top, bs_new);
2260 bdrv_move_feature_fields(bs_new, &tmp);
2262 assert(!bs_new->throttle_state);
2263 if (bs_top->throttle_state) {
2264 assert(bs_top->io_limits_enabled);
2265 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2266 bdrv_io_limits_disable(bs_top);
2271 * Add new bs contents at the top of an image chain while the chain is
2272 * live, while keeping required fields on the top layer.
2274 * This will modify the BlockDriverState fields, and swap contents
2275 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2277 * bs_new must not be attached to a BlockBackend.
2279 * This function does not create any image files.
2281 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2282 * that's what the callers commonly need. bs_new will be referenced by the old
2283 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2284 * reference of its own, it must call bdrv_ref().
2286 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2288 assert(!bdrv_requests_pending(bs_top));
2289 assert(!bdrv_requests_pending(bs_new));
2292 change_parent_backing_link(bs_top, bs_new);
2294 /* Some fields always stay on top of the backing file chain */
2295 swap_feature_fields(bs_top, bs_new);
2297 bdrv_set_backing_hd(bs_new, bs_top);
2300 /* bs_new is now referenced by its new parents, we don't need the
2301 * additional reference any more. */
2305 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2307 assert(!bdrv_requests_pending(old));
2308 assert(!bdrv_requests_pending(new));
2313 /* As long as these fields aren't in BlockBackend, but in the top-level
2314 * BlockDriverState, it's not possible for a BDS to have two BBs.
2316 * We really want to copy the fields from old to new, but we go for a
2317 * swap instead so that pointers aren't duplicated and cause trouble.
2318 * (Also, bdrv_swap() used to do the same.) */
2320 swap_feature_fields(old, new);
2322 change_parent_backing_link(old, new);
2324 /* Change backing files if a previously independent node is added to the
2325 * chain. For active commit, we replace top by its own (indirect) backing
2326 * file and don't do anything here so we don't build a loop. */
2327 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2328 bdrv_set_backing_hd(new, backing_bs(old));
2329 bdrv_set_backing_hd(old, NULL);
2335 static void bdrv_delete(BlockDriverState *bs)
2338 assert(bdrv_op_blocker_is_empty(bs));
2339 assert(!bs->refcnt);
2345 /* remove from list, if necessary */
2346 if (bs->node_name[0] != '\0') {
2347 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2349 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2355 * Run consistency checks on an image
2357 * Returns 0 if the check could be completed (it doesn't mean that the image is
2358 * free of errors) or -errno when an internal error occurred. The results of the
2359 * check are stored in res.
2361 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2363 if (bs->drv == NULL) {
2366 if (bs->drv->bdrv_check == NULL) {
2370 memset(res, 0, sizeof(*res));
2371 return bs->drv->bdrv_check(bs, res, fix);
2374 #define COMMIT_BUF_SECTORS 2048
2376 /* commit COW file into the raw image */
2377 int bdrv_commit(BlockDriverState *bs)
2379 BlockDriver *drv = bs->drv;
2380 int64_t sector, total_sectors, length, backing_length;
2381 int n, ro, open_flags;
2383 uint8_t *buf = NULL;
2392 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2393 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2397 ro = bs->backing->bs->read_only;
2398 open_flags = bs->backing->bs->open_flags;
2401 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2406 length = bdrv_getlength(bs);
2412 backing_length = bdrv_getlength(bs->backing->bs);
2413 if (backing_length < 0) {
2414 ret = backing_length;
2418 /* If our top snapshot is larger than the backing file image,
2419 * grow the backing file image if possible. If not possible,
2420 * we must return an error */
2421 if (length > backing_length) {
2422 ret = bdrv_truncate(bs->backing->bs, length);
2428 total_sectors = length >> BDRV_SECTOR_BITS;
2430 /* qemu_try_blockalign() for bs will choose an alignment that works for
2431 * bs->backing->bs as well, so no need to compare the alignment manually. */
2432 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2438 for (sector = 0; sector < total_sectors; sector += n) {
2439 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2444 ret = bdrv_read(bs, sector, buf, n);
2449 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2456 if (drv->bdrv_make_empty) {
2457 ret = drv->bdrv_make_empty(bs);
2465 * Make sure all data we wrote to the backing device is actually
2469 bdrv_flush(bs->backing->bs);
2477 /* ignoring error return here */
2478 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2487 * -EINVAL - backing format specified, but no file
2488 * -ENOSPC - can't update the backing file because no space is left in the
2490 * -ENOTSUP - format driver doesn't support changing the backing file
2492 int bdrv_change_backing_file(BlockDriverState *bs,
2493 const char *backing_file, const char *backing_fmt)
2495 BlockDriver *drv = bs->drv;
2498 /* Backing file format doesn't make sense without a backing file */
2499 if (backing_fmt && !backing_file) {
2503 if (drv->bdrv_change_backing_file != NULL) {
2504 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2510 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2511 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2517 * Finds the image layer in the chain that has 'bs' as its backing file.
2519 * active is the current topmost image.
2521 * Returns NULL if bs is not found in active's image chain,
2522 * or if active == bs.
2524 * Returns the bottommost base image if bs == NULL.
2526 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2527 BlockDriverState *bs)
2529 while (active && bs != backing_bs(active)) {
2530 active = backing_bs(active);
2536 /* Given a BDS, searches for the base layer. */
2537 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2539 return bdrv_find_overlay(bs, NULL);
2543 * Drops images above 'base' up to and including 'top', and sets the image
2544 * above 'top' to have base as its backing file.
2546 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2547 * information in 'bs' can be properly updated.
2549 * E.g., this will convert the following chain:
2550 * bottom <- base <- intermediate <- top <- active
2554 * bottom <- base <- active
2556 * It is allowed for bottom==base, in which case it converts:
2558 * base <- intermediate <- top <- active
2564 * If backing_file_str is non-NULL, it will be used when modifying top's
2565 * overlay image metadata.
2568 * if active == top, that is considered an error
2571 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2572 BlockDriverState *base, const char *backing_file_str)
2574 BlockDriverState *new_top_bs = NULL;
2577 if (!top->drv || !base->drv) {
2581 new_top_bs = bdrv_find_overlay(active, top);
2583 if (new_top_bs == NULL) {
2584 /* we could not find the image above 'top', this is an error */
2588 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2589 * to do, no intermediate images */
2590 if (backing_bs(new_top_bs) == base) {
2595 /* Make sure that base is in the backing chain of top */
2596 if (!bdrv_chain_contains(top, base)) {
2600 /* success - we can delete the intermediate states, and link top->base */
2601 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2602 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2603 base->drv ? base->drv->format_name : "");
2607 bdrv_set_backing_hd(new_top_bs, base);
2615 * Truncate file to 'offset' bytes (needed only for file protocols)
2617 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2619 BlockDriver *drv = bs->drv;
2623 if (!drv->bdrv_truncate)
2628 ret = drv->bdrv_truncate(bs, offset);
2630 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2631 bdrv_dirty_bitmap_truncate(bs);
2633 blk_dev_resize_cb(bs->blk);
2640 * Length of a allocated file in bytes. Sparse files are counted by actual
2641 * allocated space. Return < 0 if error or unknown.
2643 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2645 BlockDriver *drv = bs->drv;
2649 if (drv->bdrv_get_allocated_file_size) {
2650 return drv->bdrv_get_allocated_file_size(bs);
2653 return bdrv_get_allocated_file_size(bs->file->bs);
2659 * Return number of sectors on success, -errno on error.
2661 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2663 BlockDriver *drv = bs->drv;
2668 if (drv->has_variable_length) {
2669 int ret = refresh_total_sectors(bs, bs->total_sectors);
2674 return bs->total_sectors;
2678 * Return length in bytes on success, -errno on error.
2679 * The length is always a multiple of BDRV_SECTOR_SIZE.
2681 int64_t bdrv_getlength(BlockDriverState *bs)
2683 int64_t ret = bdrv_nb_sectors(bs);
2685 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2686 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2689 /* return 0 as number of sectors if no device present or error */
2690 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2692 int64_t nb_sectors = bdrv_nb_sectors(bs);
2694 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2697 int bdrv_is_read_only(BlockDriverState *bs)
2699 return bs->read_only;
2702 int bdrv_is_sg(BlockDriverState *bs)
2707 int bdrv_is_encrypted(BlockDriverState *bs)
2709 if (bs->backing && bs->backing->bs->encrypted) {
2712 return bs->encrypted;
2715 int bdrv_key_required(BlockDriverState *bs)
2717 BdrvChild *backing = bs->backing;
2719 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2722 return (bs->encrypted && !bs->valid_key);
2725 int bdrv_set_key(BlockDriverState *bs, const char *key)
2728 if (bs->backing && bs->backing->bs->encrypted) {
2729 ret = bdrv_set_key(bs->backing->bs, key);
2735 if (!bs->encrypted) {
2737 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2740 ret = bs->drv->bdrv_set_key(bs, key);
2743 } else if (!bs->valid_key) {
2746 /* call the change callback now, we skipped it on open */
2747 blk_dev_change_media_cb(bs->blk, true);
2754 * Provide an encryption key for @bs.
2755 * If @key is non-null:
2756 * If @bs is not encrypted, fail.
2757 * Else if the key is invalid, fail.
2758 * Else set @bs's key to @key, replacing the existing key, if any.
2760 * If @bs is encrypted and still lacks a key, fail.
2762 * On failure, store an error object through @errp if non-null.
2764 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2767 if (!bdrv_is_encrypted(bs)) {
2768 error_setg(errp, "Node '%s' is not encrypted",
2769 bdrv_get_device_or_node_name(bs));
2770 } else if (bdrv_set_key(bs, key) < 0) {
2771 error_setg(errp, QERR_INVALID_PASSWORD);
2774 if (bdrv_key_required(bs)) {
2775 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2776 "'%s' (%s) is encrypted",
2777 bdrv_get_device_or_node_name(bs),
2778 bdrv_get_encrypted_filename(bs));
2783 const char *bdrv_get_format_name(BlockDriverState *bs)
2785 return bs->drv ? bs->drv->format_name : NULL;
2788 static int qsort_strcmp(const void *a, const void *b)
2790 return strcmp(a, b);
2793 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2799 const char **formats = NULL;
2801 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2802 if (drv->format_name) {
2805 while (formats && i && !found) {
2806 found = !strcmp(formats[--i], drv->format_name);
2810 formats = g_renew(const char *, formats, count + 1);
2811 formats[count++] = drv->format_name;
2816 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2818 for (i = 0; i < count; i++) {
2819 it(opaque, formats[i]);
2825 /* This function is to find a node in the bs graph */
2826 BlockDriverState *bdrv_find_node(const char *node_name)
2828 BlockDriverState *bs;
2832 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2833 if (!strcmp(node_name, bs->node_name)) {
2840 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2841 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2843 BlockDeviceInfoList *list, *entry;
2844 BlockDriverState *bs;
2847 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2848 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
2850 qapi_free_BlockDeviceInfoList(list);
2853 entry = g_malloc0(sizeof(*entry));
2854 entry->value = info;
2862 BlockDriverState *bdrv_lookup_bs(const char *device,
2863 const char *node_name,
2867 BlockDriverState *bs;
2870 blk = blk_by_name(device);
2875 error_setg(errp, "Device '%s' has no medium", device);
2883 bs = bdrv_find_node(node_name);
2890 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2891 device ? device : "",
2892 node_name ? node_name : "");
2896 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2897 * return false. If either argument is NULL, return false. */
2898 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2900 while (top && top != base) {
2901 top = backing_bs(top);
2907 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2910 return QTAILQ_FIRST(&graph_bdrv_states);
2912 return QTAILQ_NEXT(bs, node_list);
2915 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
2916 * the monitor or attached to a BlockBackend */
2917 BlockDriverState *bdrv_next(BlockDriverState *bs)
2919 if (!bs || bs->blk) {
2920 bs = blk_next_root_bs(bs);
2926 /* Ignore all BDSs that are attached to a BlockBackend here; they have been
2927 * handled by the above block already */
2929 bs = bdrv_next_monitor_owned(bs);
2930 } while (bs && bs->blk);
2934 const char *bdrv_get_node_name(const BlockDriverState *bs)
2936 return bs->node_name;
2939 /* TODO check what callers really want: bs->node_name or blk_name() */
2940 const char *bdrv_get_device_name(const BlockDriverState *bs)
2942 return bs->blk ? blk_name(bs->blk) : "";
2945 /* This can be used to identify nodes that might not have a device
2946 * name associated. Since node and device names live in the same
2947 * namespace, the result is unambiguous. The exception is if both are
2948 * absent, then this returns an empty (non-null) string. */
2949 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2951 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2954 int bdrv_get_flags(BlockDriverState *bs)
2956 return bs->open_flags;
2959 int bdrv_has_zero_init_1(BlockDriverState *bs)
2964 int bdrv_has_zero_init(BlockDriverState *bs)
2968 /* If BS is a copy on write image, it is initialized to
2969 the contents of the base image, which may not be zeroes. */
2973 if (bs->drv->bdrv_has_zero_init) {
2974 return bs->drv->bdrv_has_zero_init(bs);
2981 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2983 BlockDriverInfo bdi;
2989 if (bdrv_get_info(bs, &bdi) == 0) {
2990 return bdi.unallocated_blocks_are_zero;
2996 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2998 BlockDriverInfo bdi;
3000 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
3004 if (bdrv_get_info(bs, &bdi) == 0) {
3005 return bdi.can_write_zeroes_with_unmap;
3011 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3013 if (bs->backing && bs->backing->bs->encrypted)
3014 return bs->backing_file;
3015 else if (bs->encrypted)
3016 return bs->filename;
3021 void bdrv_get_backing_filename(BlockDriverState *bs,
3022 char *filename, int filename_size)
3024 pstrcpy(filename, filename_size, bs->backing_file);
3027 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3029 BlockDriver *drv = bs->drv;
3032 if (!drv->bdrv_get_info)
3034 memset(bdi, 0, sizeof(*bdi));
3035 return drv->bdrv_get_info(bs, bdi);
3038 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3040 BlockDriver *drv = bs->drv;
3041 if (drv && drv->bdrv_get_specific_info) {
3042 return drv->bdrv_get_specific_info(bs);
3047 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
3049 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3053 bs->drv->bdrv_debug_event(bs, event);
3056 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3059 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3060 bs = bs->file ? bs->file->bs : NULL;
3063 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3064 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3070 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3072 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3073 bs = bs->file ? bs->file->bs : NULL;
3076 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3077 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3083 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3085 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3086 bs = bs->file ? bs->file->bs : NULL;
3089 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3090 return bs->drv->bdrv_debug_resume(bs, tag);
3096 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3098 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3099 bs = bs->file ? bs->file->bs : NULL;
3102 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3103 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3109 int bdrv_is_snapshot(BlockDriverState *bs)
3111 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3114 /* backing_file can either be relative, or absolute, or a protocol. If it is
3115 * relative, it must be relative to the chain. So, passing in bs->filename
3116 * from a BDS as backing_file should not be done, as that may be relative to
3117 * the CWD rather than the chain. */
3118 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3119 const char *backing_file)
3121 char *filename_full = NULL;
3122 char *backing_file_full = NULL;
3123 char *filename_tmp = NULL;
3124 int is_protocol = 0;
3125 BlockDriverState *curr_bs = NULL;
3126 BlockDriverState *retval = NULL;
3128 if (!bs || !bs->drv || !backing_file) {
3132 filename_full = g_malloc(PATH_MAX);
3133 backing_file_full = g_malloc(PATH_MAX);
3134 filename_tmp = g_malloc(PATH_MAX);
3136 is_protocol = path_has_protocol(backing_file);
3138 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3140 /* If either of the filename paths is actually a protocol, then
3141 * compare unmodified paths; otherwise make paths relative */
3142 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3143 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3144 retval = curr_bs->backing->bs;
3148 /* If not an absolute filename path, make it relative to the current
3149 * image's filename path */
3150 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3153 /* We are going to compare absolute pathnames */
3154 if (!realpath(filename_tmp, filename_full)) {
3158 /* We need to make sure the backing filename we are comparing against
3159 * is relative to the current image filename (or absolute) */
3160 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3161 curr_bs->backing_file);
3163 if (!realpath(filename_tmp, backing_file_full)) {
3167 if (strcmp(backing_file_full, filename_full) == 0) {
3168 retval = curr_bs->backing->bs;
3174 g_free(filename_full);
3175 g_free(backing_file_full);
3176 g_free(filename_tmp);
3180 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3190 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3193 void bdrv_init(void)
3195 module_call_init(MODULE_INIT_BLOCK);
3198 void bdrv_init_with_whitelist(void)
3200 use_bdrv_whitelist = 1;
3204 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3206 Error *local_err = NULL;
3213 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
3216 bs->open_flags &= ~BDRV_O_INACTIVE;
3218 if (bs->drv->bdrv_invalidate_cache) {
3219 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3220 } else if (bs->file) {
3221 bdrv_invalidate_cache(bs->file->bs, &local_err);
3224 bs->open_flags |= BDRV_O_INACTIVE;
3225 error_propagate(errp, local_err);
3229 ret = refresh_total_sectors(bs, bs->total_sectors);
3231 bs->open_flags |= BDRV_O_INACTIVE;
3232 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3237 void bdrv_invalidate_cache_all(Error **errp)
3239 BlockDriverState *bs = NULL;
3240 Error *local_err = NULL;
3242 while ((bs = bdrv_next(bs)) != NULL) {
3243 AioContext *aio_context = bdrv_get_aio_context(bs);
3245 aio_context_acquire(aio_context);
3246 bdrv_invalidate_cache(bs, &local_err);
3247 aio_context_release(aio_context);
3249 error_propagate(errp, local_err);
3255 static int bdrv_inactivate(BlockDriverState *bs)
3259 if (bs->drv->bdrv_inactivate) {
3260 ret = bs->drv->bdrv_inactivate(bs);
3266 bs->open_flags |= BDRV_O_INACTIVE;
3270 int bdrv_inactivate_all(void)
3272 BlockDriverState *bs = NULL;
3275 while ((bs = bdrv_next(bs)) != NULL) {
3276 AioContext *aio_context = bdrv_get_aio_context(bs);
3278 aio_context_acquire(aio_context);
3279 ret = bdrv_inactivate(bs);
3280 aio_context_release(aio_context);
3289 /**************************************************************/
3290 /* removable device support */
3293 * Return TRUE if the media is present
3295 bool bdrv_is_inserted(BlockDriverState *bs)
3297 BlockDriver *drv = bs->drv;
3303 if (drv->bdrv_is_inserted) {
3304 return drv->bdrv_is_inserted(bs);
3306 QLIST_FOREACH(child, &bs->children, next) {
3307 if (!bdrv_is_inserted(child->bs)) {
3315 * Return whether the media changed since the last call to this
3316 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3318 int bdrv_media_changed(BlockDriverState *bs)
3320 BlockDriver *drv = bs->drv;
3322 if (drv && drv->bdrv_media_changed) {
3323 return drv->bdrv_media_changed(bs);
3329 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3331 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3333 BlockDriver *drv = bs->drv;
3334 const char *device_name;
3336 if (drv && drv->bdrv_eject) {
3337 drv->bdrv_eject(bs, eject_flag);
3340 device_name = bdrv_get_device_name(bs);
3341 if (device_name[0] != '\0') {
3342 qapi_event_send_device_tray_moved(device_name,
3343 eject_flag, &error_abort);
3348 * Lock or unlock the media (if it is locked, the user won't be able
3349 * to eject it manually).
3351 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3353 BlockDriver *drv = bs->drv;
3355 trace_bdrv_lock_medium(bs, locked);
3357 if (drv && drv->bdrv_lock_medium) {
3358 drv->bdrv_lock_medium(bs, locked);
3362 /* Get a reference to bs */
3363 void bdrv_ref(BlockDriverState *bs)
3368 /* Release a previously grabbed reference to bs.
3369 * If after releasing, reference count is zero, the BlockDriverState is
3371 void bdrv_unref(BlockDriverState *bs)
3376 assert(bs->refcnt > 0);
3377 if (--bs->refcnt == 0) {
3382 struct BdrvOpBlocker {
3384 QLIST_ENTRY(BdrvOpBlocker) list;
3387 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3389 BdrvOpBlocker *blocker;
3390 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3391 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3392 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3394 *errp = error_copy(blocker->reason);
3395 error_prepend(errp, "Node '%s' is busy: ",
3396 bdrv_get_device_or_node_name(bs));
3403 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3405 BdrvOpBlocker *blocker;
3406 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3408 blocker = g_new0(BdrvOpBlocker, 1);
3409 blocker->reason = reason;
3410 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3413 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3415 BdrvOpBlocker *blocker, *next;
3416 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3417 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3418 if (blocker->reason == reason) {
3419 QLIST_REMOVE(blocker, list);
3425 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3428 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3429 bdrv_op_block(bs, i, reason);
3433 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3436 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3437 bdrv_op_unblock(bs, i, reason);
3441 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3445 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3446 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3453 void bdrv_img_create(const char *filename, const char *fmt,
3454 const char *base_filename, const char *base_fmt,
3455 char *options, uint64_t img_size, int flags,
3456 Error **errp, bool quiet)
3458 QemuOptsList *create_opts = NULL;
3459 QemuOpts *opts = NULL;
3460 const char *backing_fmt, *backing_file;
3462 BlockDriver *drv, *proto_drv;
3463 Error *local_err = NULL;
3466 /* Find driver and parse its options */
3467 drv = bdrv_find_format(fmt);
3469 error_setg(errp, "Unknown file format '%s'", fmt);
3473 proto_drv = bdrv_find_protocol(filename, true, errp);
3478 if (!drv->create_opts) {
3479 error_setg(errp, "Format driver '%s' does not support image creation",
3484 if (!proto_drv->create_opts) {
3485 error_setg(errp, "Protocol driver '%s' does not support image creation",
3486 proto_drv->format_name);
3490 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3491 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3493 /* Create parameter list with default values */
3494 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3495 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3497 /* Parse -o options */
3499 qemu_opts_do_parse(opts, options, NULL, &local_err);
3501 error_report_err(local_err);
3503 error_setg(errp, "Invalid options for file format '%s'", fmt);
3508 if (base_filename) {
3509 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3511 error_setg(errp, "Backing file not supported for file format '%s'",
3518 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3520 error_setg(errp, "Backing file format not supported for file "
3521 "format '%s'", fmt);
3526 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3528 if (!strcmp(filename, backing_file)) {
3529 error_setg(errp, "Error: Trying to create an image with the "
3530 "same filename as the backing file");
3535 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3537 // The size for the image must always be specified, with one exception:
3538 // If we are using a backing file, we can obtain the size from there
3539 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3542 BlockDriverState *bs;
3543 char *full_backing = g_new0(char, PATH_MAX);
3546 QDict *backing_options = NULL;
3548 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3549 full_backing, PATH_MAX,
3552 g_free(full_backing);
3556 /* backing files always opened read-only */
3558 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3561 backing_options = qdict_new();
3562 qdict_put(backing_options, "driver",
3563 qstring_from_str(backing_fmt));
3567 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3568 back_flags, &local_err);
3569 g_free(full_backing);
3573 size = bdrv_getlength(bs);
3575 error_setg_errno(errp, -size, "Could not get size of '%s'",
3581 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3585 error_setg(errp, "Image creation needs a size parameter");
3591 printf("Formatting '%s', fmt=%s ", filename, fmt);
3592 qemu_opts_print(opts, " ");
3596 ret = bdrv_create(drv, filename, opts, &local_err);
3598 if (ret == -EFBIG) {
3599 /* This is generally a better message than whatever the driver would
3600 * deliver (especially because of the cluster_size_hint), since that
3601 * is most probably not much different from "image too large". */
3602 const char *cluster_size_hint = "";
3603 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3604 cluster_size_hint = " (try using a larger cluster size)";
3606 error_setg(errp, "The image size is too large for file format '%s'"
3607 "%s", fmt, cluster_size_hint);
3608 error_free(local_err);
3613 qemu_opts_del(opts);
3614 qemu_opts_free(create_opts);
3616 error_propagate(errp, local_err);
3620 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3622 return bs->aio_context;
3625 void bdrv_detach_aio_context(BlockDriverState *bs)
3627 BdrvAioNotifier *baf;
3633 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3634 baf->detach_aio_context(baf->opaque);
3637 if (bs->throttle_state) {
3638 throttle_timers_detach_aio_context(&bs->throttle_timers);
3640 if (bs->drv->bdrv_detach_aio_context) {
3641 bs->drv->bdrv_detach_aio_context(bs);
3644 bdrv_detach_aio_context(bs->file->bs);
3647 bdrv_detach_aio_context(bs->backing->bs);
3650 bs->aio_context = NULL;
3653 void bdrv_attach_aio_context(BlockDriverState *bs,
3654 AioContext *new_context)
3656 BdrvAioNotifier *ban;
3662 bs->aio_context = new_context;
3665 bdrv_attach_aio_context(bs->backing->bs, new_context);
3668 bdrv_attach_aio_context(bs->file->bs, new_context);
3670 if (bs->drv->bdrv_attach_aio_context) {
3671 bs->drv->bdrv_attach_aio_context(bs, new_context);
3673 if (bs->throttle_state) {
3674 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3677 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3678 ban->attached_aio_context(new_context, ban->opaque);
3682 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3684 bdrv_drain(bs); /* ensure there are no in-flight requests */
3686 bdrv_detach_aio_context(bs);
3688 /* This function executes in the old AioContext so acquire the new one in
3689 * case it runs in a different thread.
3691 aio_context_acquire(new_context);
3692 bdrv_attach_aio_context(bs, new_context);
3693 aio_context_release(new_context);
3696 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3697 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3698 void (*detach_aio_context)(void *opaque), void *opaque)
3700 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3701 *ban = (BdrvAioNotifier){
3702 .attached_aio_context = attached_aio_context,
3703 .detach_aio_context = detach_aio_context,
3707 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3710 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3711 void (*attached_aio_context)(AioContext *,
3713 void (*detach_aio_context)(void *),
3716 BdrvAioNotifier *ban, *ban_next;
3718 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3719 if (ban->attached_aio_context == attached_aio_context &&
3720 ban->detach_aio_context == detach_aio_context &&
3721 ban->opaque == opaque)
3723 QLIST_REMOVE(ban, list);
3733 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3734 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
3736 if (!bs->drv->bdrv_amend_options) {
3739 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
3742 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3743 * of block filter and by bdrv_is_first_non_filter.
3744 * It is used to test if the given bs is the candidate or recurse more in the
3747 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3748 BlockDriverState *candidate)
3750 /* return false if basic checks fails */
3751 if (!bs || !bs->drv) {
3755 /* the code reached a non block filter driver -> check if the bs is
3756 * the same as the candidate. It's the recursion termination condition.
3758 if (!bs->drv->is_filter) {
3759 return bs == candidate;
3761 /* Down this path the driver is a block filter driver */
3763 /* If the block filter recursion method is defined use it to recurse down
3766 if (bs->drv->bdrv_recurse_is_first_non_filter) {
3767 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3770 /* the driver is a block filter but don't allow to recurse -> return false
3775 /* This function checks if the candidate is the first non filter bs down it's
3776 * bs chain. Since we don't have pointers to parents it explore all bs chains
3777 * from the top. Some filters can choose not to pass down the recursion.
3779 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
3781 BlockDriverState *bs = NULL;
3783 /* walk down the bs forest recursively */
3784 while ((bs = bdrv_next(bs)) != NULL) {
3787 /* try to recurse in this top level bs */
3788 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
3790 /* candidate is the first non filter */
3799 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3800 const char *node_name, Error **errp)
3802 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
3803 AioContext *aio_context;
3805 if (!to_replace_bs) {
3806 error_setg(errp, "Node name '%s' not found", node_name);
3810 aio_context = bdrv_get_aio_context(to_replace_bs);
3811 aio_context_acquire(aio_context);
3813 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
3814 to_replace_bs = NULL;
3818 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3819 * most non filter in order to prevent data corruption.
3820 * Another benefit is that this tests exclude backing files which are
3821 * blocked by the backing blockers.
3823 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
3824 error_setg(errp, "Only top most non filter can be replaced");
3825 to_replace_bs = NULL;
3830 aio_context_release(aio_context);
3831 return to_replace_bs;
3834 static bool append_open_options(QDict *d, BlockDriverState *bs)
3836 const QDictEntry *entry;
3839 bool found_any = false;
3842 for (entry = qdict_first(bs->options); entry;
3843 entry = qdict_next(bs->options, entry))
3845 /* Exclude options for children */
3846 QLIST_FOREACH(child, &bs->children, next) {
3847 if (strstart(qdict_entry_key(entry), child->name, &p)
3848 && (!*p || *p == '.'))
3857 /* And exclude all non-driver-specific options */
3858 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
3859 if (!strcmp(qdict_entry_key(entry), desc->name)) {
3867 qobject_incref(qdict_entry_value(entry));
3868 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3875 /* Updates the following BDS fields:
3876 * - exact_filename: A filename which may be used for opening a block device
3877 * which (mostly) equals the given BDS (even without any
3878 * other options; so reading and writing must return the same
3879 * results, but caching etc. may be different)
3880 * - full_open_options: Options which, when given when opening a block device
3881 * (without a filename), result in a BDS (mostly)
3882 * equalling the given one
3883 * - filename: If exact_filename is set, it is copied here. Otherwise,
3884 * full_open_options is converted to a JSON object, prefixed with
3885 * "json:" (for use through the JSON pseudo protocol) and put here.
3887 void bdrv_refresh_filename(BlockDriverState *bs)
3889 BlockDriver *drv = bs->drv;
3896 /* This BDS's file name will most probably depend on its file's name, so
3897 * refresh that first */
3899 bdrv_refresh_filename(bs->file->bs);
3902 if (drv->bdrv_refresh_filename) {
3903 /* Obsolete information is of no use here, so drop the old file name
3904 * information before refreshing it */
3905 bs->exact_filename[0] = '\0';
3906 if (bs->full_open_options) {
3907 QDECREF(bs->full_open_options);
3908 bs->full_open_options = NULL;
3912 append_open_options(opts, bs);
3913 drv->bdrv_refresh_filename(bs, opts);
3915 } else if (bs->file) {
3916 /* Try to reconstruct valid information from the underlying file */
3917 bool has_open_options;
3919 bs->exact_filename[0] = '\0';
3920 if (bs->full_open_options) {
3921 QDECREF(bs->full_open_options);
3922 bs->full_open_options = NULL;
3926 has_open_options = append_open_options(opts, bs);
3928 /* If no specific options have been given for this BDS, the filename of
3929 * the underlying file should suffice for this one as well */
3930 if (bs->file->bs->exact_filename[0] && !has_open_options) {
3931 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
3933 /* Reconstructing the full options QDict is simple for most format block
3934 * drivers, as long as the full options are known for the underlying
3935 * file BDS. The full options QDict of that file BDS should somehow
3936 * contain a representation of the filename, therefore the following
3937 * suffices without querying the (exact_)filename of this BDS. */
3938 if (bs->file->bs->full_open_options) {
3939 qdict_put_obj(opts, "driver",
3940 QOBJECT(qstring_from_str(drv->format_name)));
3941 QINCREF(bs->file->bs->full_open_options);
3942 qdict_put_obj(opts, "file",
3943 QOBJECT(bs->file->bs->full_open_options));
3945 bs->full_open_options = opts;
3949 } else if (!bs->full_open_options && qdict_size(bs->options)) {
3950 /* There is no underlying file BDS (at least referenced by BDS.file),
3951 * so the full options QDict should be equal to the options given
3952 * specifically for this block device when it was opened (plus the
3953 * driver specification).
3954 * Because those options don't change, there is no need to update
3955 * full_open_options when it's already set. */
3958 append_open_options(opts, bs);
3959 qdict_put_obj(opts, "driver",
3960 QOBJECT(qstring_from_str(drv->format_name)));
3962 if (bs->exact_filename[0]) {
3963 /* This may not work for all block protocol drivers (some may
3964 * require this filename to be parsed), but we have to find some
3965 * default solution here, so just include it. If some block driver
3966 * does not support pure options without any filename at all or
3967 * needs some special format of the options QDict, it needs to
3968 * implement the driver-specific bdrv_refresh_filename() function.
3970 qdict_put_obj(opts, "filename",
3971 QOBJECT(qstring_from_str(bs->exact_filename)));
3974 bs->full_open_options = opts;
3977 if (bs->exact_filename[0]) {
3978 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
3979 } else if (bs->full_open_options) {
3980 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
3981 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
3982 qstring_get_str(json));