2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "block/blockjob.h"
28 #include "qemu/error-report.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qerror.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
42 #include "qemu/cutils.h"
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
57 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
59 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
60 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
62 static QTAILQ_HEAD(, BlockDriverState
) all_bdrv_states
=
63 QTAILQ_HEAD_INITIALIZER(all_bdrv_states
);
65 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
66 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
68 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
69 const char *reference
, QDict
*options
, int flags
,
70 BlockDriverState
*parent
,
71 const BdrvChildRole
*child_role
, Error
**errp
);
73 /* If non-zero, use only whitelisted block drivers */
74 static int use_bdrv_whitelist
;
76 static void bdrv_close(BlockDriverState
*bs
);
79 static int is_windows_drive_prefix(const char *filename
)
81 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
82 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
86 int is_windows_drive(const char *filename
)
88 if (is_windows_drive_prefix(filename
) &&
91 if (strstart(filename
, "\\\\.\\", NULL
) ||
92 strstart(filename
, "//./", NULL
))
98 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
100 if (!bs
|| !bs
->drv
) {
101 /* page size or 4k (hdd sector size) should be on the safe side */
102 return MAX(4096, getpagesize());
105 return bs
->bl
.opt_mem_alignment
;
108 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
110 if (!bs
|| !bs
->drv
) {
111 /* page size or 4k (hdd sector size) should be on the safe side */
112 return MAX(4096, getpagesize());
115 return bs
->bl
.min_mem_alignment
;
118 /* check if the path starts with "<protocol>:" */
119 int path_has_protocol(const char *path
)
124 if (is_windows_drive(path
) ||
125 is_windows_drive_prefix(path
)) {
128 p
= path
+ strcspn(path
, ":/\\");
130 p
= path
+ strcspn(path
, ":/");
136 int path_is_absolute(const char *path
)
139 /* specific case for names like: "\\.\d:" */
140 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
143 return (*path
== '/' || *path
== '\\');
145 return (*path
== '/');
149 /* if filename is absolute, just copy it to dest. Otherwise, build a
150 path to it by considering it is relative to base_path. URL are
152 void path_combine(char *dest
, int dest_size
,
153 const char *base_path
,
154 const char *filename
)
161 if (path_is_absolute(filename
)) {
162 pstrcpy(dest
, dest_size
, filename
);
164 p
= strchr(base_path
, ':');
169 p1
= strrchr(base_path
, '/');
173 p2
= strrchr(base_path
, '\\');
185 if (len
> dest_size
- 1)
187 memcpy(dest
, base_path
, len
);
189 pstrcat(dest
, dest_size
, filename
);
193 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
195 char *dest
, size_t sz
,
198 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
199 path_is_absolute(backing
))
201 pstrcpy(dest
, sz
, backing
);
202 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
203 error_setg(errp
, "Cannot use relative backing file names for '%s'",
206 path_combine(dest
, sz
, backed
, backing
);
210 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
213 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
215 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
219 void bdrv_register(BlockDriver
*bdrv
)
221 bdrv_setup_io_funcs(bdrv
);
223 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
226 BlockDriverState
*bdrv_new_root(void)
231 BlockDriverState
*bdrv_new(void)
233 BlockDriverState
*bs
;
236 bs
= g_new0(BlockDriverState
, 1);
237 QLIST_INIT(&bs
->dirty_bitmaps
);
238 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
239 QLIST_INIT(&bs
->op_blockers
[i
]);
241 notifier_with_return_list_init(&bs
->before_write_notifiers
);
242 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
243 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
245 bs
->aio_context
= qemu_get_aio_context();
247 QTAILQ_INSERT_TAIL(&all_bdrv_states
, bs
, bs_list
);
252 BlockDriver
*bdrv_find_format(const char *format_name
)
255 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
256 if (!strcmp(drv1
->format_name
, format_name
)) {
263 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
265 static const char *whitelist_rw
[] = {
266 CONFIG_BDRV_RW_WHITELIST
268 static const char *whitelist_ro
[] = {
269 CONFIG_BDRV_RO_WHITELIST
273 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
274 return 1; /* no whitelist, anything goes */
277 for (p
= whitelist_rw
; *p
; p
++) {
278 if (!strcmp(drv
->format_name
, *p
)) {
283 for (p
= whitelist_ro
; *p
; p
++) {
284 if (!strcmp(drv
->format_name
, *p
)) {
292 bool bdrv_uses_whitelist(void)
294 return use_bdrv_whitelist
;
297 typedef struct CreateCo
{
305 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
307 Error
*local_err
= NULL
;
310 CreateCo
*cco
= opaque
;
313 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
315 error_propagate(&cco
->err
, local_err
);
320 int bdrv_create(BlockDriver
*drv
, const char* filename
,
321 QemuOpts
*opts
, Error
**errp
)
328 .filename
= g_strdup(filename
),
334 if (!drv
->bdrv_create
) {
335 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
340 if (qemu_in_coroutine()) {
341 /* Fast-path if already in coroutine context */
342 bdrv_create_co_entry(&cco
);
344 co
= qemu_coroutine_create(bdrv_create_co_entry
);
345 qemu_coroutine_enter(co
, &cco
);
346 while (cco
.ret
== NOT_DONE
) {
347 aio_poll(qemu_get_aio_context(), true);
354 error_propagate(errp
, cco
.err
);
356 error_setg_errno(errp
, -ret
, "Could not create image");
361 g_free(cco
.filename
);
365 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
368 Error
*local_err
= NULL
;
371 drv
= bdrv_find_protocol(filename
, true, errp
);
376 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
378 error_propagate(errp
, local_err
);
384 * Try to get @bs's logical and physical block size.
385 * On success, store them in @bsz struct and return 0.
386 * On failure return -errno.
387 * @bs must not be empty.
389 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
391 BlockDriver
*drv
= bs
->drv
;
393 if (drv
&& drv
->bdrv_probe_blocksizes
) {
394 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
401 * Try to get @bs's geometry (cyls, heads, sectors).
402 * On success, store them in @geo struct and return 0.
403 * On failure return -errno.
404 * @bs must not be empty.
406 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
408 BlockDriver
*drv
= bs
->drv
;
410 if (drv
&& drv
->bdrv_probe_geometry
) {
411 return drv
->bdrv_probe_geometry(bs
, geo
);
418 * Create a uniquely-named empty temporary file.
419 * Return 0 upon success, otherwise a negative errno value.
421 int get_tmp_filename(char *filename
, int size
)
424 char temp_dir
[MAX_PATH
];
425 /* GetTempFileName requires that its output buffer (4th param)
426 have length MAX_PATH or greater. */
427 assert(size
>= MAX_PATH
);
428 return (GetTempPath(MAX_PATH
, temp_dir
)
429 && GetTempFileName(temp_dir
, "qem", 0, filename
)
430 ? 0 : -GetLastError());
434 tmpdir
= getenv("TMPDIR");
438 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
441 fd
= mkstemp(filename
);
445 if (close(fd
) != 0) {
454 * Detect host devices. By convention, /dev/cdrom[N] is always
455 * recognized as a host CDROM.
457 static BlockDriver
*find_hdev_driver(const char *filename
)
459 int score_max
= 0, score
;
460 BlockDriver
*drv
= NULL
, *d
;
462 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
463 if (d
->bdrv_probe_device
) {
464 score
= d
->bdrv_probe_device(filename
);
465 if (score
> score_max
) {
475 BlockDriver
*bdrv_find_protocol(const char *filename
,
476 bool allow_protocol_prefix
,
484 /* TODO Drivers without bdrv_file_open must be specified explicitly */
487 * XXX(hch): we really should not let host device detection
488 * override an explicit protocol specification, but moving this
489 * later breaks access to device names with colons in them.
490 * Thanks to the brain-dead persistent naming schemes on udev-
491 * based Linux systems those actually are quite common.
493 drv1
= find_hdev_driver(filename
);
498 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
502 p
= strchr(filename
, ':');
505 if (len
> sizeof(protocol
) - 1)
506 len
= sizeof(protocol
) - 1;
507 memcpy(protocol
, filename
, len
);
508 protocol
[len
] = '\0';
509 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
510 if (drv1
->protocol_name
&&
511 !strcmp(drv1
->protocol_name
, protocol
)) {
516 error_setg(errp
, "Unknown protocol '%s'", protocol
);
521 * Guess image format by probing its contents.
522 * This is not a good idea when your image is raw (CVE-2008-2004), but
523 * we do it anyway for backward compatibility.
525 * @buf contains the image's first @buf_size bytes.
526 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
527 * but can be smaller if the image file is smaller)
528 * @filename is its filename.
530 * For all block drivers, call the bdrv_probe() method to get its
532 * Return the first block driver with the highest probing score.
534 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
535 const char *filename
)
537 int score_max
= 0, score
;
538 BlockDriver
*drv
= NULL
, *d
;
540 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
542 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
543 if (score
> score_max
) {
553 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
554 BlockDriver
**pdrv
, Error
**errp
)
557 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
560 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
561 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
566 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
568 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
574 drv
= bdrv_probe_all(buf
, ret
, filename
);
576 error_setg(errp
, "Could not determine image format: No compatible "
585 * Set the current 'total_sectors' value
586 * Return 0 on success, -errno on error.
588 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
590 BlockDriver
*drv
= bs
->drv
;
592 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
596 /* query actual device if possible, otherwise just trust the hint */
597 if (drv
->bdrv_getlength
) {
598 int64_t length
= drv
->bdrv_getlength(bs
);
602 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
605 bs
->total_sectors
= hint
;
610 * Combines a QDict of new block driver @options with any missing options taken
611 * from @old_options, so that leaving out an option defaults to its old value.
613 static void bdrv_join_options(BlockDriverState
*bs
, QDict
*options
,
616 if (bs
->drv
&& bs
->drv
->bdrv_join_options
) {
617 bs
->drv
->bdrv_join_options(options
, old_options
);
619 qdict_join(options
, old_options
, false);
624 * Set open flags for a given discard mode
626 * Return 0 on success, -1 if the discard mode was invalid.
628 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
630 *flags
&= ~BDRV_O_UNMAP
;
632 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
634 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
635 *flags
|= BDRV_O_UNMAP
;
644 * Set open flags for a given cache mode
646 * Return 0 on success, -1 if the cache mode was invalid.
648 int bdrv_parse_cache_mode(const char *mode
, int *flags
, bool *writethrough
)
650 *flags
&= ~BDRV_O_CACHE_MASK
;
652 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
653 *writethrough
= false;
654 *flags
|= BDRV_O_NOCACHE
;
655 } else if (!strcmp(mode
, "directsync")) {
656 *writethrough
= true;
657 *flags
|= BDRV_O_NOCACHE
;
658 } else if (!strcmp(mode
, "writeback")) {
659 *writethrough
= false;
660 } else if (!strcmp(mode
, "unsafe")) {
661 *writethrough
= false;
662 *flags
|= BDRV_O_NO_FLUSH
;
663 } else if (!strcmp(mode
, "writethrough")) {
664 *writethrough
= true;
673 * Returns the options and flags that a temporary snapshot should get, based on
674 * the originally requested flags (the originally requested image will have
675 * flags like a backing file)
677 static void bdrv_temp_snapshot_options(int *child_flags
, QDict
*child_options
,
678 int parent_flags
, QDict
*parent_options
)
680 *child_flags
= (parent_flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
682 /* For temporary files, unconditional cache=unsafe is fine */
683 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_WB
, "on");
684 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_DIRECT
, "off");
685 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_NO_FLUSH
, "on");
689 * Returns the options and flags that bs->file should get if a protocol driver
690 * is expected, based on the given options and flags for the parent BDS
692 static void bdrv_inherited_options(int *child_flags
, QDict
*child_options
,
693 int parent_flags
, QDict
*parent_options
)
695 int flags
= parent_flags
;
697 /* Enable protocol handling, disable format probing for bs->file */
698 flags
|= BDRV_O_PROTOCOL
;
700 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
702 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
703 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
705 /* Our block drivers take care to send flushes and respect unmap policy,
706 * so we can default to enable both on lower layers regardless of the
707 * corresponding parent options. */
708 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_WB
, "on");
709 flags
|= BDRV_O_UNMAP
;
711 /* Clear flags that only apply to the top layer */
712 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
|
715 *child_flags
= flags
;
718 const BdrvChildRole child_file
= {
719 .inherit_options
= bdrv_inherited_options
,
723 * Returns the options and flags that bs->file should get if the use of formats
724 * (and not only protocols) is permitted for it, based on the given options and
725 * flags for the parent BDS
727 static void bdrv_inherited_fmt_options(int *child_flags
, QDict
*child_options
,
728 int parent_flags
, QDict
*parent_options
)
730 child_file
.inherit_options(child_flags
, child_options
,
731 parent_flags
, parent_options
);
733 *child_flags
&= ~(BDRV_O_PROTOCOL
| BDRV_O_NO_IO
);
736 const BdrvChildRole child_format
= {
737 .inherit_options
= bdrv_inherited_fmt_options
,
741 * Returns the options and flags that bs->backing should get, based on the
742 * given options and flags for the parent BDS
744 static void bdrv_backing_options(int *child_flags
, QDict
*child_options
,
745 int parent_flags
, QDict
*parent_options
)
747 int flags
= parent_flags
;
749 /* The cache mode is inherited unmodified for backing files; except WCE,
750 * which is only applied on the top level (BlockBackend) */
751 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_WB
, "on");
752 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
753 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
755 /* backing files always opened read-only */
756 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
758 /* snapshot=on is handled on the top layer */
759 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
761 *child_flags
= flags
;
764 static const BdrvChildRole child_backing
= {
765 .inherit_options
= bdrv_backing_options
,
768 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
770 int open_flags
= flags
| BDRV_O_CACHE_WB
;
773 * Clear flags that are internal to the block layer before opening the
776 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
779 * Snapshots should be writable.
781 if (flags
& BDRV_O_TEMPORARY
) {
782 open_flags
|= BDRV_O_RDWR
;
788 static void update_flags_from_options(int *flags
, QemuOpts
*opts
)
790 *flags
&= ~BDRV_O_CACHE_MASK
;
792 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_WB
));
793 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_WB
, false)) {
794 *flags
|= BDRV_O_CACHE_WB
;
797 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_NO_FLUSH
));
798 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_NO_FLUSH
, false)) {
799 *flags
|= BDRV_O_NO_FLUSH
;
802 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_DIRECT
));
803 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_DIRECT
, false)) {
804 *flags
|= BDRV_O_NOCACHE
;
808 static void update_options_from_flags(QDict
*options
, int flags
)
810 if (!qdict_haskey(options
, BDRV_OPT_CACHE_WB
)) {
811 qdict_put(options
, BDRV_OPT_CACHE_WB
,
812 qbool_from_bool(flags
& BDRV_O_CACHE_WB
));
814 if (!qdict_haskey(options
, BDRV_OPT_CACHE_DIRECT
)) {
815 qdict_put(options
, BDRV_OPT_CACHE_DIRECT
,
816 qbool_from_bool(flags
& BDRV_O_NOCACHE
));
818 if (!qdict_haskey(options
, BDRV_OPT_CACHE_NO_FLUSH
)) {
819 qdict_put(options
, BDRV_OPT_CACHE_NO_FLUSH
,
820 qbool_from_bool(flags
& BDRV_O_NO_FLUSH
));
824 static void bdrv_assign_node_name(BlockDriverState
*bs
,
825 const char *node_name
,
828 char *gen_node_name
= NULL
;
831 node_name
= gen_node_name
= id_generate(ID_BLOCK
);
832 } else if (!id_wellformed(node_name
)) {
834 * Check for empty string or invalid characters, but not if it is
835 * generated (generated names use characters not available to the user)
837 error_setg(errp
, "Invalid node name");
841 /* takes care of avoiding namespaces collisions */
842 if (blk_by_name(node_name
)) {
843 error_setg(errp
, "node-name=%s is conflicting with a device id",
848 /* takes care of avoiding duplicates node names */
849 if (bdrv_find_node(node_name
)) {
850 error_setg(errp
, "Duplicate node name");
854 /* copy node name into the bs and insert it into the graph list */
855 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
856 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
858 g_free(gen_node_name
);
861 static QemuOptsList bdrv_runtime_opts
= {
862 .name
= "bdrv_common",
863 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
867 .type
= QEMU_OPT_STRING
,
868 .help
= "Node name of the block device node",
872 .type
= QEMU_OPT_STRING
,
873 .help
= "Block driver to use for the node",
876 .name
= BDRV_OPT_CACHE_WB
,
877 .type
= QEMU_OPT_BOOL
,
878 .help
= "Enable writeback mode",
881 .name
= BDRV_OPT_CACHE_DIRECT
,
882 .type
= QEMU_OPT_BOOL
,
883 .help
= "Bypass software writeback cache on the host",
886 .name
= BDRV_OPT_CACHE_NO_FLUSH
,
887 .type
= QEMU_OPT_BOOL
,
888 .help
= "Ignore flush requests",
890 { /* end of list */ }
895 * Common part for opening disk images and files
897 * Removes all processed options from *options.
899 static int bdrv_open_common(BlockDriverState
*bs
, BdrvChild
*file
,
900 QDict
*options
, Error
**errp
)
903 const char *filename
;
904 const char *driver_name
= NULL
;
905 const char *node_name
= NULL
;
908 Error
*local_err
= NULL
;
910 assert(bs
->file
== NULL
);
911 assert(options
!= NULL
&& bs
->options
!= options
);
913 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
914 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
916 error_propagate(errp
, local_err
);
921 driver_name
= qemu_opt_get(opts
, "driver");
922 drv
= bdrv_find_format(driver_name
);
926 filename
= file
->bs
->filename
;
928 filename
= qdict_get_try_str(options
, "filename");
931 if (drv
->bdrv_needs_filename
&& !filename
) {
932 error_setg(errp
, "The '%s' block driver requires a file name",
938 trace_bdrv_open_common(bs
, filename
?: "", bs
->open_flags
,
941 node_name
= qemu_opt_get(opts
, "node-name");
942 bdrv_assign_node_name(bs
, node_name
, &local_err
);
944 error_propagate(errp
, local_err
);
949 bs
->request_alignment
= 512;
950 bs
->zero_beyond_eof
= true;
951 bs
->read_only
= !(bs
->open_flags
& BDRV_O_RDWR
);
953 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
955 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
956 ? "Driver '%s' can only be used for read-only devices"
957 : "Driver '%s' is not whitelisted",
963 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
964 if (bs
->open_flags
& BDRV_O_COPY_ON_READ
) {
965 if (!bs
->read_only
) {
966 bdrv_enable_copy_on_read(bs
);
968 error_setg(errp
, "Can't use copy-on-read on read-only device");
974 if (filename
!= NULL
) {
975 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
977 bs
->filename
[0] = '\0';
979 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
982 bs
->opaque
= g_malloc0(drv
->instance_size
);
984 /* Apply cache mode options */
985 update_flags_from_options(&bs
->open_flags
, opts
);
987 if (!bs
->blk
&& (bs
->open_flags
& BDRV_O_CACHE_WB
) == 0) {
988 error_setg(errp
, "Can't set writethrough mode except for the root");
993 bdrv_set_enable_write_cache(bs
, bs
->open_flags
& BDRV_O_CACHE_WB
);
995 /* Open the image, either directly or using a protocol */
996 open_flags
= bdrv_open_flags(bs
, bs
->open_flags
);
997 if (drv
->bdrv_file_open
) {
998 assert(file
== NULL
);
999 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
1000 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
1003 error_setg(errp
, "Can't use '%s' as a block driver for the "
1004 "protocol level", drv
->format_name
);
1009 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1014 error_propagate(errp
, local_err
);
1015 } else if (bs
->filename
[0]) {
1016 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1018 error_setg_errno(errp
, -ret
, "Could not open image");
1023 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1025 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1029 bdrv_refresh_limits(bs
, &local_err
);
1031 error_propagate(errp
, local_err
);
1036 assert(bdrv_opt_mem_align(bs
) != 0);
1037 assert(bdrv_min_mem_align(bs
) != 0);
1038 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
1040 qemu_opts_del(opts
);
1049 qemu_opts_del(opts
);
1053 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1055 QObject
*options_obj
;
1059 ret
= strstart(filename
, "json:", &filename
);
1062 options_obj
= qobject_from_json(filename
);
1064 error_setg(errp
, "Could not parse the JSON options");
1068 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1069 qobject_decref(options_obj
);
1070 error_setg(errp
, "Invalid JSON object given");
1074 options
= qobject_to_qdict(options_obj
);
1075 qdict_flatten(options
);
1080 static void parse_json_protocol(QDict
*options
, const char **pfilename
,
1083 QDict
*json_options
;
1084 Error
*local_err
= NULL
;
1086 /* Parse json: pseudo-protocol */
1087 if (!*pfilename
|| !g_str_has_prefix(*pfilename
, "json:")) {
1091 json_options
= parse_json_filename(*pfilename
, &local_err
);
1093 error_propagate(errp
, local_err
);
1097 /* Options given in the filename have lower priority than options
1098 * specified directly */
1099 qdict_join(options
, json_options
, false);
1100 QDECREF(json_options
);
1105 * Fills in default options for opening images and converts the legacy
1106 * filename/flags pair to option QDict entries.
1107 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1108 * block driver has been specified explicitly.
1110 static int bdrv_fill_options(QDict
**options
, const char *filename
,
1111 int *flags
, Error
**errp
)
1113 const char *drvname
;
1114 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1115 bool parse_filename
= false;
1116 BlockDriver
*drv
= NULL
;
1117 Error
*local_err
= NULL
;
1119 drvname
= qdict_get_try_str(*options
, "driver");
1121 drv
= bdrv_find_format(drvname
);
1123 error_setg(errp
, "Unknown driver '%s'", drvname
);
1126 /* If the user has explicitly specified the driver, this choice should
1127 * override the BDRV_O_PROTOCOL flag */
1128 protocol
= drv
->bdrv_file_open
;
1132 *flags
|= BDRV_O_PROTOCOL
;
1134 *flags
&= ~BDRV_O_PROTOCOL
;
1137 /* Translate cache options from flags into options */
1138 update_options_from_flags(*options
, *flags
);
1140 /* Fetch the file name from the options QDict if necessary */
1141 if (protocol
&& filename
) {
1142 if (!qdict_haskey(*options
, "filename")) {
1143 qdict_put(*options
, "filename", qstring_from_str(filename
));
1144 parse_filename
= true;
1146 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1152 /* Find the right block driver */
1153 filename
= qdict_get_try_str(*options
, "filename");
1155 if (!drvname
&& protocol
) {
1157 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1162 drvname
= drv
->format_name
;
1163 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1165 error_setg(errp
, "Must specify either driver or file");
1170 assert(drv
|| !protocol
);
1172 /* Driver-specific filename parsing */
1173 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1174 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1176 error_propagate(errp
, local_err
);
1180 if (!drv
->bdrv_needs_filename
) {
1181 qdict_del(*options
, "filename");
1188 BdrvChild
*bdrv_root_attach_child(BlockDriverState
*child_bs
,
1189 const char *child_name
,
1190 const BdrvChildRole
*child_role
)
1192 BdrvChild
*child
= g_new(BdrvChild
, 1);
1193 *child
= (BdrvChild
) {
1195 .name
= g_strdup(child_name
),
1199 QLIST_INSERT_HEAD(&child_bs
->parents
, child
, next_parent
);
1204 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1205 BlockDriverState
*child_bs
,
1206 const char *child_name
,
1207 const BdrvChildRole
*child_role
)
1209 BdrvChild
*child
= bdrv_root_attach_child(child_bs
, child_name
, child_role
);
1210 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1214 static void bdrv_detach_child(BdrvChild
*child
)
1216 if (child
->next
.le_prev
) {
1217 QLIST_REMOVE(child
, next
);
1218 child
->next
.le_prev
= NULL
;
1220 QLIST_REMOVE(child
, next_parent
);
1221 g_free(child
->name
);
1225 void bdrv_root_unref_child(BdrvChild
*child
)
1227 BlockDriverState
*child_bs
;
1229 child_bs
= child
->bs
;
1230 bdrv_detach_child(child
);
1231 bdrv_unref(child_bs
);
1234 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1236 if (child
== NULL
) {
1240 if (child
->bs
->inherits_from
== parent
) {
1241 child
->bs
->inherits_from
= NULL
;
1244 bdrv_root_unref_child(child
);
1248 * Sets the backing file link of a BDS. A new reference is created; callers
1249 * which don't need their own reference any more must call bdrv_unref().
1251 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1254 bdrv_ref(backing_hd
);
1258 assert(bs
->backing_blocker
);
1259 bdrv_op_unblock_all(bs
->backing
->bs
, bs
->backing_blocker
);
1260 bdrv_unref_child(bs
, bs
->backing
);
1261 } else if (backing_hd
) {
1262 error_setg(&bs
->backing_blocker
,
1263 "node is used as backing hd of '%s'",
1264 bdrv_get_device_or_node_name(bs
));
1268 error_free(bs
->backing_blocker
);
1269 bs
->backing_blocker
= NULL
;
1273 bs
->backing
= bdrv_attach_child(bs
, backing_hd
, "backing", &child_backing
);
1274 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1275 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1276 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1277 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1279 bdrv_op_block_all(backing_hd
, bs
->backing_blocker
);
1280 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1281 bdrv_op_unblock(backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1282 bs
->backing_blocker
);
1284 bdrv_refresh_limits(bs
, NULL
);
1288 * Opens the backing file for a BlockDriverState if not yet open
1290 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1291 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1292 * itself, all options starting with "${bdref_key}." are considered part of the
1295 * TODO Can this be unified with bdrv_open_image()?
1297 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*parent_options
,
1298 const char *bdref_key
, Error
**errp
)
1300 char *backing_filename
= g_malloc0(PATH_MAX
);
1301 char *bdref_key_dot
;
1302 const char *reference
= NULL
;
1304 BlockDriverState
*backing_hd
;
1306 QDict
*tmp_parent_options
= NULL
;
1307 Error
*local_err
= NULL
;
1309 if (bs
->backing
!= NULL
) {
1313 /* NULL means an empty set of options */
1314 if (parent_options
== NULL
) {
1315 tmp_parent_options
= qdict_new();
1316 parent_options
= tmp_parent_options
;
1319 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1321 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1322 qdict_extract_subqdict(parent_options
, &options
, bdref_key_dot
);
1323 g_free(bdref_key_dot
);
1325 reference
= qdict_get_try_str(parent_options
, bdref_key
);
1326 if (reference
|| qdict_haskey(options
, "file.filename")) {
1327 backing_filename
[0] = '\0';
1328 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1332 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1336 error_propagate(errp
, local_err
);
1342 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1344 error_setg(errp
, "Driver doesn't support backing files");
1349 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1350 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1354 ret
= bdrv_open_inherit(&backing_hd
,
1355 *backing_filename
? backing_filename
: NULL
,
1356 reference
, options
, 0, bs
, &child_backing
,
1359 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1360 error_prepend(errp
, "Could not open backing file: ");
1364 /* Hook up the backing file link; drop our reference, bs owns the
1365 * backing_hd reference now */
1366 bdrv_set_backing_hd(bs
, backing_hd
);
1367 bdrv_unref(backing_hd
);
1369 qdict_del(parent_options
, bdref_key
);
1372 g_free(backing_filename
);
1373 QDECREF(tmp_parent_options
);
1378 * Opens a disk image whose options are given as BlockdevRef in another block
1381 * If allow_none is true, no image will be opened if filename is false and no
1382 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1384 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1385 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1386 * itself, all options starting with "${bdref_key}." are considered part of the
1389 * The BlockdevRef will be removed from the options QDict.
1391 BdrvChild
*bdrv_open_child(const char *filename
,
1392 QDict
*options
, const char *bdref_key
,
1393 BlockDriverState
* parent
,
1394 const BdrvChildRole
*child_role
,
1395 bool allow_none
, Error
**errp
)
1397 BdrvChild
*c
= NULL
;
1398 BlockDriverState
*bs
;
1399 QDict
*image_options
;
1401 char *bdref_key_dot
;
1402 const char *reference
;
1404 assert(child_role
!= NULL
);
1406 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1407 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1408 g_free(bdref_key_dot
);
1410 reference
= qdict_get_try_str(options
, bdref_key
);
1411 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1413 error_setg(errp
, "A block device must be specified for \"%s\"",
1416 QDECREF(image_options
);
1421 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1422 parent
, child_role
, errp
);
1427 c
= bdrv_attach_child(parent
, bs
, bdref_key
, child_role
);
1430 qdict_del(options
, bdref_key
);
1434 static int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
,
1435 QDict
*snapshot_options
, Error
**errp
)
1437 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1438 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1440 QemuOpts
*opts
= NULL
;
1441 BlockDriverState
*bs_snapshot
;
1442 Error
*local_err
= NULL
;
1445 /* if snapshot, we create a temporary backing file and open it
1446 instead of opening 'filename' directly */
1448 /* Get the required size from the image */
1449 total_size
= bdrv_getlength(bs
);
1450 if (total_size
< 0) {
1452 error_setg_errno(errp
, -total_size
, "Could not get image size");
1456 /* Create the temporary image */
1457 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1459 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1463 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1465 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1466 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, errp
);
1467 qemu_opts_del(opts
);
1469 error_prepend(errp
, "Could not create temporary overlay '%s': ",
1474 /* Prepare options QDict for the temporary file */
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
,
1486 snapshot_options
= NULL
;
1488 error_propagate(errp
, local_err
);
1492 bdrv_append(bs_snapshot
, bs
);
1495 QDECREF(snapshot_options
);
1496 g_free(tmp_filename
);
1501 * Opens a disk image (raw, qcow2, vmdk, ...)
1503 * options is a QDict of options to pass to the block drivers, or NULL for an
1504 * empty set of options. The reference to the QDict belongs to the block layer
1505 * after the call (even on failure), so if the caller intends to reuse the
1506 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1508 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1509 * If it is not NULL, the referenced BDS will be reused.
1511 * The reference parameter may be used to specify an existing block device which
1512 * should be opened. If specified, neither options nor a filename may be given,
1513 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1515 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1516 const char *reference
, QDict
*options
, int flags
,
1517 BlockDriverState
*parent
,
1518 const BdrvChildRole
*child_role
, Error
**errp
)
1521 BdrvChild
*file
= NULL
;
1522 BlockDriverState
*bs
;
1523 BlockDriver
*drv
= NULL
;
1524 const char *drvname
;
1525 const char *backing
;
1526 Error
*local_err
= NULL
;
1527 QDict
*snapshot_options
= NULL
;
1528 int snapshot_flags
= 0;
1531 assert(!child_role
|| !flags
);
1532 assert(!child_role
== !parent
);
1535 bool options_non_empty
= options
? qdict_size(options
) : false;
1539 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1540 "another block device");
1544 if (filename
|| options_non_empty
) {
1545 error_setg(errp
, "Cannot reference an existing block device with "
1546 "additional options or a new filename");
1550 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1565 /* NULL means an empty set of options */
1566 if (options
== NULL
) {
1567 options
= qdict_new();
1570 /* json: syntax counts as explicit options, as if in the QDict */
1571 parse_json_protocol(options
, &filename
, &local_err
);
1577 bs
->explicit_options
= qdict_clone_shallow(options
);
1580 bs
->inherits_from
= parent
;
1581 child_role
->inherit_options(&flags
, options
,
1582 parent
->open_flags
, parent
->options
);
1585 ret
= bdrv_fill_options(&options
, filename
, &flags
, &local_err
);
1590 bs
->open_flags
= flags
;
1591 bs
->options
= options
;
1592 options
= qdict_clone_shallow(options
);
1594 /* Find the right image format driver */
1595 drvname
= qdict_get_try_str(options
, "driver");
1597 drv
= bdrv_find_format(drvname
);
1599 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1605 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1607 backing
= qdict_get_try_str(options
, "backing");
1608 if (backing
&& *backing
== '\0') {
1609 flags
|= BDRV_O_NO_BACKING
;
1610 qdict_del(options
, "backing");
1613 /* Open image file without format layer */
1614 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1615 if (flags
& BDRV_O_RDWR
) {
1616 flags
|= BDRV_O_ALLOW_RDWR
;
1618 if (flags
& BDRV_O_SNAPSHOT
) {
1619 snapshot_options
= qdict_new();
1620 bdrv_temp_snapshot_options(&snapshot_flags
, snapshot_options
,
1622 bdrv_backing_options(&flags
, options
, flags
, options
);
1625 bs
->open_flags
= flags
;
1627 file
= bdrv_open_child(filename
, options
, "file", bs
,
1628 &child_file
, true, &local_err
);
1635 /* Image format probing */
1638 ret
= find_image_format(file
->bs
, filename
, &drv
, &local_err
);
1643 * This option update would logically belong in bdrv_fill_options(),
1644 * but we first need to open bs->file for the probing to work, while
1645 * opening bs->file already requires the (mostly) final set of options
1646 * so that cache mode etc. can be inherited.
1648 * Adding the driver later is somewhat ugly, but it's not an option
1649 * that would ever be inherited, so it's correct. We just need to make
1650 * sure to update both bs->options (which has the full effective
1651 * options for bs) and options (which has file.* already removed).
1653 qdict_put(bs
->options
, "driver", qstring_from_str(drv
->format_name
));
1654 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1656 error_setg(errp
, "Must specify either driver or file");
1661 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1662 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1663 /* file must be NULL if a protocol BDS is about to be created
1664 * (the inverse results in an error message from bdrv_open_common()) */
1665 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1667 /* Open the image */
1668 ret
= bdrv_open_common(bs
, file
, options
, &local_err
);
1673 if (file
&& (bs
->file
!= file
)) {
1674 bdrv_unref_child(bs
, file
);
1678 /* If there is a backing file, use it */
1679 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1680 ret
= bdrv_open_backing_file(bs
, options
, "backing", &local_err
);
1682 goto close_and_fail
;
1686 bdrv_refresh_filename(bs
);
1688 /* Check if any unknown options were used */
1689 if (options
&& (qdict_size(options
) != 0)) {
1690 const QDictEntry
*entry
= qdict_first(options
);
1691 if (flags
& BDRV_O_PROTOCOL
) {
1692 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1693 "'%s'", drv
->format_name
, entry
->key
);
1696 "Block format '%s' does not support the option '%s'",
1697 drv
->format_name
, entry
->key
);
1701 goto close_and_fail
;
1704 if (!bdrv_key_required(bs
)) {
1706 blk_dev_change_media_cb(bs
->blk
, true);
1708 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1709 && !runstate_check(RUN_STATE_INMIGRATE
)
1710 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1712 "Guest must be stopped for opening of encrypted image");
1714 goto close_and_fail
;
1720 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1721 * temporary snapshot afterwards. */
1722 if (snapshot_flags
) {
1723 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, snapshot_options
,
1725 snapshot_options
= NULL
;
1727 goto close_and_fail
;
1735 bdrv_unref_child(bs
, file
);
1737 QDECREF(snapshot_options
);
1738 QDECREF(bs
->explicit_options
);
1739 QDECREF(bs
->options
);
1743 /* If *pbs is NULL, a new BDS has been created in this function and
1744 needs to be freed now. Otherwise, it does not need to be closed,
1745 since it has not really been opened yet. */
1749 error_propagate(errp
, local_err
);
1754 /* See fail path, but now the BDS has to be always closed */
1760 QDECREF(snapshot_options
);
1763 error_propagate(errp
, local_err
);
1768 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1769 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1771 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1775 typedef struct BlockReopenQueueEntry
{
1777 BDRVReopenState state
;
1778 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1779 } BlockReopenQueueEntry
;
1782 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1783 * reopen of multiple devices.
1785 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1786 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1787 * be created and initialized. This newly created BlockReopenQueue should be
1788 * passed back in for subsequent calls that are intended to be of the same
1791 * bs is the BlockDriverState to add to the reopen queue.
1793 * options contains the changed options for the associated bs
1794 * (the BlockReopenQueue takes ownership)
1796 * flags contains the open flags for the associated bs
1798 * returns a pointer to bs_queue, which is either the newly allocated
1799 * bs_queue, or the existing bs_queue being used.
1802 static BlockReopenQueue
*bdrv_reopen_queue_child(BlockReopenQueue
*bs_queue
,
1803 BlockDriverState
*bs
,
1806 const BdrvChildRole
*role
,
1807 QDict
*parent_options
,
1812 BlockReopenQueueEntry
*bs_entry
;
1814 QDict
*old_options
, *explicit_options
;
1816 if (bs_queue
== NULL
) {
1817 bs_queue
= g_new0(BlockReopenQueue
, 1);
1818 QSIMPLEQ_INIT(bs_queue
);
1822 options
= qdict_new();
1826 * Precedence of options:
1827 * 1. Explicitly passed in options (highest)
1828 * 2. Set in flags (only for top level)
1829 * 3. Retained from explicitly set options of bs
1830 * 4. Inherited from parent node
1831 * 5. Retained from effective options of bs
1834 if (!parent_options
) {
1836 * Any setting represented by flags is always updated. If the
1837 * corresponding QDict option is set, it takes precedence. Otherwise
1838 * the flag is translated into a QDict option. The old setting of bs is
1841 update_options_from_flags(options
, flags
);
1844 /* Old explicitly set values (don't overwrite by inherited value) */
1845 old_options
= qdict_clone_shallow(bs
->explicit_options
);
1846 bdrv_join_options(bs
, options
, old_options
);
1847 QDECREF(old_options
);
1849 explicit_options
= qdict_clone_shallow(options
);
1851 /* Inherit from parent node */
1852 if (parent_options
) {
1854 role
->inherit_options(&flags
, options
, parent_flags
, parent_options
);
1857 /* Old values are used for options that aren't set yet */
1858 old_options
= qdict_clone_shallow(bs
->options
);
1859 bdrv_join_options(bs
, options
, old_options
);
1860 QDECREF(old_options
);
1862 /* bdrv_open() masks this flag out */
1863 flags
&= ~BDRV_O_PROTOCOL
;
1865 QLIST_FOREACH(child
, &bs
->children
, next
) {
1866 QDict
*new_child_options
;
1867 char *child_key_dot
;
1869 /* reopen can only change the options of block devices that were
1870 * implicitly created and inherited options. For other (referenced)
1871 * block devices, a syntax like "backing.foo" results in an error. */
1872 if (child
->bs
->inherits_from
!= bs
) {
1876 child_key_dot
= g_strdup_printf("%s.", child
->name
);
1877 qdict_extract_subqdict(options
, &new_child_options
, child_key_dot
);
1878 g_free(child_key_dot
);
1880 bdrv_reopen_queue_child(bs_queue
, child
->bs
, new_child_options
, 0,
1881 child
->role
, options
, flags
);
1884 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1885 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1887 bs_entry
->state
.bs
= bs
;
1888 bs_entry
->state
.options
= options
;
1889 bs_entry
->state
.explicit_options
= explicit_options
;
1890 bs_entry
->state
.flags
= flags
;
1895 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1896 BlockDriverState
*bs
,
1897 QDict
*options
, int flags
)
1899 return bdrv_reopen_queue_child(bs_queue
, bs
, options
, flags
,
1904 * Reopen multiple BlockDriverStates atomically & transactionally.
1906 * The queue passed in (bs_queue) must have been built up previous
1907 * via bdrv_reopen_queue().
1909 * Reopens all BDS specified in the queue, with the appropriate
1910 * flags. All devices are prepared for reopen, and failure of any
1911 * device will cause all device changes to be abandonded, and intermediate
1914 * If all devices prepare successfully, then the changes are committed
1918 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1921 BlockReopenQueueEntry
*bs_entry
, *next
;
1922 Error
*local_err
= NULL
;
1924 assert(bs_queue
!= NULL
);
1928 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1929 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1930 error_propagate(errp
, local_err
);
1933 bs_entry
->prepared
= true;
1936 /* If we reach this point, we have success and just need to apply the
1939 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1940 bdrv_reopen_commit(&bs_entry
->state
);
1946 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1947 if (ret
&& bs_entry
->prepared
) {
1948 bdrv_reopen_abort(&bs_entry
->state
);
1950 QDECREF(bs_entry
->state
.explicit_options
);
1952 QDECREF(bs_entry
->state
.options
);
1960 /* Reopen a single BlockDriverState with the specified flags. */
1961 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1964 Error
*local_err
= NULL
;
1965 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, NULL
, bdrv_flags
);
1967 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1968 if (local_err
!= NULL
) {
1969 error_propagate(errp
, local_err
);
1976 * Prepares a BlockDriverState for reopen. All changes are staged in the
1977 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1978 * the block driver layer .bdrv_reopen_prepare()
1980 * bs is the BlockDriverState to reopen
1981 * flags are the new open flags
1982 * queue is the reopen queue
1984 * Returns 0 on success, non-zero on error. On error errp will be set
1987 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1988 * It is the responsibility of the caller to then call the abort() or
1989 * commit() for any other BDS that have been left in a prepare() state
1992 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1996 Error
*local_err
= NULL
;
2001 assert(reopen_state
!= NULL
);
2002 assert(reopen_state
->bs
->drv
!= NULL
);
2003 drv
= reopen_state
->bs
->drv
;
2005 /* Process generic block layer options */
2006 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
2007 qemu_opts_absorb_qdict(opts
, reopen_state
->options
, &local_err
);
2009 error_propagate(errp
, local_err
);
2014 update_flags_from_options(&reopen_state
->flags
, opts
);
2016 /* WCE is a BlockBackend level option, can't change it */
2017 bool old_wce
= bdrv_enable_write_cache(reopen_state
->bs
);
2018 bool new_wce
= (reopen_state
->flags
& BDRV_O_CACHE_WB
);
2020 if (old_wce
!= new_wce
) {
2021 error_setg(errp
, "Cannot change cache.writeback");
2026 /* node-name and driver must be unchanged. Put them back into the QDict, so
2027 * that they are checked at the end of this function. */
2028 value
= qemu_opt_get(opts
, "node-name");
2030 qdict_put(reopen_state
->options
, "node-name", qstring_from_str(value
));
2033 value
= qemu_opt_get(opts
, "driver");
2035 qdict_put(reopen_state
->options
, "driver", qstring_from_str(value
));
2038 /* if we are to stay read-only, do not allow permission change
2040 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
2041 reopen_state
->flags
& BDRV_O_RDWR
) {
2042 error_setg(errp
, "Node '%s' is read only",
2043 bdrv_get_device_or_node_name(reopen_state
->bs
));
2048 ret
= bdrv_flush(reopen_state
->bs
);
2050 error_setg_errno(errp
, -ret
, "Error flushing drive");
2054 if (drv
->bdrv_reopen_prepare
) {
2055 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
2057 if (local_err
!= NULL
) {
2058 error_propagate(errp
, local_err
);
2060 error_setg(errp
, "failed while preparing to reopen image '%s'",
2061 reopen_state
->bs
->filename
);
2066 /* It is currently mandatory to have a bdrv_reopen_prepare()
2067 * handler for each supported drv. */
2068 error_setg(errp
, "Block format '%s' used by node '%s' "
2069 "does not support reopening files", drv
->format_name
,
2070 bdrv_get_device_or_node_name(reopen_state
->bs
));
2075 /* Options that are not handled are only okay if they are unchanged
2076 * compared to the old state. It is expected that some options are only
2077 * used for the initial open, but not reopen (e.g. filename) */
2078 if (qdict_size(reopen_state
->options
)) {
2079 const QDictEntry
*entry
= qdict_first(reopen_state
->options
);
2082 QString
*new_obj
= qobject_to_qstring(entry
->value
);
2083 const char *new = qstring_get_str(new_obj
);
2084 const char *old
= qdict_get_try_str(reopen_state
->bs
->options
,
2087 if (!old
|| strcmp(new, old
)) {
2088 error_setg(errp
, "Cannot change the option '%s'", entry
->key
);
2092 } while ((entry
= qdict_next(reopen_state
->options
, entry
)));
2098 qemu_opts_del(opts
);
2103 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2104 * makes them final by swapping the staging BlockDriverState contents into
2105 * the active BlockDriverState contents.
2107 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
2111 assert(reopen_state
!= NULL
);
2112 drv
= reopen_state
->bs
->drv
;
2113 assert(drv
!= NULL
);
2115 /* If there are any driver level actions to take */
2116 if (drv
->bdrv_reopen_commit
) {
2117 drv
->bdrv_reopen_commit(reopen_state
);
2120 /* set BDS specific flags now */
2121 QDECREF(reopen_state
->bs
->explicit_options
);
2123 reopen_state
->bs
->explicit_options
= reopen_state
->explicit_options
;
2124 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
2125 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
2127 bdrv_set_enable_write_cache(reopen_state
->bs
,
2128 !!(reopen_state
->flags
& BDRV_O_CACHE_WB
));
2129 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
2133 * Abort the reopen, and delete and free the staged changes in
2136 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
2140 assert(reopen_state
!= NULL
);
2141 drv
= reopen_state
->bs
->drv
;
2142 assert(drv
!= NULL
);
2144 if (drv
->bdrv_reopen_abort
) {
2145 drv
->bdrv_reopen_abort(reopen_state
);
2148 QDECREF(reopen_state
->explicit_options
);
2152 static void bdrv_close(BlockDriverState
*bs
)
2154 BdrvAioNotifier
*ban
, *ban_next
;
2158 /* Disable I/O limits and drain all pending throttled requests */
2159 if (bs
->throttle_state
) {
2160 bdrv_io_limits_disable(bs
);
2163 bdrv_drained_begin(bs
); /* complete I/O */
2165 bdrv_drain(bs
); /* in case flush left pending I/O */
2167 bdrv_release_named_dirty_bitmaps(bs
);
2168 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2171 blk_dev_change_media_cb(bs
->blk
, false);
2175 BdrvChild
*child
, *next
;
2177 bs
->drv
->bdrv_close(bs
);
2180 bdrv_set_backing_hd(bs
, NULL
);
2182 if (bs
->file
!= NULL
) {
2183 bdrv_unref_child(bs
, bs
->file
);
2187 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
2188 /* TODO Remove bdrv_unref() from drivers' close function and use
2189 * bdrv_unref_child() here */
2190 if (child
->bs
->inherits_from
== bs
) {
2191 child
->bs
->inherits_from
= NULL
;
2193 bdrv_detach_child(child
);
2198 bs
->copy_on_read
= 0;
2199 bs
->backing_file
[0] = '\0';
2200 bs
->backing_format
[0] = '\0';
2201 bs
->total_sectors
= 0;
2205 bs
->zero_beyond_eof
= false;
2206 QDECREF(bs
->options
);
2207 QDECREF(bs
->explicit_options
);
2209 QDECREF(bs
->full_open_options
);
2210 bs
->full_open_options
= NULL
;
2213 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
2216 QLIST_INIT(&bs
->aio_notifiers
);
2217 bdrv_drained_end(bs
);
2220 void bdrv_close_all(void)
2222 BlockDriverState
*bs
;
2223 AioContext
*aio_context
;
2225 /* Drop references from requests still in flight, such as canceled block
2226 * jobs whose AIO context has not been polled yet */
2229 blk_remove_all_bs();
2230 blockdev_close_all_bdrv_states();
2232 /* Cancel all block jobs */
2233 while (!QTAILQ_EMPTY(&all_bdrv_states
)) {
2234 QTAILQ_FOREACH(bs
, &all_bdrv_states
, bs_list
) {
2235 aio_context
= bdrv_get_aio_context(bs
);
2237 aio_context_acquire(aio_context
);
2239 block_job_cancel_sync(bs
->job
);
2240 aio_context_release(aio_context
);
2243 aio_context_release(aio_context
);
2246 /* All the remaining BlockDriverStates are referenced directly or
2247 * indirectly from block jobs, so there needs to be at least one BDS
2248 * directly used by a block job */
2253 /* Fields that need to stay with the top-level BDS */
2254 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2255 BlockDriverState
*bs_src
)
2257 /* move some fields that need to stay attached to the device */
2260 static void change_parent_backing_link(BlockDriverState
*from
,
2261 BlockDriverState
*to
)
2263 BdrvChild
*c
, *next
;
2266 /* FIXME We bypass blk_set_bs(), so we need to make these updates
2267 * manually. The root problem is not in this change function, but the
2268 * existence of BlockDriverState.blk. */
2269 to
->blk
= from
->blk
;
2273 QLIST_FOREACH_SAFE(c
, &from
->parents
, next_parent
, next
) {
2274 assert(c
->role
!= &child_backing
);
2276 QLIST_REMOVE(c
, next_parent
);
2277 QLIST_INSERT_HEAD(&to
->parents
, c
, next_parent
);
2283 static void swap_feature_fields(BlockDriverState
*bs_top
,
2284 BlockDriverState
*bs_new
)
2286 BlockDriverState tmp
;
2288 bdrv_move_feature_fields(&tmp
, bs_top
);
2289 bdrv_move_feature_fields(bs_top
, bs_new
);
2290 bdrv_move_feature_fields(bs_new
, &tmp
);
2292 assert(!bs_new
->throttle_state
);
2293 if (bs_top
->throttle_state
) {
2294 assert(bs_top
->io_limits_enabled
);
2295 bdrv_io_limits_enable(bs_new
, throttle_group_get_name(bs_top
));
2296 bdrv_io_limits_disable(bs_top
);
2301 * Add new bs contents at the top of an image chain while the chain is
2302 * live, while keeping required fields on the top layer.
2304 * This will modify the BlockDriverState fields, and swap contents
2305 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2307 * bs_new must not be attached to a BlockBackend.
2309 * This function does not create any image files.
2311 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2312 * that's what the callers commonly need. bs_new will be referenced by the old
2313 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2314 * reference of its own, it must call bdrv_ref().
2316 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2318 assert(!bdrv_requests_pending(bs_top
));
2319 assert(!bdrv_requests_pending(bs_new
));
2322 change_parent_backing_link(bs_top
, bs_new
);
2324 /* Some fields always stay on top of the backing file chain */
2325 swap_feature_fields(bs_top
, bs_new
);
2327 bdrv_set_backing_hd(bs_new
, bs_top
);
2330 /* bs_new is now referenced by its new parents, we don't need the
2331 * additional reference any more. */
2335 void bdrv_replace_in_backing_chain(BlockDriverState
*old
, BlockDriverState
*new)
2337 assert(!bdrv_requests_pending(old
));
2338 assert(!bdrv_requests_pending(new));
2343 /* As long as these fields aren't in BlockBackend, but in the top-level
2344 * BlockDriverState, it's not possible for a BDS to have two BBs.
2346 * We really want to copy the fields from old to new, but we go for a
2347 * swap instead so that pointers aren't duplicated and cause trouble.
2348 * (Also, bdrv_swap() used to do the same.) */
2350 swap_feature_fields(old
, new);
2352 change_parent_backing_link(old
, new);
2354 /* Change backing files if a previously independent node is added to the
2355 * chain. For active commit, we replace top by its own (indirect) backing
2356 * file and don't do anything here so we don't build a loop. */
2357 if (new->backing
== NULL
&& !bdrv_chain_contains(backing_bs(old
), new)) {
2358 bdrv_set_backing_hd(new, backing_bs(old
));
2359 bdrv_set_backing_hd(old
, NULL
);
2365 static void bdrv_delete(BlockDriverState
*bs
)
2368 assert(bdrv_op_blocker_is_empty(bs
));
2369 assert(!bs
->refcnt
);
2373 /* remove from list, if necessary */
2374 if (bs
->node_name
[0] != '\0') {
2375 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2377 QTAILQ_REMOVE(&all_bdrv_states
, bs
, bs_list
);
2383 * Run consistency checks on an image
2385 * Returns 0 if the check could be completed (it doesn't mean that the image is
2386 * free of errors) or -errno when an internal error occurred. The results of the
2387 * check are stored in res.
2389 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2391 if (bs
->drv
== NULL
) {
2394 if (bs
->drv
->bdrv_check
== NULL
) {
2398 memset(res
, 0, sizeof(*res
));
2399 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2402 #define COMMIT_BUF_SECTORS 2048
2404 /* commit COW file into the raw image */
2405 int bdrv_commit(BlockDriverState
*bs
)
2407 BlockDriver
*drv
= bs
->drv
;
2408 int64_t sector
, total_sectors
, length
, backing_length
;
2409 int n
, ro
, open_flags
;
2411 uint8_t *buf
= NULL
;
2420 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2421 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2425 ro
= bs
->backing
->bs
->read_only
;
2426 open_flags
= bs
->backing
->bs
->open_flags
;
2429 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2434 length
= bdrv_getlength(bs
);
2440 backing_length
= bdrv_getlength(bs
->backing
->bs
);
2441 if (backing_length
< 0) {
2442 ret
= backing_length
;
2446 /* If our top snapshot is larger than the backing file image,
2447 * grow the backing file image if possible. If not possible,
2448 * we must return an error */
2449 if (length
> backing_length
) {
2450 ret
= bdrv_truncate(bs
->backing
->bs
, length
);
2456 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2458 /* qemu_try_blockalign() for bs will choose an alignment that works for
2459 * bs->backing->bs as well, so no need to compare the alignment manually. */
2460 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2466 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2467 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2472 ret
= bdrv_read(bs
, sector
, buf
, n
);
2477 ret
= bdrv_write(bs
->backing
->bs
, sector
, buf
, n
);
2484 if (drv
->bdrv_make_empty
) {
2485 ret
= drv
->bdrv_make_empty(bs
);
2493 * Make sure all data we wrote to the backing device is actually
2497 bdrv_flush(bs
->backing
->bs
);
2505 /* ignoring error return here */
2506 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2515 * -EINVAL - backing format specified, but no file
2516 * -ENOSPC - can't update the backing file because no space is left in the
2518 * -ENOTSUP - format driver doesn't support changing the backing file
2520 int bdrv_change_backing_file(BlockDriverState
*bs
,
2521 const char *backing_file
, const char *backing_fmt
)
2523 BlockDriver
*drv
= bs
->drv
;
2526 /* Backing file format doesn't make sense without a backing file */
2527 if (backing_fmt
&& !backing_file
) {
2531 if (drv
->bdrv_change_backing_file
!= NULL
) {
2532 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2538 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2539 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2545 * Finds the image layer in the chain that has 'bs' as its backing file.
2547 * active is the current topmost image.
2549 * Returns NULL if bs is not found in active's image chain,
2550 * or if active == bs.
2552 * Returns the bottommost base image if bs == NULL.
2554 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2555 BlockDriverState
*bs
)
2557 while (active
&& bs
!= backing_bs(active
)) {
2558 active
= backing_bs(active
);
2564 /* Given a BDS, searches for the base layer. */
2565 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2567 return bdrv_find_overlay(bs
, NULL
);
2571 * Drops images above 'base' up to and including 'top', and sets the image
2572 * above 'top' to have base as its backing file.
2574 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2575 * information in 'bs' can be properly updated.
2577 * E.g., this will convert the following chain:
2578 * bottom <- base <- intermediate <- top <- active
2582 * bottom <- base <- active
2584 * It is allowed for bottom==base, in which case it converts:
2586 * base <- intermediate <- top <- active
2592 * If backing_file_str is non-NULL, it will be used when modifying top's
2593 * overlay image metadata.
2596 * if active == top, that is considered an error
2599 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2600 BlockDriverState
*base
, const char *backing_file_str
)
2602 BlockDriverState
*new_top_bs
= NULL
;
2605 if (!top
->drv
|| !base
->drv
) {
2609 new_top_bs
= bdrv_find_overlay(active
, top
);
2611 if (new_top_bs
== NULL
) {
2612 /* we could not find the image above 'top', this is an error */
2616 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2617 * to do, no intermediate images */
2618 if (backing_bs(new_top_bs
) == base
) {
2623 /* Make sure that base is in the backing chain of top */
2624 if (!bdrv_chain_contains(top
, base
)) {
2628 /* success - we can delete the intermediate states, and link top->base */
2629 backing_file_str
= backing_file_str
? backing_file_str
: base
->filename
;
2630 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2631 base
->drv
? base
->drv
->format_name
: "");
2635 bdrv_set_backing_hd(new_top_bs
, base
);
2643 * Truncate file to 'offset' bytes (needed only for file protocols)
2645 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2647 BlockDriver
*drv
= bs
->drv
;
2651 if (!drv
->bdrv_truncate
)
2656 ret
= drv
->bdrv_truncate(bs
, offset
);
2658 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2659 bdrv_dirty_bitmap_truncate(bs
);
2661 blk_dev_resize_cb(bs
->blk
);
2668 * Length of a allocated file in bytes. Sparse files are counted by actual
2669 * allocated space. Return < 0 if error or unknown.
2671 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2673 BlockDriver
*drv
= bs
->drv
;
2677 if (drv
->bdrv_get_allocated_file_size
) {
2678 return drv
->bdrv_get_allocated_file_size(bs
);
2681 return bdrv_get_allocated_file_size(bs
->file
->bs
);
2687 * Return number of sectors on success, -errno on error.
2689 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2691 BlockDriver
*drv
= bs
->drv
;
2696 if (drv
->has_variable_length
) {
2697 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2702 return bs
->total_sectors
;
2706 * Return length in bytes on success, -errno on error.
2707 * The length is always a multiple of BDRV_SECTOR_SIZE.
2709 int64_t bdrv_getlength(BlockDriverState
*bs
)
2711 int64_t ret
= bdrv_nb_sectors(bs
);
2713 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2714 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2717 /* return 0 as number of sectors if no device present or error */
2718 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2720 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2722 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2725 int bdrv_is_read_only(BlockDriverState
*bs
)
2727 return bs
->read_only
;
2730 int bdrv_is_sg(BlockDriverState
*bs
)
2735 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2738 return blk_enable_write_cache(bs
->blk
);
2744 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2747 blk_set_enable_write_cache(bs
->blk
, wce
);
2750 /* so a reopen() will preserve wce */
2752 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2754 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2758 int bdrv_is_encrypted(BlockDriverState
*bs
)
2760 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2763 return bs
->encrypted
;
2766 int bdrv_key_required(BlockDriverState
*bs
)
2768 BdrvChild
*backing
= bs
->backing
;
2770 if (backing
&& backing
->bs
->encrypted
&& !backing
->bs
->valid_key
) {
2773 return (bs
->encrypted
&& !bs
->valid_key
);
2776 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2779 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2780 ret
= bdrv_set_key(bs
->backing
->bs
, key
);
2786 if (!bs
->encrypted
) {
2788 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2791 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2794 } else if (!bs
->valid_key
) {
2797 /* call the change callback now, we skipped it on open */
2798 blk_dev_change_media_cb(bs
->blk
, true);
2805 * Provide an encryption key for @bs.
2806 * If @key is non-null:
2807 * If @bs is not encrypted, fail.
2808 * Else if the key is invalid, fail.
2809 * Else set @bs's key to @key, replacing the existing key, if any.
2811 * If @bs is encrypted and still lacks a key, fail.
2813 * On failure, store an error object through @errp if non-null.
2815 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2818 if (!bdrv_is_encrypted(bs
)) {
2819 error_setg(errp
, "Node '%s' is not encrypted",
2820 bdrv_get_device_or_node_name(bs
));
2821 } else if (bdrv_set_key(bs
, key
) < 0) {
2822 error_setg(errp
, QERR_INVALID_PASSWORD
);
2825 if (bdrv_key_required(bs
)) {
2826 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2827 "'%s' (%s) is encrypted",
2828 bdrv_get_device_or_node_name(bs
),
2829 bdrv_get_encrypted_filename(bs
));
2834 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2836 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2839 static int qsort_strcmp(const void *a
, const void *b
)
2841 return strcmp(a
, b
);
2844 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2850 const char **formats
= NULL
;
2852 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2853 if (drv
->format_name
) {
2856 while (formats
&& i
&& !found
) {
2857 found
= !strcmp(formats
[--i
], drv
->format_name
);
2861 formats
= g_renew(const char *, formats
, count
+ 1);
2862 formats
[count
++] = drv
->format_name
;
2867 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2869 for (i
= 0; i
< count
; i
++) {
2870 it(opaque
, formats
[i
]);
2876 /* This function is to find a node in the bs graph */
2877 BlockDriverState
*bdrv_find_node(const char *node_name
)
2879 BlockDriverState
*bs
;
2883 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2884 if (!strcmp(node_name
, bs
->node_name
)) {
2891 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2892 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2894 BlockDeviceInfoList
*list
, *entry
;
2895 BlockDriverState
*bs
;
2898 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2899 BlockDeviceInfo
*info
= bdrv_block_device_info(NULL
, bs
, errp
);
2901 qapi_free_BlockDeviceInfoList(list
);
2904 entry
= g_malloc0(sizeof(*entry
));
2905 entry
->value
= info
;
2913 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2914 const char *node_name
,
2918 BlockDriverState
*bs
;
2921 blk
= blk_by_name(device
);
2926 error_setg(errp
, "Device '%s' has no medium", device
);
2934 bs
= bdrv_find_node(node_name
);
2941 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2942 device
? device
: "",
2943 node_name
? node_name
: "");
2947 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2948 * return false. If either argument is NULL, return false. */
2949 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2951 while (top
&& top
!= base
) {
2952 top
= backing_bs(top
);
2958 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2961 return QTAILQ_FIRST(&graph_bdrv_states
);
2963 return QTAILQ_NEXT(bs
, node_list
);
2966 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
2967 * the monitor or attached to a BlockBackend */
2968 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2970 if (!bs
|| bs
->blk
) {
2971 bs
= blk_next_root_bs(bs
);
2977 /* Ignore all BDSs that are attached to a BlockBackend here; they have been
2978 * handled by the above block already */
2980 bs
= bdrv_next_monitor_owned(bs
);
2981 } while (bs
&& bs
->blk
);
2985 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2987 return bs
->node_name
;
2990 /* TODO check what callers really want: bs->node_name or blk_name() */
2991 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2993 return bs
->blk
? blk_name(bs
->blk
) : "";
2996 /* This can be used to identify nodes that might not have a device
2997 * name associated. Since node and device names live in the same
2998 * namespace, the result is unambiguous. The exception is if both are
2999 * absent, then this returns an empty (non-null) string. */
3000 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
3002 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
3005 int bdrv_get_flags(BlockDriverState
*bs
)
3007 return bs
->open_flags
;
3010 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3015 int bdrv_has_zero_init(BlockDriverState
*bs
)
3019 /* If BS is a copy on write image, it is initialized to
3020 the contents of the base image, which may not be zeroes. */
3024 if (bs
->drv
->bdrv_has_zero_init
) {
3025 return bs
->drv
->bdrv_has_zero_init(bs
);
3032 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3034 BlockDriverInfo bdi
;
3040 if (bdrv_get_info(bs
, &bdi
) == 0) {
3041 return bdi
.unallocated_blocks_are_zero
;
3047 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3049 BlockDriverInfo bdi
;
3051 if (bs
->backing
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3055 if (bdrv_get_info(bs
, &bdi
) == 0) {
3056 return bdi
.can_write_zeroes_with_unmap
;
3062 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3064 if (bs
->backing
&& bs
->backing
->bs
->encrypted
)
3065 return bs
->backing_file
;
3066 else if (bs
->encrypted
)
3067 return bs
->filename
;
3072 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3073 char *filename
, int filename_size
)
3075 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3078 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3080 BlockDriver
*drv
= bs
->drv
;
3083 if (!drv
->bdrv_get_info
)
3085 memset(bdi
, 0, sizeof(*bdi
));
3086 return drv
->bdrv_get_info(bs
, bdi
);
3089 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3091 BlockDriver
*drv
= bs
->drv
;
3092 if (drv
&& drv
->bdrv_get_specific_info
) {
3093 return drv
->bdrv_get_specific_info(bs
);
3098 void bdrv_debug_event(BlockDriverState
*bs
, BlkdebugEvent event
)
3100 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3104 bs
->drv
->bdrv_debug_event(bs
, event
);
3107 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3110 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3111 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3114 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3115 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3121 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3123 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3124 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3127 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3128 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3134 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3136 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3137 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3140 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3141 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3147 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3149 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3150 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3153 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3154 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3160 int bdrv_is_snapshot(BlockDriverState
*bs
)
3162 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3165 /* backing_file can either be relative, or absolute, or a protocol. If it is
3166 * relative, it must be relative to the chain. So, passing in bs->filename
3167 * from a BDS as backing_file should not be done, as that may be relative to
3168 * the CWD rather than the chain. */
3169 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3170 const char *backing_file
)
3172 char *filename_full
= NULL
;
3173 char *backing_file_full
= NULL
;
3174 char *filename_tmp
= NULL
;
3175 int is_protocol
= 0;
3176 BlockDriverState
*curr_bs
= NULL
;
3177 BlockDriverState
*retval
= NULL
;
3179 if (!bs
|| !bs
->drv
|| !backing_file
) {
3183 filename_full
= g_malloc(PATH_MAX
);
3184 backing_file_full
= g_malloc(PATH_MAX
);
3185 filename_tmp
= g_malloc(PATH_MAX
);
3187 is_protocol
= path_has_protocol(backing_file
);
3189 for (curr_bs
= bs
; curr_bs
->backing
; curr_bs
= curr_bs
->backing
->bs
) {
3191 /* If either of the filename paths is actually a protocol, then
3192 * compare unmodified paths; otherwise make paths relative */
3193 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3194 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3195 retval
= curr_bs
->backing
->bs
;
3199 /* If not an absolute filename path, make it relative to the current
3200 * image's filename path */
3201 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3204 /* We are going to compare absolute pathnames */
3205 if (!realpath(filename_tmp
, filename_full
)) {
3209 /* We need to make sure the backing filename we are comparing against
3210 * is relative to the current image filename (or absolute) */
3211 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3212 curr_bs
->backing_file
);
3214 if (!realpath(filename_tmp
, backing_file_full
)) {
3218 if (strcmp(backing_file_full
, filename_full
) == 0) {
3219 retval
= curr_bs
->backing
->bs
;
3225 g_free(filename_full
);
3226 g_free(backing_file_full
);
3227 g_free(filename_tmp
);
3231 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3241 return 1 + bdrv_get_backing_file_depth(bs
->backing
->bs
);
3244 void bdrv_init(void)
3246 module_call_init(MODULE_INIT_BLOCK
);
3249 void bdrv_init_with_whitelist(void)
3251 use_bdrv_whitelist
= 1;
3255 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3257 Error
*local_err
= NULL
;
3264 if (!(bs
->open_flags
& BDRV_O_INACTIVE
)) {
3267 bs
->open_flags
&= ~BDRV_O_INACTIVE
;
3269 if (bs
->drv
->bdrv_invalidate_cache
) {
3270 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3271 } else if (bs
->file
) {
3272 bdrv_invalidate_cache(bs
->file
->bs
, &local_err
);
3275 bs
->open_flags
|= BDRV_O_INACTIVE
;
3276 error_propagate(errp
, local_err
);
3280 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3282 bs
->open_flags
|= BDRV_O_INACTIVE
;
3283 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3288 void bdrv_invalidate_cache_all(Error
**errp
)
3290 BlockDriverState
*bs
= NULL
;
3291 Error
*local_err
= NULL
;
3293 while ((bs
= bdrv_next(bs
)) != NULL
) {
3294 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3296 aio_context_acquire(aio_context
);
3297 bdrv_invalidate_cache(bs
, &local_err
);
3298 aio_context_release(aio_context
);
3300 error_propagate(errp
, local_err
);
3306 static int bdrv_inactivate(BlockDriverState
*bs
)
3310 if (bs
->drv
->bdrv_inactivate
) {
3311 ret
= bs
->drv
->bdrv_inactivate(bs
);
3317 bs
->open_flags
|= BDRV_O_INACTIVE
;
3321 int bdrv_inactivate_all(void)
3323 BlockDriverState
*bs
= NULL
;
3326 while ((bs
= bdrv_next(bs
)) != NULL
) {
3327 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3329 aio_context_acquire(aio_context
);
3330 ret
= bdrv_inactivate(bs
);
3331 aio_context_release(aio_context
);
3340 /**************************************************************/
3341 /* removable device support */
3344 * Return TRUE if the media is present
3346 bool bdrv_is_inserted(BlockDriverState
*bs
)
3348 BlockDriver
*drv
= bs
->drv
;
3354 if (drv
->bdrv_is_inserted
) {
3355 return drv
->bdrv_is_inserted(bs
);
3357 QLIST_FOREACH(child
, &bs
->children
, next
) {
3358 if (!bdrv_is_inserted(child
->bs
)) {
3366 * Return whether the media changed since the last call to this
3367 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3369 int bdrv_media_changed(BlockDriverState
*bs
)
3371 BlockDriver
*drv
= bs
->drv
;
3373 if (drv
&& drv
->bdrv_media_changed
) {
3374 return drv
->bdrv_media_changed(bs
);
3380 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3382 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3384 BlockDriver
*drv
= bs
->drv
;
3385 const char *device_name
;
3387 if (drv
&& drv
->bdrv_eject
) {
3388 drv
->bdrv_eject(bs
, eject_flag
);
3391 device_name
= bdrv_get_device_name(bs
);
3392 if (device_name
[0] != '\0') {
3393 qapi_event_send_device_tray_moved(device_name
,
3394 eject_flag
, &error_abort
);
3399 * Lock or unlock the media (if it is locked, the user won't be able
3400 * to eject it manually).
3402 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3404 BlockDriver
*drv
= bs
->drv
;
3406 trace_bdrv_lock_medium(bs
, locked
);
3408 if (drv
&& drv
->bdrv_lock_medium
) {
3409 drv
->bdrv_lock_medium(bs
, locked
);
3413 /* Get a reference to bs */
3414 void bdrv_ref(BlockDriverState
*bs
)
3419 /* Release a previously grabbed reference to bs.
3420 * If after releasing, reference count is zero, the BlockDriverState is
3422 void bdrv_unref(BlockDriverState
*bs
)
3427 assert(bs
->refcnt
> 0);
3428 if (--bs
->refcnt
== 0) {
3433 struct BdrvOpBlocker
{
3435 QLIST_ENTRY(BdrvOpBlocker
) list
;
3438 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3440 BdrvOpBlocker
*blocker
;
3441 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3442 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3443 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3445 *errp
= error_copy(blocker
->reason
);
3446 error_prepend(errp
, "Node '%s' is busy: ",
3447 bdrv_get_device_or_node_name(bs
));
3454 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3456 BdrvOpBlocker
*blocker
;
3457 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3459 blocker
= g_new0(BdrvOpBlocker
, 1);
3460 blocker
->reason
= reason
;
3461 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3464 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3466 BdrvOpBlocker
*blocker
, *next
;
3467 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3468 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3469 if (blocker
->reason
== reason
) {
3470 QLIST_REMOVE(blocker
, list
);
3476 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3479 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3480 bdrv_op_block(bs
, i
, reason
);
3484 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3487 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3488 bdrv_op_unblock(bs
, i
, reason
);
3492 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3496 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3497 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3504 void bdrv_img_create(const char *filename
, const char *fmt
,
3505 const char *base_filename
, const char *base_fmt
,
3506 char *options
, uint64_t img_size
, int flags
,
3507 Error
**errp
, bool quiet
)
3509 QemuOptsList
*create_opts
= NULL
;
3510 QemuOpts
*opts
= NULL
;
3511 const char *backing_fmt
, *backing_file
;
3513 BlockDriver
*drv
, *proto_drv
;
3514 Error
*local_err
= NULL
;
3517 /* Find driver and parse its options */
3518 drv
= bdrv_find_format(fmt
);
3520 error_setg(errp
, "Unknown file format '%s'", fmt
);
3524 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3529 if (!drv
->create_opts
) {
3530 error_setg(errp
, "Format driver '%s' does not support image creation",
3535 if (!proto_drv
->create_opts
) {
3536 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3537 proto_drv
->format_name
);
3541 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3542 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3544 /* Create parameter list with default values */
3545 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3546 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3548 /* Parse -o options */
3550 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3552 error_report_err(local_err
);
3554 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3559 if (base_filename
) {
3560 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3562 error_setg(errp
, "Backing file not supported for file format '%s'",
3569 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3571 error_setg(errp
, "Backing file format not supported for file "
3572 "format '%s'", fmt
);
3577 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3579 if (!strcmp(filename
, backing_file
)) {
3580 error_setg(errp
, "Error: Trying to create an image with the "
3581 "same filename as the backing file");
3586 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3588 // The size for the image must always be specified, with one exception:
3589 // If we are using a backing file, we can obtain the size from there
3590 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3593 BlockDriverState
*bs
;
3594 char *full_backing
= g_new0(char, PATH_MAX
);
3597 QDict
*backing_options
= NULL
;
3599 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3600 full_backing
, PATH_MAX
,
3603 g_free(full_backing
);
3607 /* backing files always opened read-only */
3608 back_flags
= flags
| BDRV_O_CACHE_WB
;
3609 back_flags
&= ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3612 backing_options
= qdict_new();
3613 qdict_put(backing_options
, "driver",
3614 qstring_from_str(backing_fmt
));
3618 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3619 back_flags
, &local_err
);
3620 g_free(full_backing
);
3624 size
= bdrv_getlength(bs
);
3626 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3632 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3636 error_setg(errp
, "Image creation needs a size parameter");
3642 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3643 qemu_opts_print(opts
, " ");
3647 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3649 if (ret
== -EFBIG
) {
3650 /* This is generally a better message than whatever the driver would
3651 * deliver (especially because of the cluster_size_hint), since that
3652 * is most probably not much different from "image too large". */
3653 const char *cluster_size_hint
= "";
3654 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3655 cluster_size_hint
= " (try using a larger cluster size)";
3657 error_setg(errp
, "The image size is too large for file format '%s'"
3658 "%s", fmt
, cluster_size_hint
);
3659 error_free(local_err
);
3664 qemu_opts_del(opts
);
3665 qemu_opts_free(create_opts
);
3667 error_propagate(errp
, local_err
);
3671 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3673 return bs
->aio_context
;
3676 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3678 BdrvAioNotifier
*baf
;
3684 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3685 baf
->detach_aio_context(baf
->opaque
);
3688 if (bs
->throttle_state
) {
3689 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3691 if (bs
->drv
->bdrv_detach_aio_context
) {
3692 bs
->drv
->bdrv_detach_aio_context(bs
);
3695 bdrv_detach_aio_context(bs
->file
->bs
);
3698 bdrv_detach_aio_context(bs
->backing
->bs
);
3701 bs
->aio_context
= NULL
;
3704 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3705 AioContext
*new_context
)
3707 BdrvAioNotifier
*ban
;
3713 bs
->aio_context
= new_context
;
3716 bdrv_attach_aio_context(bs
->backing
->bs
, new_context
);
3719 bdrv_attach_aio_context(bs
->file
->bs
, new_context
);
3721 if (bs
->drv
->bdrv_attach_aio_context
) {
3722 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3724 if (bs
->throttle_state
) {
3725 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3728 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3729 ban
->attached_aio_context(new_context
, ban
->opaque
);
3733 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3735 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3737 bdrv_detach_aio_context(bs
);
3739 /* This function executes in the old AioContext so acquire the new one in
3740 * case it runs in a different thread.
3742 aio_context_acquire(new_context
);
3743 bdrv_attach_aio_context(bs
, new_context
);
3744 aio_context_release(new_context
);
3747 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3748 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3749 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3751 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3752 *ban
= (BdrvAioNotifier
){
3753 .attached_aio_context
= attached_aio_context
,
3754 .detach_aio_context
= detach_aio_context
,
3758 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3761 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3762 void (*attached_aio_context
)(AioContext
*,
3764 void (*detach_aio_context
)(void *),
3767 BdrvAioNotifier
*ban
, *ban_next
;
3769 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3770 if (ban
->attached_aio_context
== attached_aio_context
&&
3771 ban
->detach_aio_context
== detach_aio_context
&&
3772 ban
->opaque
== opaque
)
3774 QLIST_REMOVE(ban
, list
);
3784 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3785 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
3787 if (!bs
->drv
->bdrv_amend_options
) {
3790 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
, cb_opaque
);
3793 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3794 * of block filter and by bdrv_is_first_non_filter.
3795 * It is used to test if the given bs is the candidate or recurse more in the
3798 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3799 BlockDriverState
*candidate
)
3801 /* return false if basic checks fails */
3802 if (!bs
|| !bs
->drv
) {
3806 /* the code reached a non block filter driver -> check if the bs is
3807 * the same as the candidate. It's the recursion termination condition.
3809 if (!bs
->drv
->is_filter
) {
3810 return bs
== candidate
;
3812 /* Down this path the driver is a block filter driver */
3814 /* If the block filter recursion method is defined use it to recurse down
3817 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
3818 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
3821 /* the driver is a block filter but don't allow to recurse -> return false
3826 /* This function checks if the candidate is the first non filter bs down it's
3827 * bs chain. Since we don't have pointers to parents it explore all bs chains
3828 * from the top. Some filters can choose not to pass down the recursion.
3830 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
3832 BlockDriverState
*bs
= NULL
;
3834 /* walk down the bs forest recursively */
3835 while ((bs
= bdrv_next(bs
)) != NULL
) {
3838 /* try to recurse in this top level bs */
3839 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
3841 /* candidate is the first non filter */
3850 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
3851 const char *node_name
, Error
**errp
)
3853 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
3854 AioContext
*aio_context
;
3856 if (!to_replace_bs
) {
3857 error_setg(errp
, "Node name '%s' not found", node_name
);
3861 aio_context
= bdrv_get_aio_context(to_replace_bs
);
3862 aio_context_acquire(aio_context
);
3864 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
3865 to_replace_bs
= NULL
;
3869 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3870 * most non filter in order to prevent data corruption.
3871 * Another benefit is that this tests exclude backing files which are
3872 * blocked by the backing blockers.
3874 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
3875 error_setg(errp
, "Only top most non filter can be replaced");
3876 to_replace_bs
= NULL
;
3881 aio_context_release(aio_context
);
3882 return to_replace_bs
;
3885 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
3887 const QDictEntry
*entry
;
3890 bool found_any
= false;
3893 for (entry
= qdict_first(bs
->options
); entry
;
3894 entry
= qdict_next(bs
->options
, entry
))
3896 /* Exclude options for children */
3897 QLIST_FOREACH(child
, &bs
->children
, next
) {
3898 if (strstart(qdict_entry_key(entry
), child
->name
, &p
)
3899 && (!*p
|| *p
== '.'))
3908 /* And exclude all non-driver-specific options */
3909 for (desc
= bdrv_runtime_opts
.desc
; desc
->name
; desc
++) {
3910 if (!strcmp(qdict_entry_key(entry
), desc
->name
)) {
3918 qobject_incref(qdict_entry_value(entry
));
3919 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
3926 /* Updates the following BDS fields:
3927 * - exact_filename: A filename which may be used for opening a block device
3928 * which (mostly) equals the given BDS (even without any
3929 * other options; so reading and writing must return the same
3930 * results, but caching etc. may be different)
3931 * - full_open_options: Options which, when given when opening a block device
3932 * (without a filename), result in a BDS (mostly)
3933 * equalling the given one
3934 * - filename: If exact_filename is set, it is copied here. Otherwise,
3935 * full_open_options is converted to a JSON object, prefixed with
3936 * "json:" (for use through the JSON pseudo protocol) and put here.
3938 void bdrv_refresh_filename(BlockDriverState
*bs
)
3940 BlockDriver
*drv
= bs
->drv
;
3947 /* This BDS's file name will most probably depend on its file's name, so
3948 * refresh that first */
3950 bdrv_refresh_filename(bs
->file
->bs
);
3953 if (drv
->bdrv_refresh_filename
) {
3954 /* Obsolete information is of no use here, so drop the old file name
3955 * information before refreshing it */
3956 bs
->exact_filename
[0] = '\0';
3957 if (bs
->full_open_options
) {
3958 QDECREF(bs
->full_open_options
);
3959 bs
->full_open_options
= NULL
;
3963 append_open_options(opts
, bs
);
3964 drv
->bdrv_refresh_filename(bs
, opts
);
3966 } else if (bs
->file
) {
3967 /* Try to reconstruct valid information from the underlying file */
3968 bool has_open_options
;
3970 bs
->exact_filename
[0] = '\0';
3971 if (bs
->full_open_options
) {
3972 QDECREF(bs
->full_open_options
);
3973 bs
->full_open_options
= NULL
;
3977 has_open_options
= append_open_options(opts
, bs
);
3979 /* If no specific options have been given for this BDS, the filename of
3980 * the underlying file should suffice for this one as well */
3981 if (bs
->file
->bs
->exact_filename
[0] && !has_open_options
) {
3982 strcpy(bs
->exact_filename
, bs
->file
->bs
->exact_filename
);
3984 /* Reconstructing the full options QDict is simple for most format block
3985 * drivers, as long as the full options are known for the underlying
3986 * file BDS. The full options QDict of that file BDS should somehow
3987 * contain a representation of the filename, therefore the following
3988 * suffices without querying the (exact_)filename of this BDS. */
3989 if (bs
->file
->bs
->full_open_options
) {
3990 qdict_put_obj(opts
, "driver",
3991 QOBJECT(qstring_from_str(drv
->format_name
)));
3992 QINCREF(bs
->file
->bs
->full_open_options
);
3993 qdict_put_obj(opts
, "file",
3994 QOBJECT(bs
->file
->bs
->full_open_options
));
3996 bs
->full_open_options
= opts
;
4000 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4001 /* There is no underlying file BDS (at least referenced by BDS.file),
4002 * so the full options QDict should be equal to the options given
4003 * specifically for this block device when it was opened (plus the
4004 * driver specification).
4005 * Because those options don't change, there is no need to update
4006 * full_open_options when it's already set. */
4009 append_open_options(opts
, bs
);
4010 qdict_put_obj(opts
, "driver",
4011 QOBJECT(qstring_from_str(drv
->format_name
)));
4013 if (bs
->exact_filename
[0]) {
4014 /* This may not work for all block protocol drivers (some may
4015 * require this filename to be parsed), but we have to find some
4016 * default solution here, so just include it. If some block driver
4017 * does not support pure options without any filename at all or
4018 * needs some special format of the options QDict, it needs to
4019 * implement the driver-specific bdrv_refresh_filename() function.
4021 qdict_put_obj(opts
, "filename",
4022 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4025 bs
->full_open_options
= opts
;
4028 if (bs
->exact_filename
[0]) {
4029 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4030 } else if (bs
->full_open_options
) {
4031 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4032 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4033 qstring_get_str(json
));