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 "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/qmp/qjson.h"
34 #include "sysemu/block-backend.h"
35 #include "sysemu/sysemu.h"
36 #include "qemu/notify.h"
37 #include "qemu/coroutine.h"
38 #include "block/qapi.h"
39 #include "qmp-commands.h"
40 #include "qemu/timer.h"
41 #include "qapi-event.h"
42 #include "block/throttle-groups.h"
45 #include <sys/types.h>
47 #include <sys/ioctl.h>
48 #include <sys/queue.h>
59 * A BdrvDirtyBitmap can be in three possible states:
60 * (1) successor is NULL and disabled is false: full r/w mode
61 * (2) successor is NULL and disabled is true: read only mode ("disabled")
62 * (3) successor is set: frozen mode.
63 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
64 * or enabled. A frozen bitmap can only abdicate() or reclaim().
66 struct BdrvDirtyBitmap
{
67 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
68 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
69 char *name
; /* Optional non-empty unique ID */
70 int64_t size
; /* Size of the bitmap (Number of sectors) */
71 bool disabled
; /* Bitmap is read-only */
72 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
75 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
77 struct BdrvStates bdrv_states
= QTAILQ_HEAD_INITIALIZER(bdrv_states
);
79 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
82 static QTAILQ_HEAD(, BlockDriverState
) all_bdrv_states
=
83 QTAILQ_HEAD_INITIALIZER(all_bdrv_states
);
85 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
86 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
88 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
89 const char *reference
, QDict
*options
, int flags
,
90 BlockDriverState
*parent
,
91 const BdrvChildRole
*child_role
, Error
**errp
);
93 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
94 static void bdrv_release_named_dirty_bitmaps(BlockDriverState
*bs
);
96 /* If non-zero, use only whitelisted block drivers */
97 static int use_bdrv_whitelist
;
99 static void bdrv_close(BlockDriverState
*bs
);
102 static int is_windows_drive_prefix(const char *filename
)
104 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
105 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
109 int is_windows_drive(const char *filename
)
111 if (is_windows_drive_prefix(filename
) &&
114 if (strstart(filename
, "\\\\.\\", NULL
) ||
115 strstart(filename
, "//./", NULL
))
121 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
123 if (!bs
|| !bs
->drv
) {
124 /* page size or 4k (hdd sector size) should be on the safe side */
125 return MAX(4096, getpagesize());
128 return bs
->bl
.opt_mem_alignment
;
131 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
133 if (!bs
|| !bs
->drv
) {
134 /* page size or 4k (hdd sector size) should be on the safe side */
135 return MAX(4096, getpagesize());
138 return bs
->bl
.min_mem_alignment
;
141 /* check if the path starts with "<protocol>:" */
142 int path_has_protocol(const char *path
)
147 if (is_windows_drive(path
) ||
148 is_windows_drive_prefix(path
)) {
151 p
= path
+ strcspn(path
, ":/\\");
153 p
= path
+ strcspn(path
, ":/");
159 int path_is_absolute(const char *path
)
162 /* specific case for names like: "\\.\d:" */
163 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
166 return (*path
== '/' || *path
== '\\');
168 return (*path
== '/');
172 /* if filename is absolute, just copy it to dest. Otherwise, build a
173 path to it by considering it is relative to base_path. URL are
175 void path_combine(char *dest
, int dest_size
,
176 const char *base_path
,
177 const char *filename
)
184 if (path_is_absolute(filename
)) {
185 pstrcpy(dest
, dest_size
, filename
);
187 p
= strchr(base_path
, ':');
192 p1
= strrchr(base_path
, '/');
196 p2
= strrchr(base_path
, '\\');
208 if (len
> dest_size
- 1)
210 memcpy(dest
, base_path
, len
);
212 pstrcat(dest
, dest_size
, filename
);
216 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
218 char *dest
, size_t sz
,
221 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
222 path_is_absolute(backing
))
224 pstrcpy(dest
, sz
, backing
);
225 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
226 error_setg(errp
, "Cannot use relative backing file names for '%s'",
229 path_combine(dest
, sz
, backed
, backing
);
233 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
236 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
238 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
242 void bdrv_register(BlockDriver
*bdrv
)
244 bdrv_setup_io_funcs(bdrv
);
246 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
249 BlockDriverState
*bdrv_new_root(void)
251 BlockDriverState
*bs
= bdrv_new();
253 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
257 BlockDriverState
*bdrv_new(void)
259 BlockDriverState
*bs
;
262 bs
= g_new0(BlockDriverState
, 1);
263 QLIST_INIT(&bs
->dirty_bitmaps
);
264 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
265 QLIST_INIT(&bs
->op_blockers
[i
]);
267 notifier_with_return_list_init(&bs
->before_write_notifiers
);
268 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
269 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
271 bs
->aio_context
= qemu_get_aio_context();
273 QTAILQ_INSERT_TAIL(&all_bdrv_states
, bs
, bs_list
);
278 BlockDriver
*bdrv_find_format(const char *format_name
)
281 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
282 if (!strcmp(drv1
->format_name
, format_name
)) {
289 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
291 static const char *whitelist_rw
[] = {
292 CONFIG_BDRV_RW_WHITELIST
294 static const char *whitelist_ro
[] = {
295 CONFIG_BDRV_RO_WHITELIST
299 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
300 return 1; /* no whitelist, anything goes */
303 for (p
= whitelist_rw
; *p
; p
++) {
304 if (!strcmp(drv
->format_name
, *p
)) {
309 for (p
= whitelist_ro
; *p
; p
++) {
310 if (!strcmp(drv
->format_name
, *p
)) {
318 typedef struct CreateCo
{
326 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
328 Error
*local_err
= NULL
;
331 CreateCo
*cco
= opaque
;
334 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
336 error_propagate(&cco
->err
, local_err
);
341 int bdrv_create(BlockDriver
*drv
, const char* filename
,
342 QemuOpts
*opts
, Error
**errp
)
349 .filename
= g_strdup(filename
),
355 if (!drv
->bdrv_create
) {
356 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
361 if (qemu_in_coroutine()) {
362 /* Fast-path if already in coroutine context */
363 bdrv_create_co_entry(&cco
);
365 co
= qemu_coroutine_create(bdrv_create_co_entry
);
366 qemu_coroutine_enter(co
, &cco
);
367 while (cco
.ret
== NOT_DONE
) {
368 aio_poll(qemu_get_aio_context(), true);
375 error_propagate(errp
, cco
.err
);
377 error_setg_errno(errp
, -ret
, "Could not create image");
382 g_free(cco
.filename
);
386 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
389 Error
*local_err
= NULL
;
392 drv
= bdrv_find_protocol(filename
, true, errp
);
397 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
399 error_propagate(errp
, local_err
);
405 * Try to get @bs's logical and physical block size.
406 * On success, store them in @bsz struct and return 0.
407 * On failure return -errno.
408 * @bs must not be empty.
410 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
412 BlockDriver
*drv
= bs
->drv
;
414 if (drv
&& drv
->bdrv_probe_blocksizes
) {
415 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
422 * Try to get @bs's geometry (cyls, heads, sectors).
423 * On success, store them in @geo struct and return 0.
424 * On failure return -errno.
425 * @bs must not be empty.
427 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
429 BlockDriver
*drv
= bs
->drv
;
431 if (drv
&& drv
->bdrv_probe_geometry
) {
432 return drv
->bdrv_probe_geometry(bs
, geo
);
439 * Create a uniquely-named empty temporary file.
440 * Return 0 upon success, otherwise a negative errno value.
442 int get_tmp_filename(char *filename
, int size
)
445 char temp_dir
[MAX_PATH
];
446 /* GetTempFileName requires that its output buffer (4th param)
447 have length MAX_PATH or greater. */
448 assert(size
>= MAX_PATH
);
449 return (GetTempPath(MAX_PATH
, temp_dir
)
450 && GetTempFileName(temp_dir
, "qem", 0, filename
)
451 ? 0 : -GetLastError());
455 tmpdir
= getenv("TMPDIR");
459 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
462 fd
= mkstemp(filename
);
466 if (close(fd
) != 0) {
475 * Detect host devices. By convention, /dev/cdrom[N] is always
476 * recognized as a host CDROM.
478 static BlockDriver
*find_hdev_driver(const char *filename
)
480 int score_max
= 0, score
;
481 BlockDriver
*drv
= NULL
, *d
;
483 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
484 if (d
->bdrv_probe_device
) {
485 score
= d
->bdrv_probe_device(filename
);
486 if (score
> score_max
) {
496 BlockDriver
*bdrv_find_protocol(const char *filename
,
497 bool allow_protocol_prefix
,
505 /* TODO Drivers without bdrv_file_open must be specified explicitly */
508 * XXX(hch): we really should not let host device detection
509 * override an explicit protocol specification, but moving this
510 * later breaks access to device names with colons in them.
511 * Thanks to the brain-dead persistent naming schemes on udev-
512 * based Linux systems those actually are quite common.
514 drv1
= find_hdev_driver(filename
);
519 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
523 p
= strchr(filename
, ':');
526 if (len
> sizeof(protocol
) - 1)
527 len
= sizeof(protocol
) - 1;
528 memcpy(protocol
, filename
, len
);
529 protocol
[len
] = '\0';
530 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
531 if (drv1
->protocol_name
&&
532 !strcmp(drv1
->protocol_name
, protocol
)) {
537 error_setg(errp
, "Unknown protocol '%s'", protocol
);
542 * Guess image format by probing its contents.
543 * This is not a good idea when your image is raw (CVE-2008-2004), but
544 * we do it anyway for backward compatibility.
546 * @buf contains the image's first @buf_size bytes.
547 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
548 * but can be smaller if the image file is smaller)
549 * @filename is its filename.
551 * For all block drivers, call the bdrv_probe() method to get its
553 * Return the first block driver with the highest probing score.
555 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
556 const char *filename
)
558 int score_max
= 0, score
;
559 BlockDriver
*drv
= NULL
, *d
;
561 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
563 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
564 if (score
> score_max
) {
574 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
575 BlockDriver
**pdrv
, Error
**errp
)
578 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
581 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
582 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
587 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
589 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
595 drv
= bdrv_probe_all(buf
, ret
, filename
);
597 error_setg(errp
, "Could not determine image format: No compatible "
606 * Set the current 'total_sectors' value
607 * Return 0 on success, -errno on error.
609 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
611 BlockDriver
*drv
= bs
->drv
;
613 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
617 /* query actual device if possible, otherwise just trust the hint */
618 if (drv
->bdrv_getlength
) {
619 int64_t length
= drv
->bdrv_getlength(bs
);
623 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
626 bs
->total_sectors
= hint
;
631 * Combines a QDict of new block driver @options with any missing options taken
632 * from @old_options, so that leaving out an option defaults to its old value.
634 static void bdrv_join_options(BlockDriverState
*bs
, QDict
*options
,
637 if (bs
->drv
&& bs
->drv
->bdrv_join_options
) {
638 bs
->drv
->bdrv_join_options(options
, old_options
);
640 qdict_join(options
, old_options
, false);
645 * Set open flags for a given discard mode
647 * Return 0 on success, -1 if the discard mode was invalid.
649 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
651 *flags
&= ~BDRV_O_UNMAP
;
653 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
655 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
656 *flags
|= BDRV_O_UNMAP
;
665 * Set open flags for a given cache mode
667 * Return 0 on success, -1 if the cache mode was invalid.
669 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
671 *flags
&= ~BDRV_O_CACHE_MASK
;
673 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
674 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
675 } else if (!strcmp(mode
, "directsync")) {
676 *flags
|= BDRV_O_NOCACHE
;
677 } else if (!strcmp(mode
, "writeback")) {
678 *flags
|= BDRV_O_CACHE_WB
;
679 } else if (!strcmp(mode
, "unsafe")) {
680 *flags
|= BDRV_O_CACHE_WB
;
681 *flags
|= BDRV_O_NO_FLUSH
;
682 } else if (!strcmp(mode
, "writethrough")) {
683 /* this is the default */
692 * Returns the flags that a temporary snapshot should get, based on the
693 * originally requested flags (the originally requested image will have flags
694 * like a backing file)
696 static int bdrv_temp_snapshot_flags(int flags
)
698 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
702 * Returns the options and flags that bs->file should get if a protocol driver
703 * is expected, based on the given options and flags for the parent BDS
705 static void bdrv_inherited_options(int *child_flags
, QDict
*child_options
,
706 int parent_flags
, QDict
*parent_options
)
708 int flags
= parent_flags
;
710 /* Enable protocol handling, disable format probing for bs->file */
711 flags
|= BDRV_O_PROTOCOL
;
713 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
715 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
716 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
718 /* Our block drivers take care to send flushes and respect unmap policy,
719 * so we can default to enable both on lower layers regardless of the
720 * corresponding parent options. */
721 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_WB
, "on");
722 flags
|= BDRV_O_UNMAP
;
724 /* Clear flags that only apply to the top layer */
725 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
727 *child_flags
= flags
;
730 const BdrvChildRole child_file
= {
731 .inherit_options
= bdrv_inherited_options
,
735 * Returns the options and flags that bs->file should get if the use of formats
736 * (and not only protocols) is permitted for it, based on the given options and
737 * flags for the parent BDS
739 static void bdrv_inherited_fmt_options(int *child_flags
, QDict
*child_options
,
740 int parent_flags
, QDict
*parent_options
)
742 child_file
.inherit_options(child_flags
, child_options
,
743 parent_flags
, parent_options
);
745 *child_flags
&= ~BDRV_O_PROTOCOL
;
748 const BdrvChildRole child_format
= {
749 .inherit_options
= bdrv_inherited_fmt_options
,
753 * Returns the options and flags that bs->backing should get, based on the
754 * given options and flags for the parent BDS
756 static void bdrv_backing_options(int *child_flags
, QDict
*child_options
,
757 int parent_flags
, QDict
*parent_options
)
759 int flags
= parent_flags
;
761 /* The cache mode is inherited unmodified for backing files */
762 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_WB
);
763 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
764 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
766 /* backing files always opened read-only */
767 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
769 /* snapshot=on is handled on the top layer */
770 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
772 *child_flags
= flags
;
775 static const BdrvChildRole child_backing
= {
776 .inherit_options
= bdrv_backing_options
,
779 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
781 int open_flags
= flags
| BDRV_O_CACHE_WB
;
784 * Clear flags that are internal to the block layer before opening the
787 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
790 * Snapshots should be writable.
792 if (flags
& BDRV_O_TEMPORARY
) {
793 open_flags
|= BDRV_O_RDWR
;
799 static void update_flags_from_options(int *flags
, QemuOpts
*opts
)
801 *flags
&= ~BDRV_O_CACHE_MASK
;
803 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_WB
));
804 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_WB
, false)) {
805 *flags
|= BDRV_O_CACHE_WB
;
808 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_NO_FLUSH
));
809 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_NO_FLUSH
, false)) {
810 *flags
|= BDRV_O_NO_FLUSH
;
813 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_DIRECT
));
814 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_DIRECT
, false)) {
815 *flags
|= BDRV_O_NOCACHE
;
819 static void update_options_from_flags(QDict
*options
, int flags
)
821 if (!qdict_haskey(options
, BDRV_OPT_CACHE_WB
)) {
822 qdict_put(options
, BDRV_OPT_CACHE_WB
,
823 qbool_from_bool(flags
& BDRV_O_CACHE_WB
));
825 if (!qdict_haskey(options
, BDRV_OPT_CACHE_DIRECT
)) {
826 qdict_put(options
, BDRV_OPT_CACHE_DIRECT
,
827 qbool_from_bool(flags
& BDRV_O_NOCACHE
));
829 if (!qdict_haskey(options
, BDRV_OPT_CACHE_NO_FLUSH
)) {
830 qdict_put(options
, BDRV_OPT_CACHE_NO_FLUSH
,
831 qbool_from_bool(flags
& BDRV_O_NO_FLUSH
));
835 static void bdrv_assign_node_name(BlockDriverState
*bs
,
836 const char *node_name
,
839 char *gen_node_name
= NULL
;
842 node_name
= gen_node_name
= id_generate(ID_BLOCK
);
843 } else if (!id_wellformed(node_name
)) {
845 * Check for empty string or invalid characters, but not if it is
846 * generated (generated names use characters not available to the user)
848 error_setg(errp
, "Invalid node name");
852 /* takes care of avoiding namespaces collisions */
853 if (blk_by_name(node_name
)) {
854 error_setg(errp
, "node-name=%s is conflicting with a device id",
859 /* takes care of avoiding duplicates node names */
860 if (bdrv_find_node(node_name
)) {
861 error_setg(errp
, "Duplicate node name");
865 /* copy node name into the bs and insert it into the graph list */
866 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
867 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
869 g_free(gen_node_name
);
872 static QemuOptsList bdrv_runtime_opts
= {
873 .name
= "bdrv_common",
874 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
878 .type
= QEMU_OPT_STRING
,
879 .help
= "Node name of the block device node",
883 .type
= QEMU_OPT_STRING
,
884 .help
= "Block driver to use for the node",
887 .name
= BDRV_OPT_CACHE_WB
,
888 .type
= QEMU_OPT_BOOL
,
889 .help
= "Enable writeback mode",
892 .name
= BDRV_OPT_CACHE_DIRECT
,
893 .type
= QEMU_OPT_BOOL
,
894 .help
= "Bypass software writeback cache on the host",
897 .name
= BDRV_OPT_CACHE_NO_FLUSH
,
898 .type
= QEMU_OPT_BOOL
,
899 .help
= "Ignore flush requests",
901 { /* end of list */ }
906 * Common part for opening disk images and files
908 * Removes all processed options from *options.
910 static int bdrv_open_common(BlockDriverState
*bs
, BdrvChild
*file
,
911 QDict
*options
, Error
**errp
)
914 const char *filename
;
915 const char *driver_name
= NULL
;
916 const char *node_name
= NULL
;
919 Error
*local_err
= NULL
;
921 assert(bs
->file
== NULL
);
922 assert(options
!= NULL
&& bs
->options
!= options
);
924 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
925 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
927 error_propagate(errp
, local_err
);
932 driver_name
= qemu_opt_get(opts
, "driver");
933 drv
= bdrv_find_format(driver_name
);
937 filename
= file
->bs
->filename
;
939 filename
= qdict_get_try_str(options
, "filename");
942 if (drv
->bdrv_needs_filename
&& !filename
) {
943 error_setg(errp
, "The '%s' block driver requires a file name",
949 trace_bdrv_open_common(bs
, filename
?: "", bs
->open_flags
,
952 node_name
= qemu_opt_get(opts
, "node-name");
953 bdrv_assign_node_name(bs
, node_name
, &local_err
);
955 error_propagate(errp
, local_err
);
960 bs
->request_alignment
= 512;
961 bs
->zero_beyond_eof
= true;
962 bs
->read_only
= !(bs
->open_flags
& BDRV_O_RDWR
);
964 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
966 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
967 ? "Driver '%s' can only be used for read-only devices"
968 : "Driver '%s' is not whitelisted",
974 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
975 if (bs
->open_flags
& BDRV_O_COPY_ON_READ
) {
976 if (!bs
->read_only
) {
977 bdrv_enable_copy_on_read(bs
);
979 error_setg(errp
, "Can't use copy-on-read on read-only device");
985 if (filename
!= NULL
) {
986 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
988 bs
->filename
[0] = '\0';
990 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
993 bs
->opaque
= g_malloc0(drv
->instance_size
);
995 /* Apply cache mode options */
996 update_flags_from_options(&bs
->open_flags
, opts
);
997 bdrv_set_enable_write_cache(bs
, bs
->open_flags
& BDRV_O_CACHE_WB
);
999 /* Open the image, either directly or using a protocol */
1000 open_flags
= bdrv_open_flags(bs
, bs
->open_flags
);
1001 if (drv
->bdrv_file_open
) {
1002 assert(file
== NULL
);
1003 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
1004 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
1007 error_setg(errp
, "Can't use '%s' as a block driver for the "
1008 "protocol level", drv
->format_name
);
1013 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1018 error_propagate(errp
, local_err
);
1019 } else if (bs
->filename
[0]) {
1020 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1022 error_setg_errno(errp
, -ret
, "Could not open image");
1027 if (bs
->encrypted
) {
1028 error_report("Encrypted images are deprecated");
1029 error_printf("Support for them will be removed in a future release.\n"
1030 "You can use 'qemu-img convert' to convert your image"
1031 " to an unencrypted one.\n");
1034 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1036 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1040 bdrv_refresh_limits(bs
, &local_err
);
1042 error_propagate(errp
, local_err
);
1047 assert(bdrv_opt_mem_align(bs
) != 0);
1048 assert(bdrv_min_mem_align(bs
) != 0);
1049 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
1051 qemu_opts_del(opts
);
1060 qemu_opts_del(opts
);
1064 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1066 QObject
*options_obj
;
1070 ret
= strstart(filename
, "json:", &filename
);
1073 options_obj
= qobject_from_json(filename
);
1075 error_setg(errp
, "Could not parse the JSON options");
1079 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1080 qobject_decref(options_obj
);
1081 error_setg(errp
, "Invalid JSON object given");
1085 options
= qobject_to_qdict(options_obj
);
1086 qdict_flatten(options
);
1091 static void parse_json_protocol(QDict
*options
, const char **pfilename
,
1094 QDict
*json_options
;
1095 Error
*local_err
= NULL
;
1097 /* Parse json: pseudo-protocol */
1098 if (!*pfilename
|| !g_str_has_prefix(*pfilename
, "json:")) {
1102 json_options
= parse_json_filename(*pfilename
, &local_err
);
1104 error_propagate(errp
, local_err
);
1108 /* Options given in the filename have lower priority than options
1109 * specified directly */
1110 qdict_join(options
, json_options
, false);
1111 QDECREF(json_options
);
1116 * Fills in default options for opening images and converts the legacy
1117 * filename/flags pair to option QDict entries.
1118 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1119 * block driver has been specified explicitly.
1121 static int bdrv_fill_options(QDict
**options
, const char *filename
,
1122 int *flags
, Error
**errp
)
1124 const char *drvname
;
1125 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1126 bool parse_filename
= false;
1127 BlockDriver
*drv
= NULL
;
1128 Error
*local_err
= NULL
;
1130 drvname
= qdict_get_try_str(*options
, "driver");
1132 drv
= bdrv_find_format(drvname
);
1134 error_setg(errp
, "Unknown driver '%s'", drvname
);
1137 /* If the user has explicitly specified the driver, this choice should
1138 * override the BDRV_O_PROTOCOL flag */
1139 protocol
= drv
->bdrv_file_open
;
1143 *flags
|= BDRV_O_PROTOCOL
;
1145 *flags
&= ~BDRV_O_PROTOCOL
;
1148 /* Translate cache options from flags into options */
1149 update_options_from_flags(*options
, *flags
);
1151 /* Fetch the file name from the options QDict if necessary */
1152 if (protocol
&& filename
) {
1153 if (!qdict_haskey(*options
, "filename")) {
1154 qdict_put(*options
, "filename", qstring_from_str(filename
));
1155 parse_filename
= true;
1157 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1163 /* Find the right block driver */
1164 filename
= qdict_get_try_str(*options
, "filename");
1166 if (!drvname
&& protocol
) {
1168 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1173 drvname
= drv
->format_name
;
1174 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1176 error_setg(errp
, "Must specify either driver or file");
1181 assert(drv
|| !protocol
);
1183 /* Driver-specific filename parsing */
1184 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1185 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1187 error_propagate(errp
, local_err
);
1191 if (!drv
->bdrv_needs_filename
) {
1192 qdict_del(*options
, "filename");
1196 if (runstate_check(RUN_STATE_INMIGRATE
)) {
1197 *flags
|= BDRV_O_INACTIVE
;
1203 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1204 BlockDriverState
*child_bs
,
1205 const char *child_name
,
1206 const BdrvChildRole
*child_role
)
1208 BdrvChild
*child
= g_new(BdrvChild
, 1);
1209 *child
= (BdrvChild
) {
1211 .name
= g_strdup(child_name
),
1215 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1216 QLIST_INSERT_HEAD(&child_bs
->parents
, child
, next_parent
);
1221 static void bdrv_detach_child(BdrvChild
*child
)
1223 QLIST_REMOVE(child
, next
);
1224 QLIST_REMOVE(child
, next_parent
);
1225 g_free(child
->name
);
1229 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1231 BlockDriverState
*child_bs
;
1233 if (child
== NULL
) {
1237 if (child
->bs
->inherits_from
== parent
) {
1238 child
->bs
->inherits_from
= NULL
;
1241 child_bs
= child
->bs
;
1242 bdrv_detach_child(child
);
1243 bdrv_unref(child_bs
);
1247 * Sets the backing file link of a BDS. A new reference is created; callers
1248 * which don't need their own reference any more must call bdrv_unref().
1250 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1253 bdrv_ref(backing_hd
);
1257 assert(bs
->backing_blocker
);
1258 bdrv_op_unblock_all(bs
->backing
->bs
, bs
->backing_blocker
);
1259 bdrv_unref_child(bs
, bs
->backing
);
1260 } else if (backing_hd
) {
1261 error_setg(&bs
->backing_blocker
,
1262 "node is used as backing hd of '%s'",
1263 bdrv_get_device_or_node_name(bs
));
1267 error_free(bs
->backing_blocker
);
1268 bs
->backing_blocker
= NULL
;
1272 bs
->backing
= bdrv_attach_child(bs
, backing_hd
, "backing", &child_backing
);
1273 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1274 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1275 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1276 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1278 bdrv_op_block_all(backing_hd
, bs
->backing_blocker
);
1279 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1280 bdrv_op_unblock(backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1281 bs
->backing_blocker
);
1283 bdrv_refresh_limits(bs
, NULL
);
1287 * Opens the backing file for a BlockDriverState if not yet open
1289 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1290 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1291 * itself, all options starting with "${bdref_key}." are considered part of the
1294 * TODO Can this be unified with bdrv_open_image()?
1296 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*parent_options
,
1297 const char *bdref_key
, Error
**errp
)
1299 char *backing_filename
= g_malloc0(PATH_MAX
);
1300 char *bdref_key_dot
;
1301 const char *reference
= NULL
;
1303 BlockDriverState
*backing_hd
;
1305 QDict
*tmp_parent_options
= NULL
;
1306 Error
*local_err
= NULL
;
1308 if (bs
->backing
!= NULL
) {
1312 /* NULL means an empty set of options */
1313 if (parent_options
== NULL
) {
1314 tmp_parent_options
= qdict_new();
1315 parent_options
= tmp_parent_options
;
1318 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1320 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1321 qdict_extract_subqdict(parent_options
, &options
, bdref_key_dot
);
1322 g_free(bdref_key_dot
);
1324 reference
= qdict_get_try_str(parent_options
, bdref_key
);
1325 if (reference
|| qdict_haskey(options
, "file.filename")) {
1326 backing_filename
[0] = '\0';
1327 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1331 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1335 error_propagate(errp
, local_err
);
1341 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1343 error_setg(errp
, "Driver doesn't support backing files");
1348 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1349 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1353 ret
= bdrv_open_inherit(&backing_hd
,
1354 *backing_filename
? backing_filename
: NULL
,
1355 reference
, options
, 0, bs
, &child_backing
,
1358 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1359 error_prepend(errp
, "Could not open backing file: ");
1363 /* Hook up the backing file link; drop our reference, bs owns the
1364 * backing_hd reference now */
1365 bdrv_set_backing_hd(bs
, backing_hd
);
1366 bdrv_unref(backing_hd
);
1368 qdict_del(parent_options
, bdref_key
);
1371 g_free(backing_filename
);
1372 QDECREF(tmp_parent_options
);
1377 * Opens a disk image whose options are given as BlockdevRef in another block
1380 * If allow_none is true, no image will be opened if filename is false and no
1381 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1383 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1384 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1385 * itself, all options starting with "${bdref_key}." are considered part of the
1388 * The BlockdevRef will be removed from the options QDict.
1390 BdrvChild
*bdrv_open_child(const char *filename
,
1391 QDict
*options
, const char *bdref_key
,
1392 BlockDriverState
* parent
,
1393 const BdrvChildRole
*child_role
,
1394 bool allow_none
, Error
**errp
)
1396 BdrvChild
*c
= NULL
;
1397 BlockDriverState
*bs
;
1398 QDict
*image_options
;
1400 char *bdref_key_dot
;
1401 const char *reference
;
1403 assert(child_role
!= NULL
);
1405 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1406 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1407 g_free(bdref_key_dot
);
1409 reference
= qdict_get_try_str(options
, bdref_key
);
1410 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1412 error_setg(errp
, "A block device must be specified for \"%s\"",
1415 QDECREF(image_options
);
1420 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1421 parent
, child_role
, errp
);
1426 c
= bdrv_attach_child(parent
, bs
, bdref_key
, child_role
);
1429 qdict_del(options
, bdref_key
);
1433 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1435 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1436 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1438 QemuOpts
*opts
= NULL
;
1439 QDict
*snapshot_options
;
1440 BlockDriverState
*bs_snapshot
;
1441 Error
*local_err
= NULL
;
1444 /* if snapshot, we create a temporary backing file and open it
1445 instead of opening 'filename' directly */
1447 /* Get the required size from the image */
1448 total_size
= bdrv_getlength(bs
);
1449 if (total_size
< 0) {
1451 error_setg_errno(errp
, -total_size
, "Could not get image size");
1455 /* Create the temporary image */
1456 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1458 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1462 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1464 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1465 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, errp
);
1466 qemu_opts_del(opts
);
1468 error_prepend(errp
, "Could not create temporary overlay '%s': ",
1473 /* Prepare a new options QDict for the temporary file */
1474 snapshot_options
= qdict_new();
1475 qdict_put(snapshot_options
, "file.driver",
1476 qstring_from_str("file"));
1477 qdict_put(snapshot_options
, "file.filename",
1478 qstring_from_str(tmp_filename
));
1479 qdict_put(snapshot_options
, "driver",
1480 qstring_from_str("qcow2"));
1482 bs_snapshot
= bdrv_new();
1484 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1487 error_propagate(errp
, local_err
);
1491 bdrv_append(bs_snapshot
, bs
);
1494 g_free(tmp_filename
);
1499 * Opens a disk image (raw, qcow2, vmdk, ...)
1501 * options is a QDict of options to pass to the block drivers, or NULL for an
1502 * empty set of options. The reference to the QDict belongs to the block layer
1503 * after the call (even on failure), so if the caller intends to reuse the
1504 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1506 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1507 * If it is not NULL, the referenced BDS will be reused.
1509 * The reference parameter may be used to specify an existing block device which
1510 * should be opened. If specified, neither options nor a filename may be given,
1511 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1513 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1514 const char *reference
, QDict
*options
, int flags
,
1515 BlockDriverState
*parent
,
1516 const BdrvChildRole
*child_role
, Error
**errp
)
1519 BdrvChild
*file
= NULL
;
1520 BlockDriverState
*bs
;
1521 BlockDriver
*drv
= NULL
;
1522 const char *drvname
;
1523 const char *backing
;
1524 Error
*local_err
= NULL
;
1525 int snapshot_flags
= 0;
1528 assert(!child_role
|| !flags
);
1529 assert(!child_role
== !parent
);
1532 bool options_non_empty
= options
? qdict_size(options
) : false;
1536 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1537 "another block device");
1541 if (filename
|| options_non_empty
) {
1542 error_setg(errp
, "Cannot reference an existing block device with "
1543 "additional options or a new filename");
1547 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1562 /* NULL means an empty set of options */
1563 if (options
== NULL
) {
1564 options
= qdict_new();
1567 /* json: syntax counts as explicit options, as if in the QDict */
1568 parse_json_protocol(options
, &filename
, &local_err
);
1574 bs
->explicit_options
= qdict_clone_shallow(options
);
1577 bs
->inherits_from
= parent
;
1578 child_role
->inherit_options(&flags
, options
,
1579 parent
->open_flags
, parent
->options
);
1582 ret
= bdrv_fill_options(&options
, filename
, &flags
, &local_err
);
1587 bs
->open_flags
= flags
;
1588 bs
->options
= options
;
1589 options
= qdict_clone_shallow(options
);
1591 /* Find the right image format driver */
1592 drvname
= qdict_get_try_str(options
, "driver");
1594 drv
= bdrv_find_format(drvname
);
1596 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1602 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1604 backing
= qdict_get_try_str(options
, "backing");
1605 if (backing
&& *backing
== '\0') {
1606 flags
|= BDRV_O_NO_BACKING
;
1607 qdict_del(options
, "backing");
1610 /* Open image file without format layer */
1611 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1612 if (flags
& BDRV_O_RDWR
) {
1613 flags
|= BDRV_O_ALLOW_RDWR
;
1615 if (flags
& BDRV_O_SNAPSHOT
) {
1616 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1617 bdrv_backing_options(&flags
, options
, flags
, options
);
1620 bs
->open_flags
= flags
;
1622 file
= bdrv_open_child(filename
, options
, "file", bs
,
1623 &child_file
, true, &local_err
);
1630 /* Image format probing */
1633 ret
= find_image_format(file
->bs
, filename
, &drv
, &local_err
);
1638 * This option update would logically belong in bdrv_fill_options(),
1639 * but we first need to open bs->file for the probing to work, while
1640 * opening bs->file already requires the (mostly) final set of options
1641 * so that cache mode etc. can be inherited.
1643 * Adding the driver later is somewhat ugly, but it's not an option
1644 * that would ever be inherited, so it's correct. We just need to make
1645 * sure to update both bs->options (which has the full effective
1646 * options for bs) and options (which has file.* already removed).
1648 qdict_put(bs
->options
, "driver", qstring_from_str(drv
->format_name
));
1649 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1651 error_setg(errp
, "Must specify either driver or file");
1656 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1657 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1658 /* file must be NULL if a protocol BDS is about to be created
1659 * (the inverse results in an error message from bdrv_open_common()) */
1660 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1662 /* Open the image */
1663 ret
= bdrv_open_common(bs
, file
, options
, &local_err
);
1668 if (file
&& (bs
->file
!= file
)) {
1669 bdrv_unref_child(bs
, file
);
1673 /* If there is a backing file, use it */
1674 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1675 ret
= bdrv_open_backing_file(bs
, options
, "backing", &local_err
);
1677 goto close_and_fail
;
1681 bdrv_refresh_filename(bs
);
1683 /* Check if any unknown options were used */
1684 if (options
&& (qdict_size(options
) != 0)) {
1685 const QDictEntry
*entry
= qdict_first(options
);
1686 if (flags
& BDRV_O_PROTOCOL
) {
1687 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1688 "'%s'", drv
->format_name
, entry
->key
);
1690 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1691 "support the option '%s'", drv
->format_name
,
1692 bdrv_get_device_name(bs
), entry
->key
);
1696 goto close_and_fail
;
1699 if (!bdrv_key_required(bs
)) {
1701 blk_dev_change_media_cb(bs
->blk
, true);
1703 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1704 && !runstate_check(RUN_STATE_INMIGRATE
)
1705 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1707 "Guest must be stopped for opening of encrypted image");
1709 goto close_and_fail
;
1715 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1716 * temporary snapshot afterwards. */
1717 if (snapshot_flags
) {
1718 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1720 goto close_and_fail
;
1728 bdrv_unref_child(bs
, file
);
1730 QDECREF(bs
->explicit_options
);
1731 QDECREF(bs
->options
);
1735 /* If *pbs is NULL, a new BDS has been created in this function and
1736 needs to be freed now. Otherwise, it does not need to be closed,
1737 since it has not really been opened yet. */
1741 error_propagate(errp
, local_err
);
1746 /* See fail path, but now the BDS has to be always closed */
1754 error_propagate(errp
, local_err
);
1759 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1760 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1762 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1766 typedef struct BlockReopenQueueEntry
{
1768 BDRVReopenState state
;
1769 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1770 } BlockReopenQueueEntry
;
1773 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1774 * reopen of multiple devices.
1776 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1777 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1778 * be created and initialized. This newly created BlockReopenQueue should be
1779 * passed back in for subsequent calls that are intended to be of the same
1782 * bs is the BlockDriverState to add to the reopen queue.
1784 * options contains the changed options for the associated bs
1785 * (the BlockReopenQueue takes ownership)
1787 * flags contains the open flags for the associated bs
1789 * returns a pointer to bs_queue, which is either the newly allocated
1790 * bs_queue, or the existing bs_queue being used.
1793 static BlockReopenQueue
*bdrv_reopen_queue_child(BlockReopenQueue
*bs_queue
,
1794 BlockDriverState
*bs
,
1797 const BdrvChildRole
*role
,
1798 QDict
*parent_options
,
1803 BlockReopenQueueEntry
*bs_entry
;
1805 QDict
*old_options
, *explicit_options
;
1807 if (bs_queue
== NULL
) {
1808 bs_queue
= g_new0(BlockReopenQueue
, 1);
1809 QSIMPLEQ_INIT(bs_queue
);
1813 options
= qdict_new();
1817 * Precedence of options:
1818 * 1. Explicitly passed in options (highest)
1819 * 2. Set in flags (only for top level)
1820 * 3. Retained from explicitly set options of bs
1821 * 4. Inherited from parent node
1822 * 5. Retained from effective options of bs
1825 if (!parent_options
) {
1827 * Any setting represented by flags is always updated. If the
1828 * corresponding QDict option is set, it takes precedence. Otherwise
1829 * the flag is translated into a QDict option. The old setting of bs is
1832 update_options_from_flags(options
, flags
);
1835 /* Old explicitly set values (don't overwrite by inherited value) */
1836 old_options
= qdict_clone_shallow(bs
->explicit_options
);
1837 bdrv_join_options(bs
, options
, old_options
);
1838 QDECREF(old_options
);
1840 explicit_options
= qdict_clone_shallow(options
);
1842 /* Inherit from parent node */
1843 if (parent_options
) {
1845 role
->inherit_options(&flags
, options
, parent_flags
, parent_options
);
1848 /* Old values are used for options that aren't set yet */
1849 old_options
= qdict_clone_shallow(bs
->options
);
1850 bdrv_join_options(bs
, options
, old_options
);
1851 QDECREF(old_options
);
1853 /* bdrv_open() masks this flag out */
1854 flags
&= ~BDRV_O_PROTOCOL
;
1856 QLIST_FOREACH(child
, &bs
->children
, next
) {
1857 QDict
*new_child_options
;
1858 char *child_key_dot
;
1860 /* reopen can only change the options of block devices that were
1861 * implicitly created and inherited options. For other (referenced)
1862 * block devices, a syntax like "backing.foo" results in an error. */
1863 if (child
->bs
->inherits_from
!= bs
) {
1867 child_key_dot
= g_strdup_printf("%s.", child
->name
);
1868 qdict_extract_subqdict(options
, &new_child_options
, child_key_dot
);
1869 g_free(child_key_dot
);
1871 bdrv_reopen_queue_child(bs_queue
, child
->bs
, new_child_options
, 0,
1872 child
->role
, options
, flags
);
1875 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1876 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1878 bs_entry
->state
.bs
= bs
;
1879 bs_entry
->state
.options
= options
;
1880 bs_entry
->state
.explicit_options
= explicit_options
;
1881 bs_entry
->state
.flags
= flags
;
1886 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1887 BlockDriverState
*bs
,
1888 QDict
*options
, int flags
)
1890 return bdrv_reopen_queue_child(bs_queue
, bs
, options
, flags
,
1895 * Reopen multiple BlockDriverStates atomically & transactionally.
1897 * The queue passed in (bs_queue) must have been built up previous
1898 * via bdrv_reopen_queue().
1900 * Reopens all BDS specified in the queue, with the appropriate
1901 * flags. All devices are prepared for reopen, and failure of any
1902 * device will cause all device changes to be abandonded, and intermediate
1905 * If all devices prepare successfully, then the changes are committed
1909 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1912 BlockReopenQueueEntry
*bs_entry
, *next
;
1913 Error
*local_err
= NULL
;
1915 assert(bs_queue
!= NULL
);
1919 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1920 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1921 error_propagate(errp
, local_err
);
1924 bs_entry
->prepared
= true;
1927 /* If we reach this point, we have success and just need to apply the
1930 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1931 bdrv_reopen_commit(&bs_entry
->state
);
1937 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1938 if (ret
&& bs_entry
->prepared
) {
1939 bdrv_reopen_abort(&bs_entry
->state
);
1941 QDECREF(bs_entry
->state
.explicit_options
);
1943 QDECREF(bs_entry
->state
.options
);
1951 /* Reopen a single BlockDriverState with the specified flags. */
1952 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1955 Error
*local_err
= NULL
;
1956 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, NULL
, bdrv_flags
);
1958 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1959 if (local_err
!= NULL
) {
1960 error_propagate(errp
, local_err
);
1967 * Prepares a BlockDriverState for reopen. All changes are staged in the
1968 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1969 * the block driver layer .bdrv_reopen_prepare()
1971 * bs is the BlockDriverState to reopen
1972 * flags are the new open flags
1973 * queue is the reopen queue
1975 * Returns 0 on success, non-zero on error. On error errp will be set
1978 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1979 * It is the responsibility of the caller to then call the abort() or
1980 * commit() for any other BDS that have been left in a prepare() state
1983 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1987 Error
*local_err
= NULL
;
1992 assert(reopen_state
!= NULL
);
1993 assert(reopen_state
->bs
->drv
!= NULL
);
1994 drv
= reopen_state
->bs
->drv
;
1996 /* Process generic block layer options */
1997 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
1998 qemu_opts_absorb_qdict(opts
, reopen_state
->options
, &local_err
);
2000 error_propagate(errp
, local_err
);
2005 update_flags_from_options(&reopen_state
->flags
, opts
);
2007 /* If a guest device is attached, it owns WCE */
2008 if (reopen_state
->bs
->blk
&& blk_get_attached_dev(reopen_state
->bs
->blk
)) {
2009 bool old_wce
= bdrv_enable_write_cache(reopen_state
->bs
);
2010 bool new_wce
= (reopen_state
->flags
& BDRV_O_CACHE_WB
);
2011 if (old_wce
!= new_wce
) {
2012 error_setg(errp
, "Cannot change cache.writeback: Device attached");
2018 /* node-name and driver must be unchanged. Put them back into the QDict, so
2019 * that they are checked at the end of this function. */
2020 value
= qemu_opt_get(opts
, "node-name");
2022 qdict_put(reopen_state
->options
, "node-name", qstring_from_str(value
));
2025 value
= qemu_opt_get(opts
, "driver");
2027 qdict_put(reopen_state
->options
, "driver", qstring_from_str(value
));
2030 /* if we are to stay read-only, do not allow permission change
2032 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
2033 reopen_state
->flags
& BDRV_O_RDWR
) {
2034 error_setg(errp
, "Node '%s' is read only",
2035 bdrv_get_device_or_node_name(reopen_state
->bs
));
2040 ret
= bdrv_flush(reopen_state
->bs
);
2042 error_setg_errno(errp
, -ret
, "Error flushing drive");
2046 if (drv
->bdrv_reopen_prepare
) {
2047 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
2049 if (local_err
!= NULL
) {
2050 error_propagate(errp
, local_err
);
2052 error_setg(errp
, "failed while preparing to reopen image '%s'",
2053 reopen_state
->bs
->filename
);
2058 /* It is currently mandatory to have a bdrv_reopen_prepare()
2059 * handler for each supported drv. */
2060 error_setg(errp
, "Block format '%s' used by node '%s' "
2061 "does not support reopening files", drv
->format_name
,
2062 bdrv_get_device_or_node_name(reopen_state
->bs
));
2067 /* Options that are not handled are only okay if they are unchanged
2068 * compared to the old state. It is expected that some options are only
2069 * used for the initial open, but not reopen (e.g. filename) */
2070 if (qdict_size(reopen_state
->options
)) {
2071 const QDictEntry
*entry
= qdict_first(reopen_state
->options
);
2074 QString
*new_obj
= qobject_to_qstring(entry
->value
);
2075 const char *new = qstring_get_str(new_obj
);
2076 const char *old
= qdict_get_try_str(reopen_state
->bs
->options
,
2079 if (!old
|| strcmp(new, old
)) {
2080 error_setg(errp
, "Cannot change the option '%s'", entry
->key
);
2084 } while ((entry
= qdict_next(reopen_state
->options
, entry
)));
2090 qemu_opts_del(opts
);
2095 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2096 * makes them final by swapping the staging BlockDriverState contents into
2097 * the active BlockDriverState contents.
2099 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
2103 assert(reopen_state
!= NULL
);
2104 drv
= reopen_state
->bs
->drv
;
2105 assert(drv
!= NULL
);
2107 /* If there are any driver level actions to take */
2108 if (drv
->bdrv_reopen_commit
) {
2109 drv
->bdrv_reopen_commit(reopen_state
);
2112 /* set BDS specific flags now */
2113 QDECREF(reopen_state
->bs
->explicit_options
);
2115 reopen_state
->bs
->explicit_options
= reopen_state
->explicit_options
;
2116 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
2117 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
2119 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
2121 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
2125 * Abort the reopen, and delete and free the staged changes in
2128 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
2132 assert(reopen_state
!= NULL
);
2133 drv
= reopen_state
->bs
->drv
;
2134 assert(drv
!= NULL
);
2136 if (drv
->bdrv_reopen_abort
) {
2137 drv
->bdrv_reopen_abort(reopen_state
);
2140 QDECREF(reopen_state
->explicit_options
);
2144 static void bdrv_close(BlockDriverState
*bs
)
2146 BdrvAioNotifier
*ban
, *ban_next
;
2149 block_job_cancel_sync(bs
->job
);
2152 /* Disable I/O limits and drain all pending throttled requests */
2153 if (bs
->throttle_state
) {
2154 bdrv_io_limits_disable(bs
);
2157 bdrv_drained_begin(bs
); /* complete I/O */
2159 bdrv_drain(bs
); /* in case flush left pending I/O */
2161 bdrv_release_named_dirty_bitmaps(bs
);
2162 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2165 blk_dev_change_media_cb(bs
->blk
, false);
2169 BdrvChild
*child
, *next
;
2171 bs
->drv
->bdrv_close(bs
);
2174 bdrv_set_backing_hd(bs
, NULL
);
2176 if (bs
->file
!= NULL
) {
2177 bdrv_unref_child(bs
, bs
->file
);
2181 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
2182 /* TODO Remove bdrv_unref() from drivers' close function and use
2183 * bdrv_unref_child() here */
2184 if (child
->bs
->inherits_from
== bs
) {
2185 child
->bs
->inherits_from
= NULL
;
2187 bdrv_detach_child(child
);
2192 bs
->copy_on_read
= 0;
2193 bs
->backing_file
[0] = '\0';
2194 bs
->backing_format
[0] = '\0';
2195 bs
->total_sectors
= 0;
2199 bs
->zero_beyond_eof
= false;
2200 QDECREF(bs
->options
);
2201 QDECREF(bs
->explicit_options
);
2203 QDECREF(bs
->full_open_options
);
2204 bs
->full_open_options
= NULL
;
2207 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
2210 QLIST_INIT(&bs
->aio_notifiers
);
2211 bdrv_drained_end(bs
);
2214 void bdrv_close_all(void)
2216 BlockDriverState
*bs
;
2218 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2219 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2221 aio_context_acquire(aio_context
);
2223 aio_context_release(aio_context
);
2227 /* make a BlockDriverState anonymous by removing from bdrv_state and
2228 * graph_bdrv_state list.
2229 Also, NULL terminate the device_name to prevent double remove */
2230 void bdrv_make_anon(BlockDriverState
*bs
)
2233 * Take care to remove bs from bdrv_states only when it's actually
2234 * in it. Note that bs->device_list.tqe_prev is initially null,
2235 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2236 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2237 * resetting it to null on remove.
2239 if (bs
->device_list
.tqe_prev
) {
2240 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
2241 bs
->device_list
.tqe_prev
= NULL
;
2243 if (bs
->node_name
[0] != '\0') {
2244 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2246 bs
->node_name
[0] = '\0';
2249 /* Fields that need to stay with the top-level BDS */
2250 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2251 BlockDriverState
*bs_src
)
2253 /* move some fields that need to stay attached to the device */
2256 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2258 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2261 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2264 static void change_parent_backing_link(BlockDriverState
*from
,
2265 BlockDriverState
*to
)
2267 BdrvChild
*c
, *next
;
2269 QLIST_FOREACH_SAFE(c
, &from
->parents
, next_parent
, next
) {
2270 assert(c
->role
!= &child_backing
);
2272 QLIST_REMOVE(c
, next_parent
);
2273 QLIST_INSERT_HEAD(&to
->parents
, c
, next_parent
);
2278 blk_set_bs(from
->blk
, to
);
2279 if (!to
->device_list
.tqe_prev
) {
2280 QTAILQ_INSERT_BEFORE(from
, to
, device_list
);
2282 QTAILQ_REMOVE(&bdrv_states
, from
, device_list
);
2286 static void swap_feature_fields(BlockDriverState
*bs_top
,
2287 BlockDriverState
*bs_new
)
2289 BlockDriverState tmp
;
2291 bdrv_move_feature_fields(&tmp
, bs_top
);
2292 bdrv_move_feature_fields(bs_top
, bs_new
);
2293 bdrv_move_feature_fields(bs_new
, &tmp
);
2295 assert(!bs_new
->throttle_state
);
2296 if (bs_top
->throttle_state
) {
2297 assert(bs_top
->io_limits_enabled
);
2298 bdrv_io_limits_enable(bs_new
, throttle_group_get_name(bs_top
));
2299 bdrv_io_limits_disable(bs_top
);
2304 * Add new bs contents at the top of an image chain while the chain is
2305 * live, while keeping required fields on the top layer.
2307 * This will modify the BlockDriverState fields, and swap contents
2308 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2310 * bs_new must not be attached to a BlockBackend.
2312 * This function does not create any image files.
2314 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2315 * that's what the callers commonly need. bs_new will be referenced by the old
2316 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2317 * reference of its own, it must call bdrv_ref().
2319 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2321 assert(!bdrv_requests_pending(bs_top
));
2322 assert(!bdrv_requests_pending(bs_new
));
2325 change_parent_backing_link(bs_top
, bs_new
);
2327 /* Some fields always stay on top of the backing file chain */
2328 swap_feature_fields(bs_top
, bs_new
);
2330 bdrv_set_backing_hd(bs_new
, bs_top
);
2333 /* bs_new is now referenced by its new parents, we don't need the
2334 * additional reference any more. */
2338 void bdrv_replace_in_backing_chain(BlockDriverState
*old
, BlockDriverState
*new)
2340 assert(!bdrv_requests_pending(old
));
2341 assert(!bdrv_requests_pending(new));
2346 /* As long as these fields aren't in BlockBackend, but in the top-level
2347 * BlockDriverState, it's not possible for a BDS to have two BBs.
2349 * We really want to copy the fields from old to new, but we go for a
2350 * swap instead so that pointers aren't duplicated and cause trouble.
2351 * (Also, bdrv_swap() used to do the same.) */
2353 swap_feature_fields(old
, new);
2355 change_parent_backing_link(old
, new);
2357 /* Change backing files if a previously independent node is added to the
2358 * chain. For active commit, we replace top by its own (indirect) backing
2359 * file and don't do anything here so we don't build a loop. */
2360 if (new->backing
== NULL
&& !bdrv_chain_contains(backing_bs(old
), new)) {
2361 bdrv_set_backing_hd(new, backing_bs(old
));
2362 bdrv_set_backing_hd(old
, NULL
);
2368 static void bdrv_delete(BlockDriverState
*bs
)
2371 assert(bdrv_op_blocker_is_empty(bs
));
2372 assert(!bs
->refcnt
);
2376 /* remove from list, if necessary */
2379 QTAILQ_REMOVE(&all_bdrv_states
, bs
, bs_list
);
2385 * Run consistency checks on an image
2387 * Returns 0 if the check could be completed (it doesn't mean that the image is
2388 * free of errors) or -errno when an internal error occurred. The results of the
2389 * check are stored in res.
2391 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2393 if (bs
->drv
== NULL
) {
2396 if (bs
->drv
->bdrv_check
== NULL
) {
2400 memset(res
, 0, sizeof(*res
));
2401 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2404 #define COMMIT_BUF_SECTORS 2048
2406 /* commit COW file into the raw image */
2407 int bdrv_commit(BlockDriverState
*bs
)
2409 BlockDriver
*drv
= bs
->drv
;
2410 int64_t sector
, total_sectors
, length
, backing_length
;
2411 int n
, ro
, open_flags
;
2413 uint8_t *buf
= NULL
;
2422 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2423 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2427 ro
= bs
->backing
->bs
->read_only
;
2428 open_flags
= bs
->backing
->bs
->open_flags
;
2431 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2436 length
= bdrv_getlength(bs
);
2442 backing_length
= bdrv_getlength(bs
->backing
->bs
);
2443 if (backing_length
< 0) {
2444 ret
= backing_length
;
2448 /* If our top snapshot is larger than the backing file image,
2449 * grow the backing file image if possible. If not possible,
2450 * we must return an error */
2451 if (length
> backing_length
) {
2452 ret
= bdrv_truncate(bs
->backing
->bs
, length
);
2458 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2460 /* qemu_try_blockalign() for bs will choose an alignment that works for
2461 * bs->backing->bs as well, so no need to compare the alignment manually. */
2462 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2468 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2469 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2474 ret
= bdrv_read(bs
, sector
, buf
, n
);
2479 ret
= bdrv_write(bs
->backing
->bs
, sector
, buf
, n
);
2486 if (drv
->bdrv_make_empty
) {
2487 ret
= drv
->bdrv_make_empty(bs
);
2495 * Make sure all data we wrote to the backing device is actually
2499 bdrv_flush(bs
->backing
->bs
);
2507 /* ignoring error return here */
2508 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2514 int bdrv_commit_all(void)
2516 BlockDriverState
*bs
;
2518 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2519 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2521 aio_context_acquire(aio_context
);
2522 if (bs
->drv
&& bs
->backing
) {
2523 int ret
= bdrv_commit(bs
);
2525 aio_context_release(aio_context
);
2529 aio_context_release(aio_context
);
2537 * -EINVAL - backing format specified, but no file
2538 * -ENOSPC - can't update the backing file because no space is left in the
2540 * -ENOTSUP - format driver doesn't support changing the backing file
2542 int bdrv_change_backing_file(BlockDriverState
*bs
,
2543 const char *backing_file
, const char *backing_fmt
)
2545 BlockDriver
*drv
= bs
->drv
;
2548 /* Backing file format doesn't make sense without a backing file */
2549 if (backing_fmt
&& !backing_file
) {
2553 if (drv
->bdrv_change_backing_file
!= NULL
) {
2554 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2560 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2561 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2567 * Finds the image layer in the chain that has 'bs' as its backing file.
2569 * active is the current topmost image.
2571 * Returns NULL if bs is not found in active's image chain,
2572 * or if active == bs.
2574 * Returns the bottommost base image if bs == NULL.
2576 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2577 BlockDriverState
*bs
)
2579 while (active
&& bs
!= backing_bs(active
)) {
2580 active
= backing_bs(active
);
2586 /* Given a BDS, searches for the base layer. */
2587 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2589 return bdrv_find_overlay(bs
, NULL
);
2593 * Drops images above 'base' up to and including 'top', and sets the image
2594 * above 'top' to have base as its backing file.
2596 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2597 * information in 'bs' can be properly updated.
2599 * E.g., this will convert the following chain:
2600 * bottom <- base <- intermediate <- top <- active
2604 * bottom <- base <- active
2606 * It is allowed for bottom==base, in which case it converts:
2608 * base <- intermediate <- top <- active
2614 * If backing_file_str is non-NULL, it will be used when modifying top's
2615 * overlay image metadata.
2618 * if active == top, that is considered an error
2621 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2622 BlockDriverState
*base
, const char *backing_file_str
)
2624 BlockDriverState
*new_top_bs
= NULL
;
2627 if (!top
->drv
|| !base
->drv
) {
2631 new_top_bs
= bdrv_find_overlay(active
, top
);
2633 if (new_top_bs
== NULL
) {
2634 /* we could not find the image above 'top', this is an error */
2638 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2639 * to do, no intermediate images */
2640 if (backing_bs(new_top_bs
) == base
) {
2645 /* Make sure that base is in the backing chain of top */
2646 if (!bdrv_chain_contains(top
, base
)) {
2650 /* success - we can delete the intermediate states, and link top->base */
2651 backing_file_str
= backing_file_str
? backing_file_str
: base
->filename
;
2652 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2653 base
->drv
? base
->drv
->format_name
: "");
2657 bdrv_set_backing_hd(new_top_bs
, base
);
2665 * Truncate file to 'offset' bytes (needed only for file protocols)
2667 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2669 BlockDriver
*drv
= bs
->drv
;
2673 if (!drv
->bdrv_truncate
)
2678 ret
= drv
->bdrv_truncate(bs
, offset
);
2680 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2681 bdrv_dirty_bitmap_truncate(bs
);
2683 blk_dev_resize_cb(bs
->blk
);
2690 * Length of a allocated file in bytes. Sparse files are counted by actual
2691 * allocated space. Return < 0 if error or unknown.
2693 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2695 BlockDriver
*drv
= bs
->drv
;
2699 if (drv
->bdrv_get_allocated_file_size
) {
2700 return drv
->bdrv_get_allocated_file_size(bs
);
2703 return bdrv_get_allocated_file_size(bs
->file
->bs
);
2709 * Return number of sectors on success, -errno on error.
2711 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2713 BlockDriver
*drv
= bs
->drv
;
2718 if (drv
->has_variable_length
) {
2719 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2724 return bs
->total_sectors
;
2728 * Return length in bytes on success, -errno on error.
2729 * The length is always a multiple of BDRV_SECTOR_SIZE.
2731 int64_t bdrv_getlength(BlockDriverState
*bs
)
2733 int64_t ret
= bdrv_nb_sectors(bs
);
2735 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2736 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2739 /* return 0 as number of sectors if no device present or error */
2740 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2742 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2744 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2747 int bdrv_is_read_only(BlockDriverState
*bs
)
2749 return bs
->read_only
;
2752 int bdrv_is_sg(BlockDriverState
*bs
)
2757 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2759 return bs
->enable_write_cache
;
2762 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2764 bs
->enable_write_cache
= wce
;
2766 /* so a reopen() will preserve wce */
2768 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2770 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2774 int bdrv_is_encrypted(BlockDriverState
*bs
)
2776 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2779 return bs
->encrypted
;
2782 int bdrv_key_required(BlockDriverState
*bs
)
2784 BdrvChild
*backing
= bs
->backing
;
2786 if (backing
&& backing
->bs
->encrypted
&& !backing
->bs
->valid_key
) {
2789 return (bs
->encrypted
&& !bs
->valid_key
);
2792 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2795 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2796 ret
= bdrv_set_key(bs
->backing
->bs
, key
);
2802 if (!bs
->encrypted
) {
2804 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2807 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2810 } else if (!bs
->valid_key
) {
2813 /* call the change callback now, we skipped it on open */
2814 blk_dev_change_media_cb(bs
->blk
, true);
2821 * Provide an encryption key for @bs.
2822 * If @key is non-null:
2823 * If @bs is not encrypted, fail.
2824 * Else if the key is invalid, fail.
2825 * Else set @bs's key to @key, replacing the existing key, if any.
2827 * If @bs is encrypted and still lacks a key, fail.
2829 * On failure, store an error object through @errp if non-null.
2831 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2834 if (!bdrv_is_encrypted(bs
)) {
2835 error_setg(errp
, "Node '%s' is not encrypted",
2836 bdrv_get_device_or_node_name(bs
));
2837 } else if (bdrv_set_key(bs
, key
) < 0) {
2838 error_setg(errp
, QERR_INVALID_PASSWORD
);
2841 if (bdrv_key_required(bs
)) {
2842 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2843 "'%s' (%s) is encrypted",
2844 bdrv_get_device_or_node_name(bs
),
2845 bdrv_get_encrypted_filename(bs
));
2850 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2852 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2855 static int qsort_strcmp(const void *a
, const void *b
)
2857 return strcmp(a
, b
);
2860 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2866 const char **formats
= NULL
;
2868 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2869 if (drv
->format_name
) {
2872 while (formats
&& i
&& !found
) {
2873 found
= !strcmp(formats
[--i
], drv
->format_name
);
2877 formats
= g_renew(const char *, formats
, count
+ 1);
2878 formats
[count
++] = drv
->format_name
;
2883 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2885 for (i
= 0; i
< count
; i
++) {
2886 it(opaque
, formats
[i
]);
2892 /* This function is to find a node in the bs graph */
2893 BlockDriverState
*bdrv_find_node(const char *node_name
)
2895 BlockDriverState
*bs
;
2899 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2900 if (!strcmp(node_name
, bs
->node_name
)) {
2907 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2908 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2910 BlockDeviceInfoList
*list
, *entry
;
2911 BlockDriverState
*bs
;
2914 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2915 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2917 qapi_free_BlockDeviceInfoList(list
);
2920 entry
= g_malloc0(sizeof(*entry
));
2921 entry
->value
= info
;
2929 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2930 const char *node_name
,
2934 BlockDriverState
*bs
;
2937 blk
= blk_by_name(device
);
2942 error_setg(errp
, "Device '%s' has no medium", device
);
2950 bs
= bdrv_find_node(node_name
);
2957 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2958 device
? device
: "",
2959 node_name
? node_name
: "");
2963 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2964 * return false. If either argument is NULL, return false. */
2965 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2967 while (top
&& top
!= base
) {
2968 top
= backing_bs(top
);
2974 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2977 return QTAILQ_FIRST(&graph_bdrv_states
);
2979 return QTAILQ_NEXT(bs
, node_list
);
2982 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2985 return QTAILQ_FIRST(&bdrv_states
);
2987 return QTAILQ_NEXT(bs
, device_list
);
2990 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2992 return bs
->node_name
;
2995 /* TODO check what callers really want: bs->node_name or blk_name() */
2996 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2998 return bs
->blk
? blk_name(bs
->blk
) : "";
3001 /* This can be used to identify nodes that might not have a device
3002 * name associated. Since node and device names live in the same
3003 * namespace, the result is unambiguous. The exception is if both are
3004 * absent, then this returns an empty (non-null) string. */
3005 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
3007 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
3010 int bdrv_get_flags(BlockDriverState
*bs
)
3012 return bs
->open_flags
;
3015 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3020 int bdrv_has_zero_init(BlockDriverState
*bs
)
3024 /* If BS is a copy on write image, it is initialized to
3025 the contents of the base image, which may not be zeroes. */
3029 if (bs
->drv
->bdrv_has_zero_init
) {
3030 return bs
->drv
->bdrv_has_zero_init(bs
);
3037 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3039 BlockDriverInfo bdi
;
3045 if (bdrv_get_info(bs
, &bdi
) == 0) {
3046 return bdi
.unallocated_blocks_are_zero
;
3052 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3054 BlockDriverInfo bdi
;
3056 if (bs
->backing
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3060 if (bdrv_get_info(bs
, &bdi
) == 0) {
3061 return bdi
.can_write_zeroes_with_unmap
;
3067 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3069 if (bs
->backing
&& bs
->backing
->bs
->encrypted
)
3070 return bs
->backing_file
;
3071 else if (bs
->encrypted
)
3072 return bs
->filename
;
3077 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3078 char *filename
, int filename_size
)
3080 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3083 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3085 BlockDriver
*drv
= bs
->drv
;
3088 if (!drv
->bdrv_get_info
)
3090 memset(bdi
, 0, sizeof(*bdi
));
3091 return drv
->bdrv_get_info(bs
, bdi
);
3094 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3096 BlockDriver
*drv
= bs
->drv
;
3097 if (drv
&& drv
->bdrv_get_specific_info
) {
3098 return drv
->bdrv_get_specific_info(bs
);
3103 void bdrv_debug_event(BlockDriverState
*bs
, BlkdebugEvent event
)
3105 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3109 bs
->drv
->bdrv_debug_event(bs
, event
);
3112 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3115 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3116 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3119 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3120 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3126 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3128 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3129 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3132 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3133 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3139 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3141 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3142 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3145 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3146 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3152 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3154 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3155 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3158 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3159 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3165 int bdrv_is_snapshot(BlockDriverState
*bs
)
3167 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3170 /* backing_file can either be relative, or absolute, or a protocol. If it is
3171 * relative, it must be relative to the chain. So, passing in bs->filename
3172 * from a BDS as backing_file should not be done, as that may be relative to
3173 * the CWD rather than the chain. */
3174 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3175 const char *backing_file
)
3177 char *filename_full
= NULL
;
3178 char *backing_file_full
= NULL
;
3179 char *filename_tmp
= NULL
;
3180 int is_protocol
= 0;
3181 BlockDriverState
*curr_bs
= NULL
;
3182 BlockDriverState
*retval
= NULL
;
3184 if (!bs
|| !bs
->drv
|| !backing_file
) {
3188 filename_full
= g_malloc(PATH_MAX
);
3189 backing_file_full
= g_malloc(PATH_MAX
);
3190 filename_tmp
= g_malloc(PATH_MAX
);
3192 is_protocol
= path_has_protocol(backing_file
);
3194 for (curr_bs
= bs
; curr_bs
->backing
; curr_bs
= curr_bs
->backing
->bs
) {
3196 /* If either of the filename paths is actually a protocol, then
3197 * compare unmodified paths; otherwise make paths relative */
3198 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3199 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3200 retval
= curr_bs
->backing
->bs
;
3204 /* If not an absolute filename path, make it relative to the current
3205 * image's filename path */
3206 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3209 /* We are going to compare absolute pathnames */
3210 if (!realpath(filename_tmp
, filename_full
)) {
3214 /* We need to make sure the backing filename we are comparing against
3215 * is relative to the current image filename (or absolute) */
3216 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3217 curr_bs
->backing_file
);
3219 if (!realpath(filename_tmp
, backing_file_full
)) {
3223 if (strcmp(backing_file_full
, filename_full
) == 0) {
3224 retval
= curr_bs
->backing
->bs
;
3230 g_free(filename_full
);
3231 g_free(backing_file_full
);
3232 g_free(filename_tmp
);
3236 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3246 return 1 + bdrv_get_backing_file_depth(bs
->backing
->bs
);
3249 void bdrv_init(void)
3251 module_call_init(MODULE_INIT_BLOCK
);
3254 void bdrv_init_with_whitelist(void)
3256 use_bdrv_whitelist
= 1;
3260 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3262 Error
*local_err
= NULL
;
3269 if (!(bs
->open_flags
& BDRV_O_INACTIVE
)) {
3272 bs
->open_flags
&= ~BDRV_O_INACTIVE
;
3274 if (bs
->drv
->bdrv_invalidate_cache
) {
3275 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3276 } else if (bs
->file
) {
3277 bdrv_invalidate_cache(bs
->file
->bs
, &local_err
);
3280 bs
->open_flags
|= BDRV_O_INACTIVE
;
3281 error_propagate(errp
, local_err
);
3285 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3287 bs
->open_flags
|= BDRV_O_INACTIVE
;
3288 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3293 void bdrv_invalidate_cache_all(Error
**errp
)
3295 BlockDriverState
*bs
;
3296 Error
*local_err
= NULL
;
3298 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3299 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3301 aio_context_acquire(aio_context
);
3302 bdrv_invalidate_cache(bs
, &local_err
);
3303 aio_context_release(aio_context
);
3305 error_propagate(errp
, local_err
);
3311 static int bdrv_inactivate(BlockDriverState
*bs
)
3315 if (bs
->drv
->bdrv_inactivate
) {
3316 ret
= bs
->drv
->bdrv_inactivate(bs
);
3322 bs
->open_flags
|= BDRV_O_INACTIVE
;
3326 int bdrv_inactivate_all(void)
3328 BlockDriverState
*bs
;
3331 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3332 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3334 aio_context_acquire(aio_context
);
3335 ret
= bdrv_inactivate(bs
);
3336 aio_context_release(aio_context
);
3345 /**************************************************************/
3346 /* removable device support */
3349 * Return TRUE if the media is present
3351 bool bdrv_is_inserted(BlockDriverState
*bs
)
3353 BlockDriver
*drv
= bs
->drv
;
3359 if (drv
->bdrv_is_inserted
) {
3360 return drv
->bdrv_is_inserted(bs
);
3362 QLIST_FOREACH(child
, &bs
->children
, next
) {
3363 if (!bdrv_is_inserted(child
->bs
)) {
3371 * Return whether the media changed since the last call to this
3372 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3374 int bdrv_media_changed(BlockDriverState
*bs
)
3376 BlockDriver
*drv
= bs
->drv
;
3378 if (drv
&& drv
->bdrv_media_changed
) {
3379 return drv
->bdrv_media_changed(bs
);
3385 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3387 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3389 BlockDriver
*drv
= bs
->drv
;
3390 const char *device_name
;
3392 if (drv
&& drv
->bdrv_eject
) {
3393 drv
->bdrv_eject(bs
, eject_flag
);
3396 device_name
= bdrv_get_device_name(bs
);
3397 if (device_name
[0] != '\0') {
3398 qapi_event_send_device_tray_moved(device_name
,
3399 eject_flag
, &error_abort
);
3404 * Lock or unlock the media (if it is locked, the user won't be able
3405 * to eject it manually).
3407 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3409 BlockDriver
*drv
= bs
->drv
;
3411 trace_bdrv_lock_medium(bs
, locked
);
3413 if (drv
&& drv
->bdrv_lock_medium
) {
3414 drv
->bdrv_lock_medium(bs
, locked
);
3418 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3420 BdrvDirtyBitmap
*bm
;
3423 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3424 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3431 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3433 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3434 g_free(bitmap
->name
);
3435 bitmap
->name
= NULL
;
3438 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3439 uint32_t granularity
,
3443 int64_t bitmap_size
;
3444 BdrvDirtyBitmap
*bitmap
;
3445 uint32_t sector_granularity
;
3447 assert((granularity
& (granularity
- 1)) == 0);
3449 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3450 error_setg(errp
, "Bitmap already exists: %s", name
);
3453 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3454 assert(sector_granularity
);
3455 bitmap_size
= bdrv_nb_sectors(bs
);
3456 if (bitmap_size
< 0) {
3457 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3458 errno
= -bitmap_size
;
3461 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3462 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3463 bitmap
->size
= bitmap_size
;
3464 bitmap
->name
= g_strdup(name
);
3465 bitmap
->disabled
= false;
3466 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3470 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3472 return bitmap
->successor
;
3475 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3477 return !(bitmap
->disabled
|| bitmap
->successor
);
3480 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3482 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3483 return DIRTY_BITMAP_STATUS_FROZEN
;
3484 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3485 return DIRTY_BITMAP_STATUS_DISABLED
;
3487 return DIRTY_BITMAP_STATUS_ACTIVE
;
3492 * Create a successor bitmap destined to replace this bitmap after an operation.
3493 * Requires that the bitmap is not frozen and has no successor.
3495 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3496 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3498 uint64_t granularity
;
3499 BdrvDirtyBitmap
*child
;
3501 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3502 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3503 "currently frozen");
3506 assert(!bitmap
->successor
);
3508 /* Create an anonymous successor */
3509 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3510 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3515 /* Successor will be on or off based on our current state. */
3516 child
->disabled
= bitmap
->disabled
;
3518 /* Install the successor and freeze the parent */
3519 bitmap
->successor
= child
;
3524 * For a bitmap with a successor, yield our name to the successor,
3525 * delete the old bitmap, and return a handle to the new bitmap.
3527 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3528 BdrvDirtyBitmap
*bitmap
,
3532 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3534 if (successor
== NULL
) {
3535 error_setg(errp
, "Cannot relinquish control if "
3536 "there's no successor present");
3540 name
= bitmap
->name
;
3541 bitmap
->name
= NULL
;
3542 successor
->name
= name
;
3543 bitmap
->successor
= NULL
;
3544 bdrv_release_dirty_bitmap(bs
, bitmap
);
3550 * In cases of failure where we can no longer safely delete the parent,
3551 * we may wish to re-join the parent and child/successor.
3552 * The merged parent will be un-frozen, but not explicitly re-enabled.
3554 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3555 BdrvDirtyBitmap
*parent
,
3558 BdrvDirtyBitmap
*successor
= parent
->successor
;
3561 error_setg(errp
, "Cannot reclaim a successor when none is present");
3565 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3566 error_setg(errp
, "Merging of parent and successor bitmap failed");
3569 bdrv_release_dirty_bitmap(bs
, successor
);
3570 parent
->successor
= NULL
;
3576 * Truncates _all_ bitmaps attached to a BDS.
3578 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3580 BdrvDirtyBitmap
*bitmap
;
3581 uint64_t size
= bdrv_nb_sectors(bs
);
3583 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3584 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3585 hbitmap_truncate(bitmap
->bitmap
, size
);
3586 bitmap
->size
= size
;
3590 static void bdrv_do_release_matching_dirty_bitmap(BlockDriverState
*bs
,
3591 BdrvDirtyBitmap
*bitmap
,
3594 BdrvDirtyBitmap
*bm
, *next
;
3595 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3596 if ((!bitmap
|| bm
== bitmap
) && (!only_named
|| bm
->name
)) {
3597 assert(!bdrv_dirty_bitmap_frozen(bm
));
3598 QLIST_REMOVE(bm
, list
);
3599 hbitmap_free(bm
->bitmap
);
3610 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3612 bdrv_do_release_matching_dirty_bitmap(bs
, bitmap
, false);
3616 * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()).
3617 * There must not be any frozen bitmaps attached.
3619 static void bdrv_release_named_dirty_bitmaps(BlockDriverState
*bs
)
3621 bdrv_do_release_matching_dirty_bitmap(bs
, NULL
, true);
3624 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3626 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3627 bitmap
->disabled
= true;
3630 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3632 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3633 bitmap
->disabled
= false;
3636 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3638 BdrvDirtyBitmap
*bm
;
3639 BlockDirtyInfoList
*list
= NULL
;
3640 BlockDirtyInfoList
**plist
= &list
;
3642 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3643 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3644 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3645 info
->count
= bdrv_get_dirty_count(bm
);
3646 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3647 info
->has_name
= !!bm
->name
;
3648 info
->name
= g_strdup(bm
->name
);
3649 info
->status
= bdrv_dirty_bitmap_status(bm
);
3650 entry
->value
= info
;
3652 plist
= &entry
->next
;
3658 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3661 return hbitmap_get(bitmap
->bitmap
, sector
);
3668 * Chooses a default granularity based on the existing cluster size,
3669 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3670 * is no cluster size information available.
3672 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3674 BlockDriverInfo bdi
;
3675 uint32_t granularity
;
3677 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3678 granularity
= MAX(4096, bdi
.cluster_size
);
3679 granularity
= MIN(65536, granularity
);
3681 granularity
= 65536;
3687 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3689 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3692 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3694 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3697 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3698 int64_t cur_sector
, int nr_sectors
)
3700 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3701 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3704 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3705 int64_t cur_sector
, int nr_sectors
)
3707 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3708 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3711 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
**out
)
3713 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3715 hbitmap_reset_all(bitmap
->bitmap
);
3717 HBitmap
*backup
= bitmap
->bitmap
;
3718 bitmap
->bitmap
= hbitmap_alloc(bitmap
->size
,
3719 hbitmap_granularity(backup
));
3724 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
*in
)
3726 HBitmap
*tmp
= bitmap
->bitmap
;
3727 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3728 bitmap
->bitmap
= in
;
3732 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3735 BdrvDirtyBitmap
*bitmap
;
3736 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3737 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3740 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3745 * Advance an HBitmapIter to an arbitrary offset.
3747 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3750 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3753 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3755 return hbitmap_count(bitmap
->bitmap
);
3758 /* Get a reference to bs */
3759 void bdrv_ref(BlockDriverState
*bs
)
3764 /* Release a previously grabbed reference to bs.
3765 * If after releasing, reference count is zero, the BlockDriverState is
3767 void bdrv_unref(BlockDriverState
*bs
)
3772 assert(bs
->refcnt
> 0);
3773 if (--bs
->refcnt
== 0) {
3778 struct BdrvOpBlocker
{
3780 QLIST_ENTRY(BdrvOpBlocker
) list
;
3783 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3785 BdrvOpBlocker
*blocker
;
3786 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3787 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3788 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3790 *errp
= error_copy(blocker
->reason
);
3791 error_prepend(errp
, "Node '%s' is busy: ",
3792 bdrv_get_device_or_node_name(bs
));
3799 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3801 BdrvOpBlocker
*blocker
;
3802 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3804 blocker
= g_new0(BdrvOpBlocker
, 1);
3805 blocker
->reason
= reason
;
3806 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3809 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3811 BdrvOpBlocker
*blocker
, *next
;
3812 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3813 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3814 if (blocker
->reason
== reason
) {
3815 QLIST_REMOVE(blocker
, list
);
3821 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3824 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3825 bdrv_op_block(bs
, i
, reason
);
3829 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3832 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3833 bdrv_op_unblock(bs
, i
, reason
);
3837 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3841 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3842 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3849 void bdrv_img_create(const char *filename
, const char *fmt
,
3850 const char *base_filename
, const char *base_fmt
,
3851 char *options
, uint64_t img_size
, int flags
,
3852 Error
**errp
, bool quiet
)
3854 QemuOptsList
*create_opts
= NULL
;
3855 QemuOpts
*opts
= NULL
;
3856 const char *backing_fmt
, *backing_file
;
3858 BlockDriver
*drv
, *proto_drv
;
3859 Error
*local_err
= NULL
;
3862 /* Find driver and parse its options */
3863 drv
= bdrv_find_format(fmt
);
3865 error_setg(errp
, "Unknown file format '%s'", fmt
);
3869 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3874 if (!drv
->create_opts
) {
3875 error_setg(errp
, "Format driver '%s' does not support image creation",
3880 if (!proto_drv
->create_opts
) {
3881 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3882 proto_drv
->format_name
);
3886 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3887 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3889 /* Create parameter list with default values */
3890 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3891 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3893 /* Parse -o options */
3895 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3897 error_report_err(local_err
);
3899 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3904 if (base_filename
) {
3905 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3907 error_setg(errp
, "Backing file not supported for file format '%s'",
3914 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3916 error_setg(errp
, "Backing file format not supported for file "
3917 "format '%s'", fmt
);
3922 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3924 if (!strcmp(filename
, backing_file
)) {
3925 error_setg(errp
, "Error: Trying to create an image with the "
3926 "same filename as the backing file");
3931 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3933 // The size for the image must always be specified, with one exception:
3934 // If we are using a backing file, we can obtain the size from there
3935 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3938 BlockDriverState
*bs
;
3939 char *full_backing
= g_new0(char, PATH_MAX
);
3942 QDict
*backing_options
= NULL
;
3944 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3945 full_backing
, PATH_MAX
,
3948 g_free(full_backing
);
3952 /* backing files always opened read-only */
3954 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3957 backing_options
= qdict_new();
3958 qdict_put(backing_options
, "driver",
3959 qstring_from_str(backing_fmt
));
3963 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3964 back_flags
, &local_err
);
3965 g_free(full_backing
);
3969 size
= bdrv_getlength(bs
);
3971 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3977 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3981 error_setg(errp
, "Image creation needs a size parameter");
3987 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3988 qemu_opts_print(opts
, " ");
3992 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3994 if (ret
== -EFBIG
) {
3995 /* This is generally a better message than whatever the driver would
3996 * deliver (especially because of the cluster_size_hint), since that
3997 * is most probably not much different from "image too large". */
3998 const char *cluster_size_hint
= "";
3999 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
4000 cluster_size_hint
= " (try using a larger cluster size)";
4002 error_setg(errp
, "The image size is too large for file format '%s'"
4003 "%s", fmt
, cluster_size_hint
);
4004 error_free(local_err
);
4009 qemu_opts_del(opts
);
4010 qemu_opts_free(create_opts
);
4012 error_propagate(errp
, local_err
);
4016 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
4018 return bs
->aio_context
;
4021 void bdrv_detach_aio_context(BlockDriverState
*bs
)
4023 BdrvAioNotifier
*baf
;
4029 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
4030 baf
->detach_aio_context(baf
->opaque
);
4033 if (bs
->throttle_state
) {
4034 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
4036 if (bs
->drv
->bdrv_detach_aio_context
) {
4037 bs
->drv
->bdrv_detach_aio_context(bs
);
4040 bdrv_detach_aio_context(bs
->file
->bs
);
4043 bdrv_detach_aio_context(bs
->backing
->bs
);
4046 bs
->aio_context
= NULL
;
4049 void bdrv_attach_aio_context(BlockDriverState
*bs
,
4050 AioContext
*new_context
)
4052 BdrvAioNotifier
*ban
;
4058 bs
->aio_context
= new_context
;
4061 bdrv_attach_aio_context(bs
->backing
->bs
, new_context
);
4064 bdrv_attach_aio_context(bs
->file
->bs
, new_context
);
4066 if (bs
->drv
->bdrv_attach_aio_context
) {
4067 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
4069 if (bs
->throttle_state
) {
4070 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
4073 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
4074 ban
->attached_aio_context(new_context
, ban
->opaque
);
4078 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
4080 bdrv_drain(bs
); /* ensure there are no in-flight requests */
4082 bdrv_detach_aio_context(bs
);
4084 /* This function executes in the old AioContext so acquire the new one in
4085 * case it runs in a different thread.
4087 aio_context_acquire(new_context
);
4088 bdrv_attach_aio_context(bs
, new_context
);
4089 aio_context_release(new_context
);
4092 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
4093 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
4094 void (*detach_aio_context
)(void *opaque
), void *opaque
)
4096 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
4097 *ban
= (BdrvAioNotifier
){
4098 .attached_aio_context
= attached_aio_context
,
4099 .detach_aio_context
= detach_aio_context
,
4103 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
4106 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
4107 void (*attached_aio_context
)(AioContext
*,
4109 void (*detach_aio_context
)(void *),
4112 BdrvAioNotifier
*ban
, *ban_next
;
4114 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
4115 if (ban
->attached_aio_context
== attached_aio_context
&&
4116 ban
->detach_aio_context
== detach_aio_context
&&
4117 ban
->opaque
== opaque
)
4119 QLIST_REMOVE(ban
, list
);
4129 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
4130 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
4132 if (!bs
->drv
->bdrv_amend_options
) {
4135 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
, cb_opaque
);
4138 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4139 * of block filter and by bdrv_is_first_non_filter.
4140 * It is used to test if the given bs is the candidate or recurse more in the
4143 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
4144 BlockDriverState
*candidate
)
4146 /* return false if basic checks fails */
4147 if (!bs
|| !bs
->drv
) {
4151 /* the code reached a non block filter driver -> check if the bs is
4152 * the same as the candidate. It's the recursion termination condition.
4154 if (!bs
->drv
->is_filter
) {
4155 return bs
== candidate
;
4157 /* Down this path the driver is a block filter driver */
4159 /* If the block filter recursion method is defined use it to recurse down
4162 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4163 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4166 /* the driver is a block filter but don't allow to recurse -> return false
4171 /* This function checks if the candidate is the first non filter bs down it's
4172 * bs chain. Since we don't have pointers to parents it explore all bs chains
4173 * from the top. Some filters can choose not to pass down the recursion.
4175 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4177 BlockDriverState
*bs
;
4179 /* walk down the bs forest recursively */
4180 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4183 /* try to recurse in this top level bs */
4184 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4186 /* candidate is the first non filter */
4195 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
4196 const char *node_name
, Error
**errp
)
4198 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4199 AioContext
*aio_context
;
4201 if (!to_replace_bs
) {
4202 error_setg(errp
, "Node name '%s' not found", node_name
);
4206 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4207 aio_context_acquire(aio_context
);
4209 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4210 to_replace_bs
= NULL
;
4214 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4215 * most non filter in order to prevent data corruption.
4216 * Another benefit is that this tests exclude backing files which are
4217 * blocked by the backing blockers.
4219 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
4220 error_setg(errp
, "Only top most non filter can be replaced");
4221 to_replace_bs
= NULL
;
4226 aio_context_release(aio_context
);
4227 return to_replace_bs
;
4230 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4232 const QDictEntry
*entry
;
4235 bool found_any
= false;
4238 for (entry
= qdict_first(bs
->options
); entry
;
4239 entry
= qdict_next(bs
->options
, entry
))
4241 /* Exclude options for children */
4242 QLIST_FOREACH(child
, &bs
->children
, next
) {
4243 if (strstart(qdict_entry_key(entry
), child
->name
, &p
)
4244 && (!*p
|| *p
== '.'))
4253 /* And exclude all non-driver-specific options */
4254 for (desc
= bdrv_runtime_opts
.desc
; desc
->name
; desc
++) {
4255 if (!strcmp(qdict_entry_key(entry
), desc
->name
)) {
4263 qobject_incref(qdict_entry_value(entry
));
4264 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4271 /* Updates the following BDS fields:
4272 * - exact_filename: A filename which may be used for opening a block device
4273 * which (mostly) equals the given BDS (even without any
4274 * other options; so reading and writing must return the same
4275 * results, but caching etc. may be different)
4276 * - full_open_options: Options which, when given when opening a block device
4277 * (without a filename), result in a BDS (mostly)
4278 * equalling the given one
4279 * - filename: If exact_filename is set, it is copied here. Otherwise,
4280 * full_open_options is converted to a JSON object, prefixed with
4281 * "json:" (for use through the JSON pseudo protocol) and put here.
4283 void bdrv_refresh_filename(BlockDriverState
*bs
)
4285 BlockDriver
*drv
= bs
->drv
;
4292 /* This BDS's file name will most probably depend on its file's name, so
4293 * refresh that first */
4295 bdrv_refresh_filename(bs
->file
->bs
);
4298 if (drv
->bdrv_refresh_filename
) {
4299 /* Obsolete information is of no use here, so drop the old file name
4300 * information before refreshing it */
4301 bs
->exact_filename
[0] = '\0';
4302 if (bs
->full_open_options
) {
4303 QDECREF(bs
->full_open_options
);
4304 bs
->full_open_options
= NULL
;
4308 append_open_options(opts
, bs
);
4309 drv
->bdrv_refresh_filename(bs
, opts
);
4311 } else if (bs
->file
) {
4312 /* Try to reconstruct valid information from the underlying file */
4313 bool has_open_options
;
4315 bs
->exact_filename
[0] = '\0';
4316 if (bs
->full_open_options
) {
4317 QDECREF(bs
->full_open_options
);
4318 bs
->full_open_options
= NULL
;
4322 has_open_options
= append_open_options(opts
, bs
);
4324 /* If no specific options have been given for this BDS, the filename of
4325 * the underlying file should suffice for this one as well */
4326 if (bs
->file
->bs
->exact_filename
[0] && !has_open_options
) {
4327 strcpy(bs
->exact_filename
, bs
->file
->bs
->exact_filename
);
4329 /* Reconstructing the full options QDict is simple for most format block
4330 * drivers, as long as the full options are known for the underlying
4331 * file BDS. The full options QDict of that file BDS should somehow
4332 * contain a representation of the filename, therefore the following
4333 * suffices without querying the (exact_)filename of this BDS. */
4334 if (bs
->file
->bs
->full_open_options
) {
4335 qdict_put_obj(opts
, "driver",
4336 QOBJECT(qstring_from_str(drv
->format_name
)));
4337 QINCREF(bs
->file
->bs
->full_open_options
);
4338 qdict_put_obj(opts
, "file",
4339 QOBJECT(bs
->file
->bs
->full_open_options
));
4341 bs
->full_open_options
= opts
;
4345 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4346 /* There is no underlying file BDS (at least referenced by BDS.file),
4347 * so the full options QDict should be equal to the options given
4348 * specifically for this block device when it was opened (plus the
4349 * driver specification).
4350 * Because those options don't change, there is no need to update
4351 * full_open_options when it's already set. */
4354 append_open_options(opts
, bs
);
4355 qdict_put_obj(opts
, "driver",
4356 QOBJECT(qstring_from_str(drv
->format_name
)));
4358 if (bs
->exact_filename
[0]) {
4359 /* This may not work for all block protocol drivers (some may
4360 * require this filename to be parsed), but we have to find some
4361 * default solution here, so just include it. If some block driver
4362 * does not support pure options without any filename at all or
4363 * needs some special format of the options QDict, it needs to
4364 * implement the driver-specific bdrv_refresh_filename() function.
4366 qdict_put_obj(opts
, "filename",
4367 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4370 bs
->full_open_options
= opts
;
4373 if (bs
->exact_filename
[0]) {
4374 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4375 } else if (bs
->full_open_options
) {
4376 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4377 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4378 qstring_get_str(json
));