2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/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"
44 #include <sys/types.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
65 struct BdrvDirtyBitmap
{
66 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
68 char *name
; /* Optional non-empty unique ID */
69 int64_t size
; /* Size of the bitmap (Number of sectors) */
70 bool disabled
; /* Bitmap is read-only */
71 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
76 struct BdrvStates bdrv_states
= QTAILQ_HEAD_INITIALIZER(bdrv_states
);
78 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
79 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
81 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
82 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
84 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
85 const char *reference
, QDict
*options
, int flags
,
86 BlockDriverState
*parent
,
87 const BdrvChildRole
*child_role
, Error
**errp
);
89 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
90 /* If non-zero, use only whitelisted block drivers */
91 static int use_bdrv_whitelist
;
94 static int is_windows_drive_prefix(const char *filename
)
96 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
97 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
101 int is_windows_drive(const char *filename
)
103 if (is_windows_drive_prefix(filename
) &&
106 if (strstart(filename
, "\\\\.\\", NULL
) ||
107 strstart(filename
, "//./", NULL
))
113 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
115 if (!bs
|| !bs
->drv
) {
116 /* page size or 4k (hdd sector size) should be on the safe side */
117 return MAX(4096, getpagesize());
120 return bs
->bl
.opt_mem_alignment
;
123 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
125 if (!bs
|| !bs
->drv
) {
126 /* page size or 4k (hdd sector size) should be on the safe side */
127 return MAX(4096, getpagesize());
130 return bs
->bl
.min_mem_alignment
;
133 /* check if the path starts with "<protocol>:" */
134 int path_has_protocol(const char *path
)
139 if (is_windows_drive(path
) ||
140 is_windows_drive_prefix(path
)) {
143 p
= path
+ strcspn(path
, ":/\\");
145 p
= path
+ strcspn(path
, ":/");
151 int path_is_absolute(const char *path
)
154 /* specific case for names like: "\\.\d:" */
155 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
158 return (*path
== '/' || *path
== '\\');
160 return (*path
== '/');
164 /* if filename is absolute, just copy it to dest. Otherwise, build a
165 path to it by considering it is relative to base_path. URL are
167 void path_combine(char *dest
, int dest_size
,
168 const char *base_path
,
169 const char *filename
)
176 if (path_is_absolute(filename
)) {
177 pstrcpy(dest
, dest_size
, filename
);
179 p
= strchr(base_path
, ':');
184 p1
= strrchr(base_path
, '/');
188 p2
= strrchr(base_path
, '\\');
200 if (len
> dest_size
- 1)
202 memcpy(dest
, base_path
, len
);
204 pstrcat(dest
, dest_size
, filename
);
208 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
210 char *dest
, size_t sz
,
213 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
214 path_is_absolute(backing
))
216 pstrcpy(dest
, sz
, backing
);
217 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
218 error_setg(errp
, "Cannot use relative backing file names for '%s'",
221 path_combine(dest
, sz
, backed
, backing
);
225 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
228 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
230 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
234 void bdrv_register(BlockDriver
*bdrv
)
236 bdrv_setup_io_funcs(bdrv
);
238 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
241 BlockDriverState
*bdrv_new_root(void)
243 BlockDriverState
*bs
= bdrv_new();
245 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
249 BlockDriverState
*bdrv_new(void)
251 BlockDriverState
*bs
;
254 bs
= g_new0(BlockDriverState
, 1);
255 QLIST_INIT(&bs
->dirty_bitmaps
);
256 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
257 QLIST_INIT(&bs
->op_blockers
[i
]);
259 notifier_list_init(&bs
->close_notifiers
);
260 notifier_with_return_list_init(&bs
->before_write_notifiers
);
261 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
262 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
264 bs
->aio_context
= qemu_get_aio_context();
269 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
271 notifier_list_add(&bs
->close_notifiers
, notify
);
274 BlockDriver
*bdrv_find_format(const char *format_name
)
277 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
278 if (!strcmp(drv1
->format_name
, format_name
)) {
285 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
287 static const char *whitelist_rw
[] = {
288 CONFIG_BDRV_RW_WHITELIST
290 static const char *whitelist_ro
[] = {
291 CONFIG_BDRV_RO_WHITELIST
295 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
296 return 1; /* no whitelist, anything goes */
299 for (p
= whitelist_rw
; *p
; p
++) {
300 if (!strcmp(drv
->format_name
, *p
)) {
305 for (p
= whitelist_ro
; *p
; p
++) {
306 if (!strcmp(drv
->format_name
, *p
)) {
314 typedef struct CreateCo
{
322 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
324 Error
*local_err
= NULL
;
327 CreateCo
*cco
= opaque
;
330 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
332 error_propagate(&cco
->err
, local_err
);
337 int bdrv_create(BlockDriver
*drv
, const char* filename
,
338 QemuOpts
*opts
, Error
**errp
)
345 .filename
= g_strdup(filename
),
351 if (!drv
->bdrv_create
) {
352 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
357 if (qemu_in_coroutine()) {
358 /* Fast-path if already in coroutine context */
359 bdrv_create_co_entry(&cco
);
361 co
= qemu_coroutine_create(bdrv_create_co_entry
);
362 qemu_coroutine_enter(co
, &cco
);
363 while (cco
.ret
== NOT_DONE
) {
364 aio_poll(qemu_get_aio_context(), true);
371 error_propagate(errp
, cco
.err
);
373 error_setg_errno(errp
, -ret
, "Could not create image");
378 g_free(cco
.filename
);
382 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
385 Error
*local_err
= NULL
;
388 drv
= bdrv_find_protocol(filename
, true, errp
);
393 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
395 error_propagate(errp
, local_err
);
401 * Try to get @bs's logical and physical block size.
402 * On success, store them in @bsz struct and return 0.
403 * On failure return -errno.
404 * @bs must not be empty.
406 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
408 BlockDriver
*drv
= bs
->drv
;
410 if (drv
&& drv
->bdrv_probe_blocksizes
) {
411 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
418 * Try to get @bs's geometry (cyls, heads, sectors).
419 * On success, store them in @geo struct and return 0.
420 * On failure return -errno.
421 * @bs must not be empty.
423 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
425 BlockDriver
*drv
= bs
->drv
;
427 if (drv
&& drv
->bdrv_probe_geometry
) {
428 return drv
->bdrv_probe_geometry(bs
, geo
);
435 * Create a uniquely-named empty temporary file.
436 * Return 0 upon success, otherwise a negative errno value.
438 int get_tmp_filename(char *filename
, int size
)
441 char temp_dir
[MAX_PATH
];
442 /* GetTempFileName requires that its output buffer (4th param)
443 have length MAX_PATH or greater. */
444 assert(size
>= MAX_PATH
);
445 return (GetTempPath(MAX_PATH
, temp_dir
)
446 && GetTempFileName(temp_dir
, "qem", 0, filename
)
447 ? 0 : -GetLastError());
451 tmpdir
= getenv("TMPDIR");
455 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
458 fd
= mkstemp(filename
);
462 if (close(fd
) != 0) {
471 * Detect host devices. By convention, /dev/cdrom[N] is always
472 * recognized as a host CDROM.
474 static BlockDriver
*find_hdev_driver(const char *filename
)
476 int score_max
= 0, score
;
477 BlockDriver
*drv
= NULL
, *d
;
479 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
480 if (d
->bdrv_probe_device
) {
481 score
= d
->bdrv_probe_device(filename
);
482 if (score
> score_max
) {
492 BlockDriver
*bdrv_find_protocol(const char *filename
,
493 bool allow_protocol_prefix
,
501 /* TODO Drivers without bdrv_file_open must be specified explicitly */
504 * XXX(hch): we really should not let host device detection
505 * override an explicit protocol specification, but moving this
506 * later breaks access to device names with colons in them.
507 * Thanks to the brain-dead persistent naming schemes on udev-
508 * based Linux systems those actually are quite common.
510 drv1
= find_hdev_driver(filename
);
515 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
519 p
= strchr(filename
, ':');
522 if (len
> sizeof(protocol
) - 1)
523 len
= sizeof(protocol
) - 1;
524 memcpy(protocol
, filename
, len
);
525 protocol
[len
] = '\0';
526 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
527 if (drv1
->protocol_name
&&
528 !strcmp(drv1
->protocol_name
, protocol
)) {
533 error_setg(errp
, "Unknown protocol '%s'", protocol
);
538 * Guess image format by probing its contents.
539 * This is not a good idea when your image is raw (CVE-2008-2004), but
540 * we do it anyway for backward compatibility.
542 * @buf contains the image's first @buf_size bytes.
543 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
544 * but can be smaller if the image file is smaller)
545 * @filename is its filename.
547 * For all block drivers, call the bdrv_probe() method to get its
549 * Return the first block driver with the highest probing score.
551 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
552 const char *filename
)
554 int score_max
= 0, score
;
555 BlockDriver
*drv
= NULL
, *d
;
557 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
559 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
560 if (score
> score_max
) {
570 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
571 BlockDriver
**pdrv
, Error
**errp
)
574 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
577 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
578 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
583 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
585 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
591 drv
= bdrv_probe_all(buf
, ret
, filename
);
593 error_setg(errp
, "Could not determine image format: No compatible "
602 * Set the current 'total_sectors' value
603 * Return 0 on success, -errno on error.
605 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
607 BlockDriver
*drv
= bs
->drv
;
609 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
613 /* query actual device if possible, otherwise just trust the hint */
614 if (drv
->bdrv_getlength
) {
615 int64_t length
= drv
->bdrv_getlength(bs
);
619 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
622 bs
->total_sectors
= hint
;
627 * Combines a QDict of new block driver @options with any missing options taken
628 * from @old_options, so that leaving out an option defaults to its old value.
630 static void bdrv_join_options(BlockDriverState
*bs
, QDict
*options
,
633 if (bs
->drv
&& bs
->drv
->bdrv_join_options
) {
634 bs
->drv
->bdrv_join_options(options
, old_options
);
636 qdict_join(options
, old_options
, false);
641 * Set open flags for a given discard mode
643 * Return 0 on success, -1 if the discard mode was invalid.
645 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
647 *flags
&= ~BDRV_O_UNMAP
;
649 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
651 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
652 *flags
|= BDRV_O_UNMAP
;
661 * Set open flags for a given cache mode
663 * Return 0 on success, -1 if the cache mode was invalid.
665 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
667 *flags
&= ~BDRV_O_CACHE_MASK
;
669 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
670 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
671 } else if (!strcmp(mode
, "directsync")) {
672 *flags
|= BDRV_O_NOCACHE
;
673 } else if (!strcmp(mode
, "writeback")) {
674 *flags
|= BDRV_O_CACHE_WB
;
675 } else if (!strcmp(mode
, "unsafe")) {
676 *flags
|= BDRV_O_CACHE_WB
;
677 *flags
|= BDRV_O_NO_FLUSH
;
678 } else if (!strcmp(mode
, "writethrough")) {
679 /* this is the default */
688 * Returns the flags that a temporary snapshot should get, based on the
689 * originally requested flags (the originally requested image will have flags
690 * like a backing file)
692 static int bdrv_temp_snapshot_flags(int flags
)
694 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
698 * Returns the options and flags that bs->file should get if a protocol driver
699 * is expected, based on the given options and flags for the parent BDS
701 static void bdrv_inherited_options(int *child_flags
, QDict
*child_options
,
702 int parent_flags
, QDict
*parent_options
)
704 int flags
= parent_flags
;
706 /* Enable protocol handling, disable format probing for bs->file */
707 flags
|= BDRV_O_PROTOCOL
;
709 /* Our block drivers take care to send flushes and respect unmap policy,
710 * so we can enable both unconditionally on lower layers. */
711 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
713 /* Clear flags that only apply to the top layer */
714 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
716 *child_flags
= flags
;
719 const BdrvChildRole child_file
= {
720 .inherit_options
= bdrv_inherited_options
,
724 * Returns the options and flags that bs->file should get if the use of formats
725 * (and not only protocols) is permitted for it, based on the given options and
726 * flags for the parent BDS
728 static void bdrv_inherited_fmt_options(int *child_flags
, QDict
*child_options
,
729 int parent_flags
, QDict
*parent_options
)
731 child_file
.inherit_options(child_flags
, child_options
,
732 parent_flags
, parent_options
);
734 *child_flags
&= ~BDRV_O_PROTOCOL
;
737 const BdrvChildRole child_format
= {
738 .inherit_options
= bdrv_inherited_fmt_options
,
742 * Returns the options and flags that bs->backing should get, based on the
743 * given options and flags for the parent BDS
745 static void bdrv_backing_options(int *child_flags
, QDict
*child_options
,
746 int parent_flags
, QDict
*parent_options
)
748 int flags
= parent_flags
;
750 /* backing files always opened read-only */
751 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
753 /* snapshot=on is handled on the top layer */
754 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
756 *child_flags
= flags
;
759 static const BdrvChildRole child_backing
= {
760 .inherit_options
= bdrv_backing_options
,
763 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
765 int open_flags
= flags
| BDRV_O_CACHE_WB
;
768 * Clear flags that are internal to the block layer before opening the
771 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
774 * Snapshots should be writable.
776 if (flags
& BDRV_O_TEMPORARY
) {
777 open_flags
|= BDRV_O_RDWR
;
783 static void bdrv_assign_node_name(BlockDriverState
*bs
,
784 const char *node_name
,
787 char *gen_node_name
= NULL
;
790 node_name
= gen_node_name
= id_generate(ID_BLOCK
);
791 } else if (!id_wellformed(node_name
)) {
793 * Check for empty string or invalid characters, but not if it is
794 * generated (generated names use characters not available to the user)
796 error_setg(errp
, "Invalid node name");
800 /* takes care of avoiding namespaces collisions */
801 if (blk_by_name(node_name
)) {
802 error_setg(errp
, "node-name=%s is conflicting with a device id",
807 /* takes care of avoiding duplicates node names */
808 if (bdrv_find_node(node_name
)) {
809 error_setg(errp
, "Duplicate node name");
813 /* copy node name into the bs and insert it into the graph list */
814 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
815 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
817 g_free(gen_node_name
);
820 static QemuOptsList bdrv_runtime_opts
= {
821 .name
= "bdrv_common",
822 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
826 .type
= QEMU_OPT_STRING
,
827 .help
= "Node name of the block device node",
831 .type
= QEMU_OPT_STRING
,
832 .help
= "Block driver to use for the node",
834 { /* end of list */ }
839 * Common part for opening disk images and files
841 * Removes all processed options from *options.
843 static int bdrv_open_common(BlockDriverState
*bs
, BdrvChild
*file
,
844 QDict
*options
, int flags
, Error
**errp
)
847 const char *filename
;
848 const char *driver_name
= NULL
;
849 const char *node_name
= NULL
;
852 Error
*local_err
= NULL
;
854 assert(bs
->file
== NULL
);
855 assert(options
!= NULL
&& bs
->options
!= options
);
857 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
858 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
860 error_propagate(errp
, local_err
);
865 driver_name
= qemu_opt_get(opts
, "driver");
866 drv
= bdrv_find_format(driver_name
);
870 filename
= file
->bs
->filename
;
872 filename
= qdict_get_try_str(options
, "filename");
875 if (drv
->bdrv_needs_filename
&& !filename
) {
876 error_setg(errp
, "The '%s' block driver requires a file name",
882 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
884 node_name
= qemu_opt_get(opts
, "node-name");
885 bdrv_assign_node_name(bs
, node_name
, &local_err
);
887 error_propagate(errp
, local_err
);
892 bs
->request_alignment
= 512;
893 bs
->zero_beyond_eof
= true;
894 open_flags
= bdrv_open_flags(bs
, flags
);
895 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
897 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
899 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
900 ? "Driver '%s' can only be used for read-only devices"
901 : "Driver '%s' is not whitelisted",
907 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
908 if (flags
& BDRV_O_COPY_ON_READ
) {
909 if (!bs
->read_only
) {
910 bdrv_enable_copy_on_read(bs
);
912 error_setg(errp
, "Can't use copy-on-read on read-only device");
918 if (filename
!= NULL
) {
919 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
921 bs
->filename
[0] = '\0';
923 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
926 bs
->opaque
= g_malloc0(drv
->instance_size
);
928 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
930 /* Open the image, either directly or using a protocol */
931 if (drv
->bdrv_file_open
) {
932 assert(file
== NULL
);
933 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
934 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
937 error_setg(errp
, "Can't use '%s' as a block driver for the "
938 "protocol level", drv
->format_name
);
943 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
948 error_propagate(errp
, local_err
);
949 } else if (bs
->filename
[0]) {
950 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
952 error_setg_errno(errp
, -ret
, "Could not open image");
958 error_report("Encrypted images are deprecated");
959 error_printf("Support for them will be removed in a future release.\n"
960 "You can use 'qemu-img convert' to convert your image"
961 " to an unencrypted one.\n");
964 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
966 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
970 bdrv_refresh_limits(bs
, &local_err
);
972 error_propagate(errp
, local_err
);
977 assert(bdrv_opt_mem_align(bs
) != 0);
978 assert(bdrv_min_mem_align(bs
) != 0);
979 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
994 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
996 QObject
*options_obj
;
1000 ret
= strstart(filename
, "json:", &filename
);
1003 options_obj
= qobject_from_json(filename
);
1005 error_setg(errp
, "Could not parse the JSON options");
1009 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1010 qobject_decref(options_obj
);
1011 error_setg(errp
, "Invalid JSON object given");
1015 options
= qobject_to_qdict(options_obj
);
1016 qdict_flatten(options
);
1021 static void parse_json_protocol(QDict
*options
, const char **pfilename
,
1024 QDict
*json_options
;
1025 Error
*local_err
= NULL
;
1027 /* Parse json: pseudo-protocol */
1028 if (!*pfilename
|| !g_str_has_prefix(*pfilename
, "json:")) {
1032 json_options
= parse_json_filename(*pfilename
, &local_err
);
1034 error_propagate(errp
, local_err
);
1038 /* Options given in the filename have lower priority than options
1039 * specified directly */
1040 qdict_join(options
, json_options
, false);
1041 QDECREF(json_options
);
1046 * Fills in default options for opening images and converts the legacy
1047 * filename/flags pair to option QDict entries.
1048 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1049 * block driver has been specified explicitly.
1051 static int bdrv_fill_options(QDict
**options
, const char *filename
,
1052 int *flags
, Error
**errp
)
1054 const char *drvname
;
1055 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1056 bool parse_filename
= false;
1057 BlockDriver
*drv
= NULL
;
1058 Error
*local_err
= NULL
;
1060 drvname
= qdict_get_try_str(*options
, "driver");
1062 drv
= bdrv_find_format(drvname
);
1064 error_setg(errp
, "Unknown driver '%s'", drvname
);
1067 /* If the user has explicitly specified the driver, this choice should
1068 * override the BDRV_O_PROTOCOL flag */
1069 protocol
= drv
->bdrv_file_open
;
1073 *flags
|= BDRV_O_PROTOCOL
;
1075 *flags
&= ~BDRV_O_PROTOCOL
;
1078 /* Fetch the file name from the options QDict if necessary */
1079 if (protocol
&& filename
) {
1080 if (!qdict_haskey(*options
, "filename")) {
1081 qdict_put(*options
, "filename", qstring_from_str(filename
));
1082 parse_filename
= true;
1084 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1090 /* Find the right block driver */
1091 filename
= qdict_get_try_str(*options
, "filename");
1093 if (!drvname
&& protocol
) {
1095 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1100 drvname
= drv
->format_name
;
1101 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1103 error_setg(errp
, "Must specify either driver or file");
1108 assert(drv
|| !protocol
);
1110 /* Driver-specific filename parsing */
1111 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1112 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1114 error_propagate(errp
, local_err
);
1118 if (!drv
->bdrv_needs_filename
) {
1119 qdict_del(*options
, "filename");
1123 if (runstate_check(RUN_STATE_INMIGRATE
)) {
1124 *flags
|= BDRV_O_INCOMING
;
1130 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1131 BlockDriverState
*child_bs
,
1132 const char *child_name
,
1133 const BdrvChildRole
*child_role
)
1135 BdrvChild
*child
= g_new(BdrvChild
, 1);
1136 *child
= (BdrvChild
) {
1138 .name
= g_strdup(child_name
),
1142 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1143 QLIST_INSERT_HEAD(&child_bs
->parents
, child
, next_parent
);
1148 static void bdrv_detach_child(BdrvChild
*child
)
1150 QLIST_REMOVE(child
, next
);
1151 QLIST_REMOVE(child
, next_parent
);
1152 g_free(child
->name
);
1156 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1158 BlockDriverState
*child_bs
;
1160 if (child
== NULL
) {
1164 if (child
->bs
->inherits_from
== parent
) {
1165 child
->bs
->inherits_from
= NULL
;
1168 child_bs
= child
->bs
;
1169 bdrv_detach_child(child
);
1170 bdrv_unref(child_bs
);
1174 * Sets the backing file link of a BDS. A new reference is created; callers
1175 * which don't need their own reference any more must call bdrv_unref().
1177 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1180 bdrv_ref(backing_hd
);
1184 assert(bs
->backing_blocker
);
1185 bdrv_op_unblock_all(bs
->backing
->bs
, bs
->backing_blocker
);
1186 bdrv_unref_child(bs
, bs
->backing
);
1187 } else if (backing_hd
) {
1188 error_setg(&bs
->backing_blocker
,
1189 "node is used as backing hd of '%s'",
1190 bdrv_get_device_or_node_name(bs
));
1194 error_free(bs
->backing_blocker
);
1195 bs
->backing_blocker
= NULL
;
1199 bs
->backing
= bdrv_attach_child(bs
, backing_hd
, "backing", &child_backing
);
1200 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1201 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1202 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1203 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1205 bdrv_op_block_all(backing_hd
, bs
->backing_blocker
);
1206 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1207 bdrv_op_unblock(backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1208 bs
->backing_blocker
);
1210 bdrv_refresh_limits(bs
, NULL
);
1214 * Opens the backing file for a BlockDriverState if not yet open
1216 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1217 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1218 * itself, all options starting with "${bdref_key}." are considered part of the
1221 * TODO Can this be unified with bdrv_open_image()?
1223 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*parent_options
,
1224 const char *bdref_key
, Error
**errp
)
1226 char *backing_filename
= g_malloc0(PATH_MAX
);
1227 char *bdref_key_dot
;
1228 const char *reference
= NULL
;
1230 BlockDriverState
*backing_hd
;
1232 QDict
*tmp_parent_options
= NULL
;
1233 Error
*local_err
= NULL
;
1235 if (bs
->backing
!= NULL
) {
1239 /* NULL means an empty set of options */
1240 if (parent_options
== NULL
) {
1241 tmp_parent_options
= qdict_new();
1242 parent_options
= tmp_parent_options
;
1245 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1247 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1248 qdict_extract_subqdict(parent_options
, &options
, bdref_key_dot
);
1249 g_free(bdref_key_dot
);
1251 reference
= qdict_get_try_str(parent_options
, bdref_key
);
1252 if (reference
|| qdict_haskey(options
, "file.filename")) {
1253 backing_filename
[0] = '\0';
1254 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1258 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1262 error_propagate(errp
, local_err
);
1268 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1270 error_setg(errp
, "Driver doesn't support backing files");
1275 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1276 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1280 ret
= bdrv_open_inherit(&backing_hd
,
1281 *backing_filename
? backing_filename
: NULL
,
1282 reference
, options
, 0, bs
, &child_backing
,
1285 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1286 error_setg(errp
, "Could not open backing file: %s",
1287 error_get_pretty(local_err
));
1288 error_free(local_err
);
1292 /* Hook up the backing file link; drop our reference, bs owns the
1293 * backing_hd reference now */
1294 bdrv_set_backing_hd(bs
, backing_hd
);
1295 bdrv_unref(backing_hd
);
1297 qdict_del(parent_options
, bdref_key
);
1300 g_free(backing_filename
);
1301 QDECREF(tmp_parent_options
);
1306 * Opens a disk image whose options are given as BlockdevRef in another block
1309 * If allow_none is true, no image will be opened if filename is false and no
1310 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1312 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1313 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1314 * itself, all options starting with "${bdref_key}." are considered part of the
1317 * The BlockdevRef will be removed from the options QDict.
1319 BdrvChild
*bdrv_open_child(const char *filename
,
1320 QDict
*options
, const char *bdref_key
,
1321 BlockDriverState
* parent
,
1322 const BdrvChildRole
*child_role
,
1323 bool allow_none
, Error
**errp
)
1325 BdrvChild
*c
= NULL
;
1326 BlockDriverState
*bs
;
1327 QDict
*image_options
;
1329 char *bdref_key_dot
;
1330 const char *reference
;
1332 assert(child_role
!= NULL
);
1334 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1335 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1336 g_free(bdref_key_dot
);
1338 reference
= qdict_get_try_str(options
, bdref_key
);
1339 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1341 error_setg(errp
, "A block device must be specified for \"%s\"",
1344 QDECREF(image_options
);
1349 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1350 parent
, child_role
, errp
);
1355 c
= bdrv_attach_child(parent
, bs
, bdref_key
, child_role
);
1358 qdict_del(options
, bdref_key
);
1362 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1364 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1365 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1367 QemuOpts
*opts
= NULL
;
1368 QDict
*snapshot_options
;
1369 BlockDriverState
*bs_snapshot
;
1370 Error
*local_err
= NULL
;
1373 /* if snapshot, we create a temporary backing file and open it
1374 instead of opening 'filename' directly */
1376 /* Get the required size from the image */
1377 total_size
= bdrv_getlength(bs
);
1378 if (total_size
< 0) {
1380 error_setg_errno(errp
, -total_size
, "Could not get image size");
1384 /* Create the temporary image */
1385 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1387 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1391 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1393 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1394 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1395 qemu_opts_del(opts
);
1397 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1398 "'%s': %s", tmp_filename
,
1399 error_get_pretty(local_err
));
1400 error_free(local_err
);
1404 /* Prepare a new options QDict for the temporary file */
1405 snapshot_options
= qdict_new();
1406 qdict_put(snapshot_options
, "file.driver",
1407 qstring_from_str("file"));
1408 qdict_put(snapshot_options
, "file.filename",
1409 qstring_from_str(tmp_filename
));
1410 qdict_put(snapshot_options
, "driver",
1411 qstring_from_str("qcow2"));
1413 bs_snapshot
= bdrv_new();
1415 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1418 error_propagate(errp
, local_err
);
1422 bdrv_append(bs_snapshot
, bs
);
1425 g_free(tmp_filename
);
1430 * Opens a disk image (raw, qcow2, vmdk, ...)
1432 * options is a QDict of options to pass to the block drivers, or NULL for an
1433 * empty set of options. The reference to the QDict belongs to the block layer
1434 * after the call (even on failure), so if the caller intends to reuse the
1435 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1437 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1438 * If it is not NULL, the referenced BDS will be reused.
1440 * The reference parameter may be used to specify an existing block device which
1441 * should be opened. If specified, neither options nor a filename may be given,
1442 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1444 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1445 const char *reference
, QDict
*options
, int flags
,
1446 BlockDriverState
*parent
,
1447 const BdrvChildRole
*child_role
, Error
**errp
)
1450 BdrvChild
*file
= NULL
;
1451 BlockDriverState
*bs
;
1452 BlockDriver
*drv
= NULL
;
1453 const char *drvname
;
1454 const char *backing
;
1455 Error
*local_err
= NULL
;
1456 int snapshot_flags
= 0;
1459 assert(!child_role
|| !flags
);
1460 assert(!child_role
== !parent
);
1463 bool options_non_empty
= options
? qdict_size(options
) : false;
1467 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1468 "another block device");
1472 if (filename
|| options_non_empty
) {
1473 error_setg(errp
, "Cannot reference an existing block device with "
1474 "additional options or a new filename");
1478 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1493 /* NULL means an empty set of options */
1494 if (options
== NULL
) {
1495 options
= qdict_new();
1498 /* json: syntax counts as explicit options, as if in the QDict */
1499 parse_json_protocol(options
, &filename
, &local_err
);
1505 bs
->explicit_options
= qdict_clone_shallow(options
);
1508 bs
->inherits_from
= parent
;
1509 child_role
->inherit_options(&flags
, options
,
1510 parent
->open_flags
, parent
->options
);
1513 ret
= bdrv_fill_options(&options
, filename
, &flags
, &local_err
);
1518 bs
->open_flags
= flags
;
1519 bs
->options
= options
;
1520 options
= qdict_clone_shallow(options
);
1522 /* Find the right image format driver */
1523 drvname
= qdict_get_try_str(options
, "driver");
1525 drv
= bdrv_find_format(drvname
);
1527 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1533 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1535 backing
= qdict_get_try_str(options
, "backing");
1536 if (backing
&& *backing
== '\0') {
1537 flags
|= BDRV_O_NO_BACKING
;
1538 qdict_del(options
, "backing");
1541 /* Open image file without format layer */
1542 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1543 if (flags
& BDRV_O_RDWR
) {
1544 flags
|= BDRV_O_ALLOW_RDWR
;
1546 if (flags
& BDRV_O_SNAPSHOT
) {
1547 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1548 bdrv_backing_options(&flags
, options
, flags
, options
);
1551 bs
->open_flags
= flags
;
1553 file
= bdrv_open_child(filename
, options
, "file", bs
,
1554 &child_file
, true, &local_err
);
1561 /* Image format probing */
1564 ret
= find_image_format(file
->bs
, filename
, &drv
, &local_err
);
1569 * This option update would logically belong in bdrv_fill_options(),
1570 * but we first need to open bs->file for the probing to work, while
1571 * opening bs->file already requires the (mostly) final set of options
1572 * so that cache mode etc. can be inherited.
1574 * Adding the driver later is somewhat ugly, but it's not an option
1575 * that would ever be inherited, so it's correct. We just need to make
1576 * sure to update both bs->options (which has the full effective
1577 * options for bs) and options (which has file.* already removed).
1579 qdict_put(bs
->options
, "driver", qstring_from_str(drv
->format_name
));
1580 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1582 error_setg(errp
, "Must specify either driver or file");
1587 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1588 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1589 /* file must be NULL if a protocol BDS is about to be created
1590 * (the inverse results in an error message from bdrv_open_common()) */
1591 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1593 /* Open the image */
1594 ret
= bdrv_open_common(bs
, file
, options
, flags
, &local_err
);
1599 if (file
&& (bs
->file
!= file
)) {
1600 bdrv_unref_child(bs
, file
);
1604 /* If there is a backing file, use it */
1605 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1606 ret
= bdrv_open_backing_file(bs
, options
, "backing", &local_err
);
1608 goto close_and_fail
;
1612 bdrv_refresh_filename(bs
);
1614 /* Check if any unknown options were used */
1615 if (options
&& (qdict_size(options
) != 0)) {
1616 const QDictEntry
*entry
= qdict_first(options
);
1617 if (flags
& BDRV_O_PROTOCOL
) {
1618 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1619 "'%s'", drv
->format_name
, entry
->key
);
1621 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1622 "support the option '%s'", drv
->format_name
,
1623 bdrv_get_device_name(bs
), entry
->key
);
1627 goto close_and_fail
;
1630 if (!bdrv_key_required(bs
)) {
1632 blk_dev_change_media_cb(bs
->blk
, true);
1634 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1635 && !runstate_check(RUN_STATE_INMIGRATE
)
1636 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1638 "Guest must be stopped for opening of encrypted image");
1640 goto close_and_fail
;
1646 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1647 * temporary snapshot afterwards. */
1648 if (snapshot_flags
) {
1649 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1651 goto close_and_fail
;
1659 bdrv_unref_child(bs
, file
);
1661 QDECREF(bs
->explicit_options
);
1662 QDECREF(bs
->options
);
1666 /* If *pbs is NULL, a new BDS has been created in this function and
1667 needs to be freed now. Otherwise, it does not need to be closed,
1668 since it has not really been opened yet. */
1672 error_propagate(errp
, local_err
);
1677 /* See fail path, but now the BDS has to be always closed */
1685 error_propagate(errp
, local_err
);
1690 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1691 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1693 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1697 typedef struct BlockReopenQueueEntry
{
1699 BDRVReopenState state
;
1700 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1701 } BlockReopenQueueEntry
;
1704 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1705 * reopen of multiple devices.
1707 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1708 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1709 * be created and initialized. This newly created BlockReopenQueue should be
1710 * passed back in for subsequent calls that are intended to be of the same
1713 * bs is the BlockDriverState to add to the reopen queue.
1715 * options contains the changed options for the associated bs
1716 * (the BlockReopenQueue takes ownership)
1718 * flags contains the open flags for the associated bs
1720 * returns a pointer to bs_queue, which is either the newly allocated
1721 * bs_queue, or the existing bs_queue being used.
1724 static BlockReopenQueue
*bdrv_reopen_queue_child(BlockReopenQueue
*bs_queue
,
1725 BlockDriverState
*bs
,
1728 const BdrvChildRole
*role
,
1729 QDict
*parent_options
,
1734 BlockReopenQueueEntry
*bs_entry
;
1736 QDict
*old_options
, *explicit_options
;
1738 if (bs_queue
== NULL
) {
1739 bs_queue
= g_new0(BlockReopenQueue
, 1);
1740 QSIMPLEQ_INIT(bs_queue
);
1744 options
= qdict_new();
1748 * Precedence of options:
1749 * 1. Explicitly passed in options (highest)
1750 * 2. TODO Set in flags (only for top level)
1751 * 3. Retained from explicitly set options of bs
1752 * 4. Inherited from parent node
1753 * 5. Retained from effective options of bs
1756 /* Old explicitly set values (don't overwrite by inherited value) */
1757 old_options
= qdict_clone_shallow(bs
->explicit_options
);
1758 bdrv_join_options(bs
, options
, old_options
);
1759 QDECREF(old_options
);
1761 explicit_options
= qdict_clone_shallow(options
);
1763 /* Inherit from parent node */
1764 if (parent_options
) {
1766 role
->inherit_options(&flags
, options
, parent_flags
, parent_options
);
1769 /* Old values are used for options that aren't set yet */
1770 old_options
= qdict_clone_shallow(bs
->options
);
1771 bdrv_join_options(bs
, options
, old_options
);
1772 QDECREF(old_options
);
1774 /* bdrv_open() masks this flag out */
1775 flags
&= ~BDRV_O_PROTOCOL
;
1777 QLIST_FOREACH(child
, &bs
->children
, next
) {
1778 QDict
*new_child_options
;
1779 char *child_key_dot
;
1781 /* reopen can only change the options of block devices that were
1782 * implicitly created and inherited options. For other (referenced)
1783 * block devices, a syntax like "backing.foo" results in an error. */
1784 if (child
->bs
->inherits_from
!= bs
) {
1788 child_key_dot
= g_strdup_printf("%s.", child
->name
);
1789 qdict_extract_subqdict(options
, &new_child_options
, child_key_dot
);
1790 g_free(child_key_dot
);
1792 bdrv_reopen_queue_child(bs_queue
, child
->bs
, new_child_options
, 0,
1793 child
->role
, options
, flags
);
1796 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1797 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1799 bs_entry
->state
.bs
= bs
;
1800 bs_entry
->state
.options
= options
;
1801 bs_entry
->state
.explicit_options
= explicit_options
;
1802 bs_entry
->state
.flags
= flags
;
1807 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1808 BlockDriverState
*bs
,
1809 QDict
*options
, int flags
)
1811 return bdrv_reopen_queue_child(bs_queue
, bs
, options
, flags
,
1816 * Reopen multiple BlockDriverStates atomically & transactionally.
1818 * The queue passed in (bs_queue) must have been built up previous
1819 * via bdrv_reopen_queue().
1821 * Reopens all BDS specified in the queue, with the appropriate
1822 * flags. All devices are prepared for reopen, and failure of any
1823 * device will cause all device changes to be abandonded, and intermediate
1826 * If all devices prepare successfully, then the changes are committed
1830 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1833 BlockReopenQueueEntry
*bs_entry
, *next
;
1834 Error
*local_err
= NULL
;
1836 assert(bs_queue
!= NULL
);
1840 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1841 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1842 error_propagate(errp
, local_err
);
1845 bs_entry
->prepared
= true;
1848 /* If we reach this point, we have success and just need to apply the
1851 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1852 bdrv_reopen_commit(&bs_entry
->state
);
1858 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1859 if (ret
&& bs_entry
->prepared
) {
1860 bdrv_reopen_abort(&bs_entry
->state
);
1862 QDECREF(bs_entry
->state
.explicit_options
);
1864 QDECREF(bs_entry
->state
.options
);
1872 /* Reopen a single BlockDriverState with the specified flags. */
1873 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1876 Error
*local_err
= NULL
;
1877 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, NULL
, bdrv_flags
);
1879 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1880 if (local_err
!= NULL
) {
1881 error_propagate(errp
, local_err
);
1888 * Prepares a BlockDriverState for reopen. All changes are staged in the
1889 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1890 * the block driver layer .bdrv_reopen_prepare()
1892 * bs is the BlockDriverState to reopen
1893 * flags are the new open flags
1894 * queue is the reopen queue
1896 * Returns 0 on success, non-zero on error. On error errp will be set
1899 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1900 * It is the responsibility of the caller to then call the abort() or
1901 * commit() for any other BDS that have been left in a prepare() state
1904 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1908 Error
*local_err
= NULL
;
1913 assert(reopen_state
!= NULL
);
1914 assert(reopen_state
->bs
->drv
!= NULL
);
1915 drv
= reopen_state
->bs
->drv
;
1917 /* Process generic block layer options */
1918 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
1919 qemu_opts_absorb_qdict(opts
, reopen_state
->options
, &local_err
);
1921 error_propagate(errp
, local_err
);
1926 /* node-name and driver must be unchanged. Put them back into the QDict, so
1927 * that they are checked at the end of this function. */
1928 value
= qemu_opt_get(opts
, "node-name");
1930 qdict_put(reopen_state
->options
, "node-name", qstring_from_str(value
));
1933 value
= qemu_opt_get(opts
, "driver");
1935 qdict_put(reopen_state
->options
, "driver", qstring_from_str(value
));
1938 /* if we are to stay read-only, do not allow permission change
1940 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1941 reopen_state
->flags
& BDRV_O_RDWR
) {
1942 error_setg(errp
, "Node '%s' is read only",
1943 bdrv_get_device_or_node_name(reopen_state
->bs
));
1948 ret
= bdrv_flush(reopen_state
->bs
);
1950 error_setg_errno(errp
, -ret
, "Error flushing drive");
1954 if (drv
->bdrv_reopen_prepare
) {
1955 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1957 if (local_err
!= NULL
) {
1958 error_propagate(errp
, local_err
);
1960 error_setg(errp
, "failed while preparing to reopen image '%s'",
1961 reopen_state
->bs
->filename
);
1966 /* It is currently mandatory to have a bdrv_reopen_prepare()
1967 * handler for each supported drv. */
1968 error_setg(errp
, "Block format '%s' used by node '%s' "
1969 "does not support reopening files", drv
->format_name
,
1970 bdrv_get_device_or_node_name(reopen_state
->bs
));
1975 /* Options that are not handled are only okay if they are unchanged
1976 * compared to the old state. It is expected that some options are only
1977 * used for the initial open, but not reopen (e.g. filename) */
1978 if (qdict_size(reopen_state
->options
)) {
1979 const QDictEntry
*entry
= qdict_first(reopen_state
->options
);
1982 QString
*new_obj
= qobject_to_qstring(entry
->value
);
1983 const char *new = qstring_get_str(new_obj
);
1984 const char *old
= qdict_get_try_str(reopen_state
->bs
->options
,
1987 if (!old
|| strcmp(new, old
)) {
1988 error_setg(errp
, "Cannot change the option '%s'", entry
->key
);
1992 } while ((entry
= qdict_next(reopen_state
->options
, entry
)));
1998 qemu_opts_del(opts
);
2003 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2004 * makes them final by swapping the staging BlockDriverState contents into
2005 * the active BlockDriverState contents.
2007 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
2011 assert(reopen_state
!= NULL
);
2012 drv
= reopen_state
->bs
->drv
;
2013 assert(drv
!= NULL
);
2015 /* If there are any driver level actions to take */
2016 if (drv
->bdrv_reopen_commit
) {
2017 drv
->bdrv_reopen_commit(reopen_state
);
2020 /* set BDS specific flags now */
2021 QDECREF(reopen_state
->bs
->explicit_options
);
2023 reopen_state
->bs
->explicit_options
= reopen_state
->explicit_options
;
2024 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
2025 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
2027 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
2029 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
2033 * Abort the reopen, and delete and free the staged changes in
2036 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
2040 assert(reopen_state
!= NULL
);
2041 drv
= reopen_state
->bs
->drv
;
2042 assert(drv
!= NULL
);
2044 if (drv
->bdrv_reopen_abort
) {
2045 drv
->bdrv_reopen_abort(reopen_state
);
2048 QDECREF(reopen_state
->explicit_options
);
2052 void bdrv_close(BlockDriverState
*bs
)
2054 BdrvAioNotifier
*ban
, *ban_next
;
2057 block_job_cancel_sync(bs
->job
);
2060 /* Disable I/O limits and drain all pending throttled requests */
2061 if (bs
->throttle_state
) {
2062 bdrv_io_limits_disable(bs
);
2065 bdrv_drain(bs
); /* complete I/O */
2067 bdrv_drain(bs
); /* in case flush left pending I/O */
2068 notifier_list_notify(&bs
->close_notifiers
, bs
);
2071 blk_dev_change_media_cb(bs
->blk
, false);
2075 BdrvChild
*child
, *next
;
2077 bs
->drv
->bdrv_close(bs
);
2080 bdrv_set_backing_hd(bs
, NULL
);
2082 if (bs
->file
!= NULL
) {
2083 bdrv_unref_child(bs
, bs
->file
);
2087 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
2088 /* TODO Remove bdrv_unref() from drivers' close function and use
2089 * bdrv_unref_child() here */
2090 if (child
->bs
->inherits_from
== bs
) {
2091 child
->bs
->inherits_from
= NULL
;
2093 bdrv_detach_child(child
);
2098 bs
->copy_on_read
= 0;
2099 bs
->backing_file
[0] = '\0';
2100 bs
->backing_format
[0] = '\0';
2101 bs
->total_sectors
= 0;
2105 bs
->zero_beyond_eof
= false;
2106 QDECREF(bs
->options
);
2107 QDECREF(bs
->explicit_options
);
2109 QDECREF(bs
->full_open_options
);
2110 bs
->full_open_options
= NULL
;
2113 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
2116 QLIST_INIT(&bs
->aio_notifiers
);
2119 void bdrv_close_all(void)
2121 BlockDriverState
*bs
;
2123 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2124 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2126 aio_context_acquire(aio_context
);
2128 aio_context_release(aio_context
);
2132 /* make a BlockDriverState anonymous by removing from bdrv_state and
2133 * graph_bdrv_state list.
2134 Also, NULL terminate the device_name to prevent double remove */
2135 void bdrv_make_anon(BlockDriverState
*bs
)
2138 * Take care to remove bs from bdrv_states only when it's actually
2139 * in it. Note that bs->device_list.tqe_prev is initially null,
2140 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2141 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2142 * resetting it to null on remove.
2144 if (bs
->device_list
.tqe_prev
) {
2145 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
2146 bs
->device_list
.tqe_prev
= NULL
;
2148 if (bs
->node_name
[0] != '\0') {
2149 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2151 bs
->node_name
[0] = '\0';
2154 /* Fields that need to stay with the top-level BDS */
2155 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2156 BlockDriverState
*bs_src
)
2158 /* move some fields that need to stay attached to the device */
2161 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2163 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2166 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2169 static void change_parent_backing_link(BlockDriverState
*from
,
2170 BlockDriverState
*to
)
2172 BdrvChild
*c
, *next
;
2174 QLIST_FOREACH_SAFE(c
, &from
->parents
, next_parent
, next
) {
2175 assert(c
->role
!= &child_backing
);
2177 QLIST_REMOVE(c
, next_parent
);
2178 QLIST_INSERT_HEAD(&to
->parents
, c
, next_parent
);
2183 blk_set_bs(from
->blk
, to
);
2184 if (!to
->device_list
.tqe_prev
) {
2185 QTAILQ_INSERT_BEFORE(from
, to
, device_list
);
2187 QTAILQ_REMOVE(&bdrv_states
, from
, device_list
);
2191 static void swap_feature_fields(BlockDriverState
*bs_top
,
2192 BlockDriverState
*bs_new
)
2194 BlockDriverState tmp
;
2196 bdrv_move_feature_fields(&tmp
, bs_top
);
2197 bdrv_move_feature_fields(bs_top
, bs_new
);
2198 bdrv_move_feature_fields(bs_new
, &tmp
);
2200 assert(!bs_new
->throttle_state
);
2201 if (bs_top
->throttle_state
) {
2202 assert(bs_top
->io_limits_enabled
);
2203 bdrv_io_limits_enable(bs_new
, throttle_group_get_name(bs_top
));
2204 bdrv_io_limits_disable(bs_top
);
2209 * Add new bs contents at the top of an image chain while the chain is
2210 * live, while keeping required fields on the top layer.
2212 * This will modify the BlockDriverState fields, and swap contents
2213 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2215 * bs_new must not be attached to a BlockBackend.
2217 * This function does not create any image files.
2219 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2220 * that's what the callers commonly need. bs_new will be referenced by the old
2221 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2222 * reference of its own, it must call bdrv_ref().
2224 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2226 assert(!bdrv_requests_pending(bs_top
));
2227 assert(!bdrv_requests_pending(bs_new
));
2230 change_parent_backing_link(bs_top
, bs_new
);
2232 /* Some fields always stay on top of the backing file chain */
2233 swap_feature_fields(bs_top
, bs_new
);
2235 bdrv_set_backing_hd(bs_new
, bs_top
);
2238 /* bs_new is now referenced by its new parents, we don't need the
2239 * additional reference any more. */
2243 void bdrv_replace_in_backing_chain(BlockDriverState
*old
, BlockDriverState
*new)
2245 assert(!bdrv_requests_pending(old
));
2246 assert(!bdrv_requests_pending(new));
2251 /* As long as these fields aren't in BlockBackend, but in the top-level
2252 * BlockDriverState, it's not possible for a BDS to have two BBs.
2254 * We really want to copy the fields from old to new, but we go for a
2255 * swap instead so that pointers aren't duplicated and cause trouble.
2256 * (Also, bdrv_swap() used to do the same.) */
2258 swap_feature_fields(old
, new);
2260 change_parent_backing_link(old
, new);
2262 /* Change backing files if a previously independent node is added to the
2263 * chain. For active commit, we replace top by its own (indirect) backing
2264 * file and don't do anything here so we don't build a loop. */
2265 if (new->backing
== NULL
&& !bdrv_chain_contains(backing_bs(old
), new)) {
2266 bdrv_set_backing_hd(new, backing_bs(old
));
2267 bdrv_set_backing_hd(old
, NULL
);
2273 static void bdrv_delete(BlockDriverState
*bs
)
2276 assert(bdrv_op_blocker_is_empty(bs
));
2277 assert(!bs
->refcnt
);
2278 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2282 /* remove from list, if necessary */
2289 * Run consistency checks on an image
2291 * Returns 0 if the check could be completed (it doesn't mean that the image is
2292 * free of errors) or -errno when an internal error occurred. The results of the
2293 * check are stored in res.
2295 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2297 if (bs
->drv
== NULL
) {
2300 if (bs
->drv
->bdrv_check
== NULL
) {
2304 memset(res
, 0, sizeof(*res
));
2305 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2308 #define COMMIT_BUF_SECTORS 2048
2310 /* commit COW file into the raw image */
2311 int bdrv_commit(BlockDriverState
*bs
)
2313 BlockDriver
*drv
= bs
->drv
;
2314 int64_t sector
, total_sectors
, length
, backing_length
;
2315 int n
, ro
, open_flags
;
2317 uint8_t *buf
= NULL
;
2326 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2327 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2331 ro
= bs
->backing
->bs
->read_only
;
2332 open_flags
= bs
->backing
->bs
->open_flags
;
2335 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2340 length
= bdrv_getlength(bs
);
2346 backing_length
= bdrv_getlength(bs
->backing
->bs
);
2347 if (backing_length
< 0) {
2348 ret
= backing_length
;
2352 /* If our top snapshot is larger than the backing file image,
2353 * grow the backing file image if possible. If not possible,
2354 * we must return an error */
2355 if (length
> backing_length
) {
2356 ret
= bdrv_truncate(bs
->backing
->bs
, length
);
2362 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2364 /* qemu_try_blockalign() for bs will choose an alignment that works for
2365 * bs->backing->bs as well, so no need to compare the alignment manually. */
2366 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2372 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2373 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2378 ret
= bdrv_read(bs
, sector
, buf
, n
);
2383 ret
= bdrv_write(bs
->backing
->bs
, sector
, buf
, n
);
2390 if (drv
->bdrv_make_empty
) {
2391 ret
= drv
->bdrv_make_empty(bs
);
2399 * Make sure all data we wrote to the backing device is actually
2403 bdrv_flush(bs
->backing
->bs
);
2411 /* ignoring error return here */
2412 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2418 int bdrv_commit_all(void)
2420 BlockDriverState
*bs
;
2422 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2423 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2425 aio_context_acquire(aio_context
);
2426 if (bs
->drv
&& bs
->backing
) {
2427 int ret
= bdrv_commit(bs
);
2429 aio_context_release(aio_context
);
2433 aio_context_release(aio_context
);
2441 * -EINVAL - backing format specified, but no file
2442 * -ENOSPC - can't update the backing file because no space is left in the
2444 * -ENOTSUP - format driver doesn't support changing the backing file
2446 int bdrv_change_backing_file(BlockDriverState
*bs
,
2447 const char *backing_file
, const char *backing_fmt
)
2449 BlockDriver
*drv
= bs
->drv
;
2452 /* Backing file format doesn't make sense without a backing file */
2453 if (backing_fmt
&& !backing_file
) {
2457 if (drv
->bdrv_change_backing_file
!= NULL
) {
2458 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2464 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2465 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2471 * Finds the image layer in the chain that has 'bs' as its backing file.
2473 * active is the current topmost image.
2475 * Returns NULL if bs is not found in active's image chain,
2476 * or if active == bs.
2478 * Returns the bottommost base image if bs == NULL.
2480 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2481 BlockDriverState
*bs
)
2483 while (active
&& bs
!= backing_bs(active
)) {
2484 active
= backing_bs(active
);
2490 /* Given a BDS, searches for the base layer. */
2491 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2493 return bdrv_find_overlay(bs
, NULL
);
2497 * Drops images above 'base' up to and including 'top', and sets the image
2498 * above 'top' to have base as its backing file.
2500 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2501 * information in 'bs' can be properly updated.
2503 * E.g., this will convert the following chain:
2504 * bottom <- base <- intermediate <- top <- active
2508 * bottom <- base <- active
2510 * It is allowed for bottom==base, in which case it converts:
2512 * base <- intermediate <- top <- active
2518 * If backing_file_str is non-NULL, it will be used when modifying top's
2519 * overlay image metadata.
2522 * if active == top, that is considered an error
2525 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2526 BlockDriverState
*base
, const char *backing_file_str
)
2528 BlockDriverState
*new_top_bs
= NULL
;
2531 if (!top
->drv
|| !base
->drv
) {
2535 new_top_bs
= bdrv_find_overlay(active
, top
);
2537 if (new_top_bs
== NULL
) {
2538 /* we could not find the image above 'top', this is an error */
2542 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2543 * to do, no intermediate images */
2544 if (backing_bs(new_top_bs
) == base
) {
2549 /* Make sure that base is in the backing chain of top */
2550 if (!bdrv_chain_contains(top
, base
)) {
2554 /* success - we can delete the intermediate states, and link top->base */
2555 backing_file_str
= backing_file_str
? backing_file_str
: base
->filename
;
2556 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2557 base
->drv
? base
->drv
->format_name
: "");
2561 bdrv_set_backing_hd(new_top_bs
, base
);
2569 * Truncate file to 'offset' bytes (needed only for file protocols)
2571 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2573 BlockDriver
*drv
= bs
->drv
;
2577 if (!drv
->bdrv_truncate
)
2582 ret
= drv
->bdrv_truncate(bs
, offset
);
2584 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2585 bdrv_dirty_bitmap_truncate(bs
);
2587 blk_dev_resize_cb(bs
->blk
);
2594 * Length of a allocated file in bytes. Sparse files are counted by actual
2595 * allocated space. Return < 0 if error or unknown.
2597 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2599 BlockDriver
*drv
= bs
->drv
;
2603 if (drv
->bdrv_get_allocated_file_size
) {
2604 return drv
->bdrv_get_allocated_file_size(bs
);
2607 return bdrv_get_allocated_file_size(bs
->file
->bs
);
2613 * Return number of sectors on success, -errno on error.
2615 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2617 BlockDriver
*drv
= bs
->drv
;
2622 if (drv
->has_variable_length
) {
2623 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2628 return bs
->total_sectors
;
2632 * Return length in bytes on success, -errno on error.
2633 * The length is always a multiple of BDRV_SECTOR_SIZE.
2635 int64_t bdrv_getlength(BlockDriverState
*bs
)
2637 int64_t ret
= bdrv_nb_sectors(bs
);
2639 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2640 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2643 /* return 0 as number of sectors if no device present or error */
2644 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2646 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2648 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2651 int bdrv_is_read_only(BlockDriverState
*bs
)
2653 return bs
->read_only
;
2656 int bdrv_is_sg(BlockDriverState
*bs
)
2661 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2663 return bs
->enable_write_cache
;
2666 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2668 bs
->enable_write_cache
= wce
;
2670 /* so a reopen() will preserve wce */
2672 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2674 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2678 int bdrv_is_encrypted(BlockDriverState
*bs
)
2680 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2683 return bs
->encrypted
;
2686 int bdrv_key_required(BlockDriverState
*bs
)
2688 BdrvChild
*backing
= bs
->backing
;
2690 if (backing
&& backing
->bs
->encrypted
&& !backing
->bs
->valid_key
) {
2693 return (bs
->encrypted
&& !bs
->valid_key
);
2696 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2699 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2700 ret
= bdrv_set_key(bs
->backing
->bs
, key
);
2706 if (!bs
->encrypted
) {
2708 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2711 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2714 } else if (!bs
->valid_key
) {
2717 /* call the change callback now, we skipped it on open */
2718 blk_dev_change_media_cb(bs
->blk
, true);
2725 * Provide an encryption key for @bs.
2726 * If @key is non-null:
2727 * If @bs is not encrypted, fail.
2728 * Else if the key is invalid, fail.
2729 * Else set @bs's key to @key, replacing the existing key, if any.
2731 * If @bs is encrypted and still lacks a key, fail.
2733 * On failure, store an error object through @errp if non-null.
2735 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2738 if (!bdrv_is_encrypted(bs
)) {
2739 error_setg(errp
, "Node '%s' is not encrypted",
2740 bdrv_get_device_or_node_name(bs
));
2741 } else if (bdrv_set_key(bs
, key
) < 0) {
2742 error_setg(errp
, QERR_INVALID_PASSWORD
);
2745 if (bdrv_key_required(bs
)) {
2746 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2747 "'%s' (%s) is encrypted",
2748 bdrv_get_device_or_node_name(bs
),
2749 bdrv_get_encrypted_filename(bs
));
2754 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2756 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2759 static int qsort_strcmp(const void *a
, const void *b
)
2761 return strcmp(a
, b
);
2764 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2770 const char **formats
= NULL
;
2772 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2773 if (drv
->format_name
) {
2776 while (formats
&& i
&& !found
) {
2777 found
= !strcmp(formats
[--i
], drv
->format_name
);
2781 formats
= g_renew(const char *, formats
, count
+ 1);
2782 formats
[count
++] = drv
->format_name
;
2787 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2789 for (i
= 0; i
< count
; i
++) {
2790 it(opaque
, formats
[i
]);
2796 /* This function is to find a node in the bs graph */
2797 BlockDriverState
*bdrv_find_node(const char *node_name
)
2799 BlockDriverState
*bs
;
2803 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2804 if (!strcmp(node_name
, bs
->node_name
)) {
2811 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2812 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2814 BlockDeviceInfoList
*list
, *entry
;
2815 BlockDriverState
*bs
;
2818 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2819 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2821 qapi_free_BlockDeviceInfoList(list
);
2824 entry
= g_malloc0(sizeof(*entry
));
2825 entry
->value
= info
;
2833 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2834 const char *node_name
,
2838 BlockDriverState
*bs
;
2841 blk
= blk_by_name(device
);
2846 error_setg(errp
, "Device '%s' has no medium", device
);
2854 bs
= bdrv_find_node(node_name
);
2861 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2862 device
? device
: "",
2863 node_name
? node_name
: "");
2867 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2868 * return false. If either argument is NULL, return false. */
2869 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2871 while (top
&& top
!= base
) {
2872 top
= backing_bs(top
);
2878 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2881 return QTAILQ_FIRST(&graph_bdrv_states
);
2883 return QTAILQ_NEXT(bs
, node_list
);
2886 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2889 return QTAILQ_FIRST(&bdrv_states
);
2891 return QTAILQ_NEXT(bs
, device_list
);
2894 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2896 return bs
->node_name
;
2899 /* TODO check what callers really want: bs->node_name or blk_name() */
2900 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2902 return bs
->blk
? blk_name(bs
->blk
) : "";
2905 /* This can be used to identify nodes that might not have a device
2906 * name associated. Since node and device names live in the same
2907 * namespace, the result is unambiguous. The exception is if both are
2908 * absent, then this returns an empty (non-null) string. */
2909 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2911 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2914 int bdrv_get_flags(BlockDriverState
*bs
)
2916 return bs
->open_flags
;
2919 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2924 int bdrv_has_zero_init(BlockDriverState
*bs
)
2928 /* If BS is a copy on write image, it is initialized to
2929 the contents of the base image, which may not be zeroes. */
2933 if (bs
->drv
->bdrv_has_zero_init
) {
2934 return bs
->drv
->bdrv_has_zero_init(bs
);
2941 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2943 BlockDriverInfo bdi
;
2949 if (bdrv_get_info(bs
, &bdi
) == 0) {
2950 return bdi
.unallocated_blocks_are_zero
;
2956 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2958 BlockDriverInfo bdi
;
2960 if (bs
->backing
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2964 if (bdrv_get_info(bs
, &bdi
) == 0) {
2965 return bdi
.can_write_zeroes_with_unmap
;
2971 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2973 if (bs
->backing
&& bs
->backing
->bs
->encrypted
)
2974 return bs
->backing_file
;
2975 else if (bs
->encrypted
)
2976 return bs
->filename
;
2981 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2982 char *filename
, int filename_size
)
2984 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2987 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2989 BlockDriver
*drv
= bs
->drv
;
2992 if (!drv
->bdrv_get_info
)
2994 memset(bdi
, 0, sizeof(*bdi
));
2995 return drv
->bdrv_get_info(bs
, bdi
);
2998 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3000 BlockDriver
*drv
= bs
->drv
;
3001 if (drv
&& drv
->bdrv_get_specific_info
) {
3002 return drv
->bdrv_get_specific_info(bs
);
3007 void bdrv_debug_event(BlockDriverState
*bs
, BlkdebugEvent event
)
3009 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3013 bs
->drv
->bdrv_debug_event(bs
, event
);
3016 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3019 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3020 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3023 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3024 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3030 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3032 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3033 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3036 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3037 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3043 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3045 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3046 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3049 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3050 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3056 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3058 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3059 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3062 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3063 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3069 int bdrv_is_snapshot(BlockDriverState
*bs
)
3071 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3074 /* backing_file can either be relative, or absolute, or a protocol. If it is
3075 * relative, it must be relative to the chain. So, passing in bs->filename
3076 * from a BDS as backing_file should not be done, as that may be relative to
3077 * the CWD rather than the chain. */
3078 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3079 const char *backing_file
)
3081 char *filename_full
= NULL
;
3082 char *backing_file_full
= NULL
;
3083 char *filename_tmp
= NULL
;
3084 int is_protocol
= 0;
3085 BlockDriverState
*curr_bs
= NULL
;
3086 BlockDriverState
*retval
= NULL
;
3088 if (!bs
|| !bs
->drv
|| !backing_file
) {
3092 filename_full
= g_malloc(PATH_MAX
);
3093 backing_file_full
= g_malloc(PATH_MAX
);
3094 filename_tmp
= g_malloc(PATH_MAX
);
3096 is_protocol
= path_has_protocol(backing_file
);
3098 for (curr_bs
= bs
; curr_bs
->backing
; curr_bs
= curr_bs
->backing
->bs
) {
3100 /* If either of the filename paths is actually a protocol, then
3101 * compare unmodified paths; otherwise make paths relative */
3102 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3103 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3104 retval
= curr_bs
->backing
->bs
;
3108 /* If not an absolute filename path, make it relative to the current
3109 * image's filename path */
3110 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3113 /* We are going to compare absolute pathnames */
3114 if (!realpath(filename_tmp
, filename_full
)) {
3118 /* We need to make sure the backing filename we are comparing against
3119 * is relative to the current image filename (or absolute) */
3120 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3121 curr_bs
->backing_file
);
3123 if (!realpath(filename_tmp
, backing_file_full
)) {
3127 if (strcmp(backing_file_full
, filename_full
) == 0) {
3128 retval
= curr_bs
->backing
->bs
;
3134 g_free(filename_full
);
3135 g_free(backing_file_full
);
3136 g_free(filename_tmp
);
3140 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3150 return 1 + bdrv_get_backing_file_depth(bs
->backing
->bs
);
3153 void bdrv_init(void)
3155 module_call_init(MODULE_INIT_BLOCK
);
3158 void bdrv_init_with_whitelist(void)
3160 use_bdrv_whitelist
= 1;
3164 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3166 Error
*local_err
= NULL
;
3173 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3176 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3178 if (bs
->drv
->bdrv_invalidate_cache
) {
3179 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3180 } else if (bs
->file
) {
3181 bdrv_invalidate_cache(bs
->file
->bs
, &local_err
);
3184 error_propagate(errp
, local_err
);
3188 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3190 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3195 void bdrv_invalidate_cache_all(Error
**errp
)
3197 BlockDriverState
*bs
;
3198 Error
*local_err
= NULL
;
3200 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3201 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3203 aio_context_acquire(aio_context
);
3204 bdrv_invalidate_cache(bs
, &local_err
);
3205 aio_context_release(aio_context
);
3207 error_propagate(errp
, local_err
);
3213 /**************************************************************/
3214 /* removable device support */
3217 * Return TRUE if the media is present
3219 bool bdrv_is_inserted(BlockDriverState
*bs
)
3221 BlockDriver
*drv
= bs
->drv
;
3227 if (drv
->bdrv_is_inserted
) {
3228 return drv
->bdrv_is_inserted(bs
);
3230 QLIST_FOREACH(child
, &bs
->children
, next
) {
3231 if (!bdrv_is_inserted(child
->bs
)) {
3239 * Return whether the media changed since the last call to this
3240 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3242 int bdrv_media_changed(BlockDriverState
*bs
)
3244 BlockDriver
*drv
= bs
->drv
;
3246 if (drv
&& drv
->bdrv_media_changed
) {
3247 return drv
->bdrv_media_changed(bs
);
3253 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3255 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3257 BlockDriver
*drv
= bs
->drv
;
3258 const char *device_name
;
3260 if (drv
&& drv
->bdrv_eject
) {
3261 drv
->bdrv_eject(bs
, eject_flag
);
3264 device_name
= bdrv_get_device_name(bs
);
3265 if (device_name
[0] != '\0') {
3266 qapi_event_send_device_tray_moved(device_name
,
3267 eject_flag
, &error_abort
);
3272 * Lock or unlock the media (if it is locked, the user won't be able
3273 * to eject it manually).
3275 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3277 BlockDriver
*drv
= bs
->drv
;
3279 trace_bdrv_lock_medium(bs
, locked
);
3281 if (drv
&& drv
->bdrv_lock_medium
) {
3282 drv
->bdrv_lock_medium(bs
, locked
);
3286 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3288 BdrvDirtyBitmap
*bm
;
3291 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3292 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3299 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3301 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3302 g_free(bitmap
->name
);
3303 bitmap
->name
= NULL
;
3306 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3307 uint32_t granularity
,
3311 int64_t bitmap_size
;
3312 BdrvDirtyBitmap
*bitmap
;
3313 uint32_t sector_granularity
;
3315 assert((granularity
& (granularity
- 1)) == 0);
3317 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3318 error_setg(errp
, "Bitmap already exists: %s", name
);
3321 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3322 assert(sector_granularity
);
3323 bitmap_size
= bdrv_nb_sectors(bs
);
3324 if (bitmap_size
< 0) {
3325 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3326 errno
= -bitmap_size
;
3329 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3330 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3331 bitmap
->size
= bitmap_size
;
3332 bitmap
->name
= g_strdup(name
);
3333 bitmap
->disabled
= false;
3334 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3338 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3340 return bitmap
->successor
;
3343 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3345 return !(bitmap
->disabled
|| bitmap
->successor
);
3348 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3350 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3351 return DIRTY_BITMAP_STATUS_FROZEN
;
3352 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3353 return DIRTY_BITMAP_STATUS_DISABLED
;
3355 return DIRTY_BITMAP_STATUS_ACTIVE
;
3360 * Create a successor bitmap destined to replace this bitmap after an operation.
3361 * Requires that the bitmap is not frozen and has no successor.
3363 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3364 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3366 uint64_t granularity
;
3367 BdrvDirtyBitmap
*child
;
3369 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3370 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3371 "currently frozen");
3374 assert(!bitmap
->successor
);
3376 /* Create an anonymous successor */
3377 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3378 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3383 /* Successor will be on or off based on our current state. */
3384 child
->disabled
= bitmap
->disabled
;
3386 /* Install the successor and freeze the parent */
3387 bitmap
->successor
= child
;
3392 * For a bitmap with a successor, yield our name to the successor,
3393 * delete the old bitmap, and return a handle to the new bitmap.
3395 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3396 BdrvDirtyBitmap
*bitmap
,
3400 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3402 if (successor
== NULL
) {
3403 error_setg(errp
, "Cannot relinquish control if "
3404 "there's no successor present");
3408 name
= bitmap
->name
;
3409 bitmap
->name
= NULL
;
3410 successor
->name
= name
;
3411 bitmap
->successor
= NULL
;
3412 bdrv_release_dirty_bitmap(bs
, bitmap
);
3418 * In cases of failure where we can no longer safely delete the parent,
3419 * we may wish to re-join the parent and child/successor.
3420 * The merged parent will be un-frozen, but not explicitly re-enabled.
3422 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3423 BdrvDirtyBitmap
*parent
,
3426 BdrvDirtyBitmap
*successor
= parent
->successor
;
3429 error_setg(errp
, "Cannot reclaim a successor when none is present");
3433 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3434 error_setg(errp
, "Merging of parent and successor bitmap failed");
3437 bdrv_release_dirty_bitmap(bs
, successor
);
3438 parent
->successor
= NULL
;
3444 * Truncates _all_ bitmaps attached to a BDS.
3446 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3448 BdrvDirtyBitmap
*bitmap
;
3449 uint64_t size
= bdrv_nb_sectors(bs
);
3451 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3452 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3453 hbitmap_truncate(bitmap
->bitmap
, size
);
3454 bitmap
->size
= size
;
3458 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3460 BdrvDirtyBitmap
*bm
, *next
;
3461 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3463 assert(!bdrv_dirty_bitmap_frozen(bm
));
3464 QLIST_REMOVE(bitmap
, list
);
3465 hbitmap_free(bitmap
->bitmap
);
3466 g_free(bitmap
->name
);
3473 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3475 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3476 bitmap
->disabled
= true;
3479 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3481 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3482 bitmap
->disabled
= false;
3485 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3487 BdrvDirtyBitmap
*bm
;
3488 BlockDirtyInfoList
*list
= NULL
;
3489 BlockDirtyInfoList
**plist
= &list
;
3491 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3492 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3493 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3494 info
->count
= bdrv_get_dirty_count(bm
);
3495 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3496 info
->has_name
= !!bm
->name
;
3497 info
->name
= g_strdup(bm
->name
);
3498 info
->status
= bdrv_dirty_bitmap_status(bm
);
3499 entry
->value
= info
;
3501 plist
= &entry
->next
;
3507 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3510 return hbitmap_get(bitmap
->bitmap
, sector
);
3517 * Chooses a default granularity based on the existing cluster size,
3518 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3519 * is no cluster size information available.
3521 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3523 BlockDriverInfo bdi
;
3524 uint32_t granularity
;
3526 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3527 granularity
= MAX(4096, bdi
.cluster_size
);
3528 granularity
= MIN(65536, granularity
);
3530 granularity
= 65536;
3536 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3538 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3541 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3543 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3546 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3547 int64_t cur_sector
, int nr_sectors
)
3549 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3550 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3553 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3554 int64_t cur_sector
, int nr_sectors
)
3556 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3557 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3560 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
**out
)
3562 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3564 hbitmap_reset_all(bitmap
->bitmap
);
3566 HBitmap
*backup
= bitmap
->bitmap
;
3567 bitmap
->bitmap
= hbitmap_alloc(bitmap
->size
,
3568 hbitmap_granularity(backup
));
3573 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
, HBitmap
*in
)
3575 HBitmap
*tmp
= bitmap
->bitmap
;
3576 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3577 bitmap
->bitmap
= in
;
3581 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3584 BdrvDirtyBitmap
*bitmap
;
3585 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3586 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3589 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3594 * Advance an HBitmapIter to an arbitrary offset.
3596 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3599 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3602 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3604 return hbitmap_count(bitmap
->bitmap
);
3607 /* Get a reference to bs */
3608 void bdrv_ref(BlockDriverState
*bs
)
3613 /* Release a previously grabbed reference to bs.
3614 * If after releasing, reference count is zero, the BlockDriverState is
3616 void bdrv_unref(BlockDriverState
*bs
)
3621 assert(bs
->refcnt
> 0);
3622 if (--bs
->refcnt
== 0) {
3627 struct BdrvOpBlocker
{
3629 QLIST_ENTRY(BdrvOpBlocker
) list
;
3632 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3634 BdrvOpBlocker
*blocker
;
3635 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3636 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3637 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3639 error_setg(errp
, "Node '%s' is busy: %s",
3640 bdrv_get_device_or_node_name(bs
),
3641 error_get_pretty(blocker
->reason
));
3648 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3650 BdrvOpBlocker
*blocker
;
3651 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3653 blocker
= g_new0(BdrvOpBlocker
, 1);
3654 blocker
->reason
= reason
;
3655 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3658 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3660 BdrvOpBlocker
*blocker
, *next
;
3661 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3662 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3663 if (blocker
->reason
== reason
) {
3664 QLIST_REMOVE(blocker
, list
);
3670 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3673 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3674 bdrv_op_block(bs
, i
, reason
);
3678 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3681 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3682 bdrv_op_unblock(bs
, i
, reason
);
3686 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3690 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3691 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3698 void bdrv_img_create(const char *filename
, const char *fmt
,
3699 const char *base_filename
, const char *base_fmt
,
3700 char *options
, uint64_t img_size
, int flags
,
3701 Error
**errp
, bool quiet
)
3703 QemuOptsList
*create_opts
= NULL
;
3704 QemuOpts
*opts
= NULL
;
3705 const char *backing_fmt
, *backing_file
;
3707 BlockDriver
*drv
, *proto_drv
;
3708 Error
*local_err
= NULL
;
3711 /* Find driver and parse its options */
3712 drv
= bdrv_find_format(fmt
);
3714 error_setg(errp
, "Unknown file format '%s'", fmt
);
3718 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3723 if (!drv
->create_opts
) {
3724 error_setg(errp
, "Format driver '%s' does not support image creation",
3729 if (!proto_drv
->create_opts
) {
3730 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3731 proto_drv
->format_name
);
3735 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3736 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3738 /* Create parameter list with default values */
3739 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3740 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3742 /* Parse -o options */
3744 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3746 error_report_err(local_err
);
3748 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3753 if (base_filename
) {
3754 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3756 error_setg(errp
, "Backing file not supported for file format '%s'",
3763 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3765 error_setg(errp
, "Backing file format not supported for file "
3766 "format '%s'", fmt
);
3771 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3773 if (!strcmp(filename
, backing_file
)) {
3774 error_setg(errp
, "Error: Trying to create an image with the "
3775 "same filename as the backing file");
3780 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3782 // The size for the image must always be specified, with one exception:
3783 // If we are using a backing file, we can obtain the size from there
3784 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3787 BlockDriverState
*bs
;
3788 char *full_backing
= g_new0(char, PATH_MAX
);
3791 QDict
*backing_options
= NULL
;
3793 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3794 full_backing
, PATH_MAX
,
3797 g_free(full_backing
);
3801 /* backing files always opened read-only */
3803 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3806 backing_options
= qdict_new();
3807 qdict_put(backing_options
, "driver",
3808 qstring_from_str(backing_fmt
));
3812 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3813 back_flags
, &local_err
);
3814 g_free(full_backing
);
3818 size
= bdrv_getlength(bs
);
3820 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3826 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3830 error_setg(errp
, "Image creation needs a size parameter");
3836 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3837 qemu_opts_print(opts
, " ");
3841 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3843 if (ret
== -EFBIG
) {
3844 /* This is generally a better message than whatever the driver would
3845 * deliver (especially because of the cluster_size_hint), since that
3846 * is most probably not much different from "image too large". */
3847 const char *cluster_size_hint
= "";
3848 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3849 cluster_size_hint
= " (try using a larger cluster size)";
3851 error_setg(errp
, "The image size is too large for file format '%s'"
3852 "%s", fmt
, cluster_size_hint
);
3853 error_free(local_err
);
3858 qemu_opts_del(opts
);
3859 qemu_opts_free(create_opts
);
3861 error_propagate(errp
, local_err
);
3865 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3867 return bs
->aio_context
;
3870 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3872 BdrvAioNotifier
*baf
;
3878 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3879 baf
->detach_aio_context(baf
->opaque
);
3882 if (bs
->throttle_state
) {
3883 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3885 if (bs
->drv
->bdrv_detach_aio_context
) {
3886 bs
->drv
->bdrv_detach_aio_context(bs
);
3889 bdrv_detach_aio_context(bs
->file
->bs
);
3892 bdrv_detach_aio_context(bs
->backing
->bs
);
3895 bs
->aio_context
= NULL
;
3898 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3899 AioContext
*new_context
)
3901 BdrvAioNotifier
*ban
;
3907 bs
->aio_context
= new_context
;
3910 bdrv_attach_aio_context(bs
->backing
->bs
, new_context
);
3913 bdrv_attach_aio_context(bs
->file
->bs
, new_context
);
3915 if (bs
->drv
->bdrv_attach_aio_context
) {
3916 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3918 if (bs
->throttle_state
) {
3919 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3922 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3923 ban
->attached_aio_context(new_context
, ban
->opaque
);
3927 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3929 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3931 bdrv_detach_aio_context(bs
);
3933 /* This function executes in the old AioContext so acquire the new one in
3934 * case it runs in a different thread.
3936 aio_context_acquire(new_context
);
3937 bdrv_attach_aio_context(bs
, new_context
);
3938 aio_context_release(new_context
);
3941 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3942 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3943 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3945 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3946 *ban
= (BdrvAioNotifier
){
3947 .attached_aio_context
= attached_aio_context
,
3948 .detach_aio_context
= detach_aio_context
,
3952 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3955 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3956 void (*attached_aio_context
)(AioContext
*,
3958 void (*detach_aio_context
)(void *),
3961 BdrvAioNotifier
*ban
, *ban_next
;
3963 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3964 if (ban
->attached_aio_context
== attached_aio_context
&&
3965 ban
->detach_aio_context
== detach_aio_context
&&
3966 ban
->opaque
== opaque
)
3968 QLIST_REMOVE(ban
, list
);
3978 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3979 BlockDriverAmendStatusCB
*status_cb
)
3981 if (!bs
->drv
->bdrv_amend_options
) {
3984 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3987 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3988 * of block filter and by bdrv_is_first_non_filter.
3989 * It is used to test if the given bs is the candidate or recurse more in the
3992 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3993 BlockDriverState
*candidate
)
3995 /* return false if basic checks fails */
3996 if (!bs
|| !bs
->drv
) {
4000 /* the code reached a non block filter driver -> check if the bs is
4001 * the same as the candidate. It's the recursion termination condition.
4003 if (!bs
->drv
->is_filter
) {
4004 return bs
== candidate
;
4006 /* Down this path the driver is a block filter driver */
4008 /* If the block filter recursion method is defined use it to recurse down
4011 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4012 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4015 /* the driver is a block filter but don't allow to recurse -> return false
4020 /* This function checks if the candidate is the first non filter bs down it's
4021 * bs chain. Since we don't have pointers to parents it explore all bs chains
4022 * from the top. Some filters can choose not to pass down the recursion.
4024 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4026 BlockDriverState
*bs
;
4028 /* walk down the bs forest recursively */
4029 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4032 /* try to recurse in this top level bs */
4033 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4035 /* candidate is the first non filter */
4044 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
4045 const char *node_name
, Error
**errp
)
4047 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4048 AioContext
*aio_context
;
4050 if (!to_replace_bs
) {
4051 error_setg(errp
, "Node name '%s' not found", node_name
);
4055 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4056 aio_context_acquire(aio_context
);
4058 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4059 to_replace_bs
= NULL
;
4063 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4064 * most non filter in order to prevent data corruption.
4065 * Another benefit is that this tests exclude backing files which are
4066 * blocked by the backing blockers.
4068 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
4069 error_setg(errp
, "Only top most non filter can be replaced");
4070 to_replace_bs
= NULL
;
4075 aio_context_release(aio_context
);
4076 return to_replace_bs
;
4079 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4081 const QDictEntry
*entry
;
4084 bool found_any
= false;
4087 for (entry
= qdict_first(bs
->options
); entry
;
4088 entry
= qdict_next(bs
->options
, entry
))
4090 /* Exclude options for children */
4091 QLIST_FOREACH(child
, &bs
->children
, next
) {
4092 if (strstart(qdict_entry_key(entry
), child
->name
, &p
)
4093 && (!*p
|| *p
== '.'))
4102 /* And exclude all non-driver-specific options */
4103 for (desc
= bdrv_runtime_opts
.desc
; desc
->name
; desc
++) {
4104 if (!strcmp(qdict_entry_key(entry
), desc
->name
)) {
4112 qobject_incref(qdict_entry_value(entry
));
4113 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4120 /* Updates the following BDS fields:
4121 * - exact_filename: A filename which may be used for opening a block device
4122 * which (mostly) equals the given BDS (even without any
4123 * other options; so reading and writing must return the same
4124 * results, but caching etc. may be different)
4125 * - full_open_options: Options which, when given when opening a block device
4126 * (without a filename), result in a BDS (mostly)
4127 * equalling the given one
4128 * - filename: If exact_filename is set, it is copied here. Otherwise,
4129 * full_open_options is converted to a JSON object, prefixed with
4130 * "json:" (for use through the JSON pseudo protocol) and put here.
4132 void bdrv_refresh_filename(BlockDriverState
*bs
)
4134 BlockDriver
*drv
= bs
->drv
;
4141 /* This BDS's file name will most probably depend on its file's name, so
4142 * refresh that first */
4144 bdrv_refresh_filename(bs
->file
->bs
);
4147 if (drv
->bdrv_refresh_filename
) {
4148 /* Obsolete information is of no use here, so drop the old file name
4149 * information before refreshing it */
4150 bs
->exact_filename
[0] = '\0';
4151 if (bs
->full_open_options
) {
4152 QDECREF(bs
->full_open_options
);
4153 bs
->full_open_options
= NULL
;
4157 append_open_options(opts
, bs
);
4158 drv
->bdrv_refresh_filename(bs
, opts
);
4160 } else if (bs
->file
) {
4161 /* Try to reconstruct valid information from the underlying file */
4162 bool has_open_options
;
4164 bs
->exact_filename
[0] = '\0';
4165 if (bs
->full_open_options
) {
4166 QDECREF(bs
->full_open_options
);
4167 bs
->full_open_options
= NULL
;
4171 has_open_options
= append_open_options(opts
, bs
);
4173 /* If no specific options have been given for this BDS, the filename of
4174 * the underlying file should suffice for this one as well */
4175 if (bs
->file
->bs
->exact_filename
[0] && !has_open_options
) {
4176 strcpy(bs
->exact_filename
, bs
->file
->bs
->exact_filename
);
4178 /* Reconstructing the full options QDict is simple for most format block
4179 * drivers, as long as the full options are known for the underlying
4180 * file BDS. The full options QDict of that file BDS should somehow
4181 * contain a representation of the filename, therefore the following
4182 * suffices without querying the (exact_)filename of this BDS. */
4183 if (bs
->file
->bs
->full_open_options
) {
4184 qdict_put_obj(opts
, "driver",
4185 QOBJECT(qstring_from_str(drv
->format_name
)));
4186 QINCREF(bs
->file
->bs
->full_open_options
);
4187 qdict_put_obj(opts
, "file",
4188 QOBJECT(bs
->file
->bs
->full_open_options
));
4190 bs
->full_open_options
= opts
;
4194 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4195 /* There is no underlying file BDS (at least referenced by BDS.file),
4196 * so the full options QDict should be equal to the options given
4197 * specifically for this block device when it was opened (plus the
4198 * driver specification).
4199 * Because those options don't change, there is no need to update
4200 * full_open_options when it's already set. */
4203 append_open_options(opts
, bs
);
4204 qdict_put_obj(opts
, "driver",
4205 QOBJECT(qstring_from_str(drv
->format_name
)));
4207 if (bs
->exact_filename
[0]) {
4208 /* This may not work for all block protocol drivers (some may
4209 * require this filename to be parsed), but we have to find some
4210 * default solution here, so just include it. If some block driver
4211 * does not support pure options without any filename at all or
4212 * needs some special format of the options QDict, it needs to
4213 * implement the driver-specific bdrv_refresh_filename() function.
4215 qdict_put_obj(opts
, "filename",
4216 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4219 bs
->full_open_options
= opts
;
4222 if (bs
->exact_filename
[0]) {
4223 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4224 } else if (bs
->full_open_options
) {
4225 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4226 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4227 qstring_get_str(json
));