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/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
39 #include "block/throttle-groups.h"
42 #include <sys/types.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
56 * A BdrvDirtyBitmap can be in three possible states:
57 * (1) successor is NULL and disabled is false: full r/w mode
58 * (2) successor is NULL and disabled is true: read only mode ("disabled")
59 * (3) successor is set: frozen mode.
60 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
61 * or enabled. A frozen bitmap can only abdicate() or reclaim().
63 struct BdrvDirtyBitmap
{
64 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
65 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
66 char *name
; /* Optional non-empty unique ID */
67 int64_t size
; /* Size of the bitmap (Number of sectors) */
68 bool disabled
; /* Bitmap is read-only */
69 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
72 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
74 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
75 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
77 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
78 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
80 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
81 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
83 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
84 const char *reference
, QDict
*options
, int flags
,
85 BlockDriverState
*parent
,
86 const BdrvChildRole
*child_role
,
87 BlockDriver
*drv
, 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 bdrv_iostatus_disable(bs
);
260 notifier_list_init(&bs
->close_notifiers
);
261 notifier_with_return_list_init(&bs
->before_write_notifiers
);
262 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
263 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
265 bs
->aio_context
= qemu_get_aio_context();
270 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
272 notifier_list_add(&bs
->close_notifiers
, notify
);
275 BlockDriver
*bdrv_find_format(const char *format_name
)
278 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
279 if (!strcmp(drv1
->format_name
, format_name
)) {
286 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
288 static const char *whitelist_rw
[] = {
289 CONFIG_BDRV_RW_WHITELIST
291 static const char *whitelist_ro
[] = {
292 CONFIG_BDRV_RO_WHITELIST
296 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
297 return 1; /* no whitelist, anything goes */
300 for (p
= whitelist_rw
; *p
; p
++) {
301 if (!strcmp(drv
->format_name
, *p
)) {
306 for (p
= whitelist_ro
; *p
; p
++) {
307 if (!strcmp(drv
->format_name
, *p
)) {
315 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
318 BlockDriver
*drv
= bdrv_find_format(format_name
);
319 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
322 typedef struct CreateCo
{
330 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
332 Error
*local_err
= NULL
;
335 CreateCo
*cco
= opaque
;
338 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
340 error_propagate(&cco
->err
, local_err
);
345 int bdrv_create(BlockDriver
*drv
, const char* filename
,
346 QemuOpts
*opts
, Error
**errp
)
353 .filename
= g_strdup(filename
),
359 if (!drv
->bdrv_create
) {
360 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
365 if (qemu_in_coroutine()) {
366 /* Fast-path if already in coroutine context */
367 bdrv_create_co_entry(&cco
);
369 co
= qemu_coroutine_create(bdrv_create_co_entry
);
370 qemu_coroutine_enter(co
, &cco
);
371 while (cco
.ret
== NOT_DONE
) {
372 aio_poll(qemu_get_aio_context(), true);
379 error_propagate(errp
, cco
.err
);
381 error_setg_errno(errp
, -ret
, "Could not create image");
386 g_free(cco
.filename
);
390 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
393 Error
*local_err
= NULL
;
396 drv
= bdrv_find_protocol(filename
, true, errp
);
401 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
403 error_propagate(errp
, local_err
);
409 * Try to get @bs's logical and physical block size.
410 * On success, store them in @bsz struct and return 0.
411 * On failure return -errno.
412 * @bs must not be empty.
414 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
416 BlockDriver
*drv
= bs
->drv
;
418 if (drv
&& drv
->bdrv_probe_blocksizes
) {
419 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
426 * Try to get @bs's geometry (cyls, heads, sectors).
427 * On success, store them in @geo struct and return 0.
428 * On failure return -errno.
429 * @bs must not be empty.
431 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
433 BlockDriver
*drv
= bs
->drv
;
435 if (drv
&& drv
->bdrv_probe_geometry
) {
436 return drv
->bdrv_probe_geometry(bs
, geo
);
443 * Create a uniquely-named empty temporary file.
444 * Return 0 upon success, otherwise a negative errno value.
446 int get_tmp_filename(char *filename
, int size
)
449 char temp_dir
[MAX_PATH
];
450 /* GetTempFileName requires that its output buffer (4th param)
451 have length MAX_PATH or greater. */
452 assert(size
>= MAX_PATH
);
453 return (GetTempPath(MAX_PATH
, temp_dir
)
454 && GetTempFileName(temp_dir
, "qem", 0, filename
)
455 ? 0 : -GetLastError());
459 tmpdir
= getenv("TMPDIR");
463 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
466 fd
= mkstemp(filename
);
470 if (close(fd
) != 0) {
479 * Detect host devices. By convention, /dev/cdrom[N] is always
480 * recognized as a host CDROM.
482 static BlockDriver
*find_hdev_driver(const char *filename
)
484 int score_max
= 0, score
;
485 BlockDriver
*drv
= NULL
, *d
;
487 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
488 if (d
->bdrv_probe_device
) {
489 score
= d
->bdrv_probe_device(filename
);
490 if (score
> score_max
) {
500 BlockDriver
*bdrv_find_protocol(const char *filename
,
501 bool allow_protocol_prefix
,
509 /* TODO Drivers without bdrv_file_open must be specified explicitly */
512 * XXX(hch): we really should not let host device detection
513 * override an explicit protocol specification, but moving this
514 * later breaks access to device names with colons in them.
515 * Thanks to the brain-dead persistent naming schemes on udev-
516 * based Linux systems those actually are quite common.
518 drv1
= find_hdev_driver(filename
);
523 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
527 p
= strchr(filename
, ':');
530 if (len
> sizeof(protocol
) - 1)
531 len
= sizeof(protocol
) - 1;
532 memcpy(protocol
, filename
, len
);
533 protocol
[len
] = '\0';
534 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
535 if (drv1
->protocol_name
&&
536 !strcmp(drv1
->protocol_name
, protocol
)) {
541 error_setg(errp
, "Unknown protocol '%s'", protocol
);
546 * Guess image format by probing its contents.
547 * This is not a good idea when your image is raw (CVE-2008-2004), but
548 * we do it anyway for backward compatibility.
550 * @buf contains the image's first @buf_size bytes.
551 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
552 * but can be smaller if the image file is smaller)
553 * @filename is its filename.
555 * For all block drivers, call the bdrv_probe() method to get its
557 * Return the first block driver with the highest probing score.
559 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
560 const char *filename
)
562 int score_max
= 0, score
;
563 BlockDriver
*drv
= NULL
, *d
;
565 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
567 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
568 if (score
> score_max
) {
578 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
579 BlockDriver
**pdrv
, Error
**errp
)
582 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
585 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
586 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
591 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
593 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
599 drv
= bdrv_probe_all(buf
, ret
, filename
);
601 error_setg(errp
, "Could not determine image format: No compatible "
610 * Set the current 'total_sectors' value
611 * Return 0 on success, -errno on error.
613 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
615 BlockDriver
*drv
= bs
->drv
;
617 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
621 /* query actual device if possible, otherwise just trust the hint */
622 if (drv
->bdrv_getlength
) {
623 int64_t length
= drv
->bdrv_getlength(bs
);
627 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
630 bs
->total_sectors
= hint
;
635 * Set open flags for a given discard mode
637 * Return 0 on success, -1 if the discard mode was invalid.
639 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
641 *flags
&= ~BDRV_O_UNMAP
;
643 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
645 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
646 *flags
|= BDRV_O_UNMAP
;
655 * Set open flags for a given cache mode
657 * Return 0 on success, -1 if the cache mode was invalid.
659 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
661 *flags
&= ~BDRV_O_CACHE_MASK
;
663 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
664 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
665 } else if (!strcmp(mode
, "directsync")) {
666 *flags
|= BDRV_O_NOCACHE
;
667 } else if (!strcmp(mode
, "writeback")) {
668 *flags
|= BDRV_O_CACHE_WB
;
669 } else if (!strcmp(mode
, "unsafe")) {
670 *flags
|= BDRV_O_CACHE_WB
;
671 *flags
|= BDRV_O_NO_FLUSH
;
672 } else if (!strcmp(mode
, "writethrough")) {
673 /* this is the default */
682 * Returns the flags that a temporary snapshot should get, based on the
683 * originally requested flags (the originally requested image will have flags
684 * like a backing file)
686 static int bdrv_temp_snapshot_flags(int flags
)
688 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
692 * Returns the flags that bs->file should get if a protocol driver is expected,
693 * based on the given flags for the parent BDS
695 static int bdrv_inherited_flags(int flags
)
697 /* Enable protocol handling, disable format probing for bs->file */
698 flags
|= BDRV_O_PROTOCOL
;
700 /* Our block drivers take care to send flushes and respect unmap policy,
701 * so we can enable both unconditionally on lower layers. */
702 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
704 /* Clear flags that only apply to the top layer */
705 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
710 const BdrvChildRole child_file
= {
711 .inherit_flags
= bdrv_inherited_flags
,
715 * Returns the flags that bs->file should get if the use of formats (and not
716 * only protocols) is permitted for it, based on the given flags for the parent
719 static int bdrv_inherited_fmt_flags(int parent_flags
)
721 int flags
= child_file
.inherit_flags(parent_flags
);
722 return flags
& ~BDRV_O_PROTOCOL
;
725 const BdrvChildRole child_format
= {
726 .inherit_flags
= bdrv_inherited_fmt_flags
,
730 * Returns the flags that bs->backing_hd should get, based on the given flags
733 static int bdrv_backing_flags(int flags
)
735 /* backing files always opened read-only */
736 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
738 /* snapshot=on is handled on the top layer */
739 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
744 static const BdrvChildRole child_backing
= {
745 .inherit_flags
= bdrv_backing_flags
,
748 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
750 int open_flags
= flags
| BDRV_O_CACHE_WB
;
753 * Clear flags that are internal to the block layer before opening the
756 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
759 * Snapshots should be writable.
761 if (flags
& BDRV_O_TEMPORARY
) {
762 open_flags
|= BDRV_O_RDWR
;
768 static void bdrv_assign_node_name(BlockDriverState
*bs
,
769 const char *node_name
,
776 /* Check for empty string or invalid characters */
777 if (!id_wellformed(node_name
)) {
778 error_setg(errp
, "Invalid node name");
782 /* takes care of avoiding namespaces collisions */
783 if (blk_by_name(node_name
)) {
784 error_setg(errp
, "node-name=%s is conflicting with a device id",
789 /* takes care of avoiding duplicates node names */
790 if (bdrv_find_node(node_name
)) {
791 error_setg(errp
, "Duplicate node name");
795 /* copy node name into the bs and insert it into the graph list */
796 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
797 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
800 static QemuOptsList bdrv_runtime_opts
= {
801 .name
= "bdrv_common",
802 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
806 .type
= QEMU_OPT_STRING
,
807 .help
= "Node name of the block device node",
809 { /* end of list */ }
814 * Common part for opening disk images and files
816 * Removes all processed options from *options.
818 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
819 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
822 const char *filename
;
823 const char *node_name
= NULL
;
825 Error
*local_err
= NULL
;
828 assert(bs
->file
== NULL
);
829 assert(options
!= NULL
&& bs
->options
!= options
);
832 filename
= file
->filename
;
834 filename
= qdict_get_try_str(options
, "filename");
837 if (drv
->bdrv_needs_filename
&& !filename
) {
838 error_setg(errp
, "The '%s' block driver requires a file name",
843 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
845 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
846 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
848 error_propagate(errp
, local_err
);
853 node_name
= qemu_opt_get(opts
, "node-name");
854 bdrv_assign_node_name(bs
, node_name
, &local_err
);
856 error_propagate(errp
, local_err
);
861 bs
->guest_block_size
= 512;
862 bs
->request_alignment
= 512;
863 bs
->zero_beyond_eof
= true;
864 open_flags
= bdrv_open_flags(bs
, flags
);
865 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
867 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
869 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
870 ? "Driver '%s' can only be used for read-only devices"
871 : "Driver '%s' is not whitelisted",
877 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
878 if (flags
& BDRV_O_COPY_ON_READ
) {
879 if (!bs
->read_only
) {
880 bdrv_enable_copy_on_read(bs
);
882 error_setg(errp
, "Can't use copy-on-read on read-only device");
888 if (filename
!= NULL
) {
889 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
891 bs
->filename
[0] = '\0';
893 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
896 bs
->opaque
= g_malloc0(drv
->instance_size
);
898 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
900 /* Open the image, either directly or using a protocol */
901 if (drv
->bdrv_file_open
) {
902 assert(file
== NULL
);
903 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
904 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
907 error_setg(errp
, "Can't use '%s' as a block driver for the "
908 "protocol level", drv
->format_name
);
913 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
918 error_propagate(errp
, local_err
);
919 } else if (bs
->filename
[0]) {
920 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
922 error_setg_errno(errp
, -ret
, "Could not open image");
928 error_report("Encrypted images are deprecated");
929 error_printf("Support for them will be removed in a future release.\n"
930 "You can use 'qemu-img convert' to convert your image"
931 " to an unencrypted one.\n");
934 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
936 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
940 bdrv_refresh_limits(bs
, &local_err
);
942 error_propagate(errp
, local_err
);
947 assert(bdrv_opt_mem_align(bs
) != 0);
948 assert(bdrv_min_mem_align(bs
) != 0);
949 assert((bs
->request_alignment
!= 0) || bs
->sg
);
964 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
966 QObject
*options_obj
;
970 ret
= strstart(filename
, "json:", &filename
);
973 options_obj
= qobject_from_json(filename
);
975 error_setg(errp
, "Could not parse the JSON options");
979 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
980 qobject_decref(options_obj
);
981 error_setg(errp
, "Invalid JSON object given");
985 options
= qobject_to_qdict(options_obj
);
986 qdict_flatten(options
);
992 * Fills in default options for opening images and converts the legacy
993 * filename/flags pair to option QDict entries.
994 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
995 * block driver has been specified explicitly.
997 static int bdrv_fill_options(QDict
**options
, const char **pfilename
,
998 int *flags
, BlockDriver
*drv
, Error
**errp
)
1000 const char *filename
= *pfilename
;
1001 const char *drvname
;
1002 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1003 bool parse_filename
= false;
1004 BlockDriver
*tmp_drv
;
1005 Error
*local_err
= NULL
;
1007 /* Parse json: pseudo-protocol */
1008 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1009 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1011 error_propagate(errp
, local_err
);
1015 /* Options given in the filename have lower priority than options
1016 * specified directly */
1017 qdict_join(*options
, json_options
, false);
1018 QDECREF(json_options
);
1019 *pfilename
= filename
= NULL
;
1022 drvname
= qdict_get_try_str(*options
, "driver");
1024 /* If the user has explicitly specified the driver, this choice should
1025 * override the BDRV_O_PROTOCOL flag */
1027 if (!tmp_drv
&& drvname
) {
1028 tmp_drv
= bdrv_find_format(drvname
);
1031 protocol
= tmp_drv
->bdrv_file_open
;
1035 *flags
|= BDRV_O_PROTOCOL
;
1037 *flags
&= ~BDRV_O_PROTOCOL
;
1040 /* Fetch the file name from the options QDict if necessary */
1041 if (protocol
&& filename
) {
1042 if (!qdict_haskey(*options
, "filename")) {
1043 qdict_put(*options
, "filename", qstring_from_str(filename
));
1044 parse_filename
= true;
1046 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1052 /* Find the right block driver */
1053 filename
= qdict_get_try_str(*options
, "filename");
1057 error_setg(errp
, "Driver specified twice");
1060 drvname
= drv
->format_name
;
1061 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1063 if (!drvname
&& protocol
) {
1065 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1070 drvname
= drv
->format_name
;
1071 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1073 error_setg(errp
, "Must specify either driver or file");
1076 } else if (drvname
) {
1077 drv
= bdrv_find_format(drvname
);
1079 error_setg(errp
, "Unknown driver '%s'", drvname
);
1085 assert(drv
|| !protocol
);
1087 /* Driver-specific filename parsing */
1088 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1089 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1091 error_propagate(errp
, local_err
);
1095 if (!drv
->bdrv_needs_filename
) {
1096 qdict_del(*options
, "filename");
1103 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1106 if (bs
->backing_hd
) {
1107 assert(bs
->backing_blocker
);
1108 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1109 } else if (backing_hd
) {
1110 error_setg(&bs
->backing_blocker
,
1111 "node is used as backing hd of '%s'",
1112 bdrv_get_device_or_node_name(bs
));
1115 bs
->backing_hd
= backing_hd
;
1117 error_free(bs
->backing_blocker
);
1118 bs
->backing_blocker
= NULL
;
1121 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1122 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1123 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1124 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1126 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1127 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1128 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1129 bs
->backing_blocker
);
1131 bdrv_refresh_limits(bs
, NULL
);
1135 * Opens the backing file for a BlockDriverState if not yet open
1137 * options is a QDict of options to pass to the block drivers, or NULL for an
1138 * empty set of options. The reference to the QDict is transferred to this
1139 * function (even on failure), so if the caller intends to reuse the dictionary,
1140 * it needs to use QINCREF() before calling bdrv_file_open.
1142 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1144 char *backing_filename
= g_malloc0(PATH_MAX
);
1146 BlockDriverState
*backing_hd
;
1147 Error
*local_err
= NULL
;
1149 if (bs
->backing_hd
!= NULL
) {
1154 /* NULL means an empty set of options */
1155 if (options
== NULL
) {
1156 options
= qdict_new();
1159 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1160 if (qdict_haskey(options
, "file.filename")) {
1161 backing_filename
[0] = '\0';
1162 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1166 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1170 error_propagate(errp
, local_err
);
1176 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1178 error_setg(errp
, "Driver doesn't support backing files");
1183 backing_hd
= bdrv_new();
1185 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1186 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1189 assert(bs
->backing_hd
== NULL
);
1190 ret
= bdrv_open_inherit(&backing_hd
,
1191 *backing_filename
? backing_filename
: NULL
,
1192 NULL
, options
, 0, bs
, &child_backing
,
1195 bdrv_unref(backing_hd
);
1197 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1198 error_setg(errp
, "Could not open backing file: %s",
1199 error_get_pretty(local_err
));
1200 error_free(local_err
);
1203 bdrv_set_backing_hd(bs
, backing_hd
);
1206 g_free(backing_filename
);
1211 * Opens a disk image whose options are given as BlockdevRef in another block
1214 * If allow_none is true, no image will be opened if filename is false and no
1215 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1217 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1218 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1219 * itself, all options starting with "${bdref_key}." are considered part of the
1222 * The BlockdevRef will be removed from the options QDict.
1224 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1226 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1227 QDict
*options
, const char *bdref_key
,
1228 BlockDriverState
* parent
, const BdrvChildRole
*child_role
,
1229 bool allow_none
, Error
**errp
)
1231 QDict
*image_options
;
1233 char *bdref_key_dot
;
1234 const char *reference
;
1237 assert(*pbs
== NULL
);
1239 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1240 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1241 g_free(bdref_key_dot
);
1243 reference
= qdict_get_try_str(options
, bdref_key
);
1244 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1248 error_setg(errp
, "A block device must be specified for \"%s\"",
1252 QDECREF(image_options
);
1256 ret
= bdrv_open_inherit(pbs
, filename
, reference
, image_options
, 0,
1257 parent
, child_role
, NULL
, errp
);
1260 qdict_del(options
, bdref_key
);
1264 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1266 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1267 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1269 QemuOpts
*opts
= NULL
;
1270 QDict
*snapshot_options
;
1271 BlockDriverState
*bs_snapshot
;
1275 /* if snapshot, we create a temporary backing file and open it
1276 instead of opening 'filename' directly */
1278 /* Get the required size from the image */
1279 total_size
= bdrv_getlength(bs
);
1280 if (total_size
< 0) {
1282 error_setg_errno(errp
, -total_size
, "Could not get image size");
1286 /* Create the temporary image */
1287 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1289 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1293 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1295 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1296 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1297 qemu_opts_del(opts
);
1299 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1300 "'%s': %s", tmp_filename
,
1301 error_get_pretty(local_err
));
1302 error_free(local_err
);
1306 /* Prepare a new options QDict for the temporary file */
1307 snapshot_options
= qdict_new();
1308 qdict_put(snapshot_options
, "file.driver",
1309 qstring_from_str("file"));
1310 qdict_put(snapshot_options
, "file.filename",
1311 qstring_from_str(tmp_filename
));
1313 bs_snapshot
= bdrv_new();
1315 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1316 flags
, &bdrv_qcow2
, &local_err
);
1318 error_propagate(errp
, local_err
);
1322 bdrv_append(bs_snapshot
, bs
);
1325 g_free(tmp_filename
);
1329 static void bdrv_attach_child(BlockDriverState
*parent_bs
,
1330 BlockDriverState
*child_bs
,
1331 const BdrvChildRole
*child_role
)
1333 BdrvChild
*child
= g_new(BdrvChild
, 1);
1334 *child
= (BdrvChild
) {
1339 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1343 * Opens a disk image (raw, qcow2, vmdk, ...)
1345 * options is a QDict of options to pass to the block drivers, or NULL for an
1346 * empty set of options. The reference to the QDict belongs to the block layer
1347 * after the call (even on failure), so if the caller intends to reuse the
1348 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1350 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1351 * If it is not NULL, the referenced BDS will be reused.
1353 * The reference parameter may be used to specify an existing block device which
1354 * should be opened. If specified, neither options nor a filename may be given,
1355 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1357 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1358 const char *reference
, QDict
*options
, int flags
,
1359 BlockDriverState
*parent
,
1360 const BdrvChildRole
*child_role
,
1361 BlockDriver
*drv
, Error
**errp
)
1364 BlockDriverState
*file
= NULL
, *bs
;
1365 const char *drvname
;
1366 Error
*local_err
= NULL
;
1367 int snapshot_flags
= 0;
1370 assert(!child_role
|| !flags
);
1371 assert(!child_role
== !parent
);
1374 bool options_non_empty
= options
? qdict_size(options
) : false;
1378 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1379 "another block device");
1383 if (filename
|| options_non_empty
) {
1384 error_setg(errp
, "Cannot reference an existing block device with "
1385 "additional options or a new filename");
1389 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1395 bdrv_attach_child(parent
, bs
, child_role
);
1407 /* NULL means an empty set of options */
1408 if (options
== NULL
) {
1409 options
= qdict_new();
1413 bs
->inherits_from
= parent
;
1414 flags
= child_role
->inherit_flags(parent
->open_flags
);
1417 ret
= bdrv_fill_options(&options
, &filename
, &flags
, drv
, &local_err
);
1422 /* Find the right image format driver */
1424 drvname
= qdict_get_try_str(options
, "driver");
1426 drv
= bdrv_find_format(drvname
);
1427 qdict_del(options
, "driver");
1429 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1435 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1437 bs
->open_flags
= flags
;
1438 bs
->options
= options
;
1439 options
= qdict_clone_shallow(options
);
1441 /* Open image file without format layer */
1442 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1443 if (flags
& BDRV_O_RDWR
) {
1444 flags
|= BDRV_O_ALLOW_RDWR
;
1446 if (flags
& BDRV_O_SNAPSHOT
) {
1447 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1448 flags
= bdrv_backing_flags(flags
);
1451 assert(file
== NULL
);
1452 bs
->open_flags
= flags
;
1453 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1454 bs
, &child_file
, true, &local_err
);
1460 /* Image format probing */
1463 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1468 error_setg(errp
, "Must specify either driver or file");
1473 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1474 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1475 /* file must be NULL if a protocol BDS is about to be created
1476 * (the inverse results in an error message from bdrv_open_common()) */
1477 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1479 /* Open the image */
1480 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1485 if (file
&& (bs
->file
!= file
)) {
1490 /* If there is a backing file, use it */
1491 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1492 QDict
*backing_options
;
1494 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1495 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1497 goto close_and_fail
;
1501 bdrv_refresh_filename(bs
);
1503 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1504 * temporary snapshot afterwards. */
1505 if (snapshot_flags
) {
1506 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1508 goto close_and_fail
;
1512 /* Check if any unknown options were used */
1513 if (options
&& (qdict_size(options
) != 0)) {
1514 const QDictEntry
*entry
= qdict_first(options
);
1515 if (flags
& BDRV_O_PROTOCOL
) {
1516 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1517 "'%s'", drv
->format_name
, entry
->key
);
1519 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1520 "support the option '%s'", drv
->format_name
,
1521 bdrv_get_device_name(bs
), entry
->key
);
1525 goto close_and_fail
;
1528 if (!bdrv_key_required(bs
)) {
1530 blk_dev_change_media_cb(bs
->blk
, true);
1532 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1533 && !runstate_check(RUN_STATE_INMIGRATE
)
1534 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1536 "Guest must be stopped for opening of encrypted image");
1538 goto close_and_fail
;
1542 bdrv_attach_child(parent
, bs
, child_role
);
1553 QDECREF(bs
->options
);
1557 /* If *pbs is NULL, a new BDS has been created in this function and
1558 needs to be freed now. Otherwise, it does not need to be closed,
1559 since it has not really been opened yet. */
1563 error_propagate(errp
, local_err
);
1568 /* See fail path, but now the BDS has to be always closed */
1576 error_propagate(errp
, local_err
);
1581 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1582 const char *reference
, QDict
*options
, int flags
,
1583 BlockDriver
*drv
, Error
**errp
)
1585 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1589 typedef struct BlockReopenQueueEntry
{
1591 BDRVReopenState state
;
1592 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1593 } BlockReopenQueueEntry
;
1596 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1597 * reopen of multiple devices.
1599 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1600 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1601 * be created and initialized. This newly created BlockReopenQueue should be
1602 * passed back in for subsequent calls that are intended to be of the same
1605 * bs is the BlockDriverState to add to the reopen queue.
1607 * flags contains the open flags for the associated bs
1609 * returns a pointer to bs_queue, which is either the newly allocated
1610 * bs_queue, or the existing bs_queue being used.
1613 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1614 BlockDriverState
*bs
, int flags
)
1618 BlockReopenQueueEntry
*bs_entry
;
1621 if (bs_queue
== NULL
) {
1622 bs_queue
= g_new0(BlockReopenQueue
, 1);
1623 QSIMPLEQ_INIT(bs_queue
);
1626 /* bdrv_open() masks this flag out */
1627 flags
&= ~BDRV_O_PROTOCOL
;
1629 QLIST_FOREACH(child
, &bs
->children
, next
) {
1632 if (child
->bs
->inherits_from
!= bs
) {
1636 child_flags
= child
->role
->inherit_flags(flags
);
1637 bdrv_reopen_queue(bs_queue
, child
->bs
, child_flags
);
1640 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1641 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1643 bs_entry
->state
.bs
= bs
;
1644 bs_entry
->state
.flags
= flags
;
1650 * Reopen multiple BlockDriverStates atomically & transactionally.
1652 * The queue passed in (bs_queue) must have been built up previous
1653 * via bdrv_reopen_queue().
1655 * Reopens all BDS specified in the queue, with the appropriate
1656 * flags. All devices are prepared for reopen, and failure of any
1657 * device will cause all device changes to be abandonded, and intermediate
1660 * If all devices prepare successfully, then the changes are committed
1664 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1667 BlockReopenQueueEntry
*bs_entry
, *next
;
1668 Error
*local_err
= NULL
;
1670 assert(bs_queue
!= NULL
);
1674 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1675 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1676 error_propagate(errp
, local_err
);
1679 bs_entry
->prepared
= true;
1682 /* If we reach this point, we have success and just need to apply the
1685 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1686 bdrv_reopen_commit(&bs_entry
->state
);
1692 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1693 if (ret
&& bs_entry
->prepared
) {
1694 bdrv_reopen_abort(&bs_entry
->state
);
1703 /* Reopen a single BlockDriverState with the specified flags. */
1704 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1707 Error
*local_err
= NULL
;
1708 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1710 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1711 if (local_err
!= NULL
) {
1712 error_propagate(errp
, local_err
);
1719 * Prepares a BlockDriverState for reopen. All changes are staged in the
1720 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1721 * the block driver layer .bdrv_reopen_prepare()
1723 * bs is the BlockDriverState to reopen
1724 * flags are the new open flags
1725 * queue is the reopen queue
1727 * Returns 0 on success, non-zero on error. On error errp will be set
1730 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1731 * It is the responsibility of the caller to then call the abort() or
1732 * commit() for any other BDS that have been left in a prepare() state
1735 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1739 Error
*local_err
= NULL
;
1742 assert(reopen_state
!= NULL
);
1743 assert(reopen_state
->bs
->drv
!= NULL
);
1744 drv
= reopen_state
->bs
->drv
;
1746 /* if we are to stay read-only, do not allow permission change
1748 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1749 reopen_state
->flags
& BDRV_O_RDWR
) {
1750 error_setg(errp
, "Node '%s' is read only",
1751 bdrv_get_device_or_node_name(reopen_state
->bs
));
1756 ret
= bdrv_flush(reopen_state
->bs
);
1758 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1763 if (drv
->bdrv_reopen_prepare
) {
1764 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1766 if (local_err
!= NULL
) {
1767 error_propagate(errp
, local_err
);
1769 error_setg(errp
, "failed while preparing to reopen image '%s'",
1770 reopen_state
->bs
->filename
);
1775 /* It is currently mandatory to have a bdrv_reopen_prepare()
1776 * handler for each supported drv. */
1777 error_setg(errp
, "Block format '%s' used by node '%s' "
1778 "does not support reopening files", drv
->format_name
,
1779 bdrv_get_device_or_node_name(reopen_state
->bs
));
1791 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1792 * makes them final by swapping the staging BlockDriverState contents into
1793 * the active BlockDriverState contents.
1795 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1799 assert(reopen_state
!= NULL
);
1800 drv
= reopen_state
->bs
->drv
;
1801 assert(drv
!= NULL
);
1803 /* If there are any driver level actions to take */
1804 if (drv
->bdrv_reopen_commit
) {
1805 drv
->bdrv_reopen_commit(reopen_state
);
1808 /* set BDS specific flags now */
1809 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1810 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1812 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1814 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1818 * Abort the reopen, and delete and free the staged changes in
1821 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1825 assert(reopen_state
!= NULL
);
1826 drv
= reopen_state
->bs
->drv
;
1827 assert(drv
!= NULL
);
1829 if (drv
->bdrv_reopen_abort
) {
1830 drv
->bdrv_reopen_abort(reopen_state
);
1835 void bdrv_close(BlockDriverState
*bs
)
1837 BdrvAioNotifier
*ban
, *ban_next
;
1840 block_job_cancel_sync(bs
->job
);
1842 bdrv_drain_all(); /* complete I/O */
1844 bdrv_drain_all(); /* in case flush left pending I/O */
1845 notifier_list_notify(&bs
->close_notifiers
, bs
);
1848 BdrvChild
*child
, *next
;
1850 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
1851 if (child
->bs
->inherits_from
== bs
) {
1852 child
->bs
->inherits_from
= NULL
;
1854 QLIST_REMOVE(child
, next
);
1858 if (bs
->backing_hd
) {
1859 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1860 bdrv_set_backing_hd(bs
, NULL
);
1861 bdrv_unref(backing_hd
);
1863 bs
->drv
->bdrv_close(bs
);
1867 bs
->copy_on_read
= 0;
1868 bs
->backing_file
[0] = '\0';
1869 bs
->backing_format
[0] = '\0';
1870 bs
->total_sectors
= 0;
1874 bs
->zero_beyond_eof
= false;
1875 QDECREF(bs
->options
);
1877 QDECREF(bs
->full_open_options
);
1878 bs
->full_open_options
= NULL
;
1880 if (bs
->file
!= NULL
) {
1881 bdrv_unref(bs
->file
);
1887 blk_dev_change_media_cb(bs
->blk
, false);
1890 /*throttling disk I/O limits*/
1891 if (bs
->io_limits_enabled
) {
1892 bdrv_io_limits_disable(bs
);
1895 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1898 QLIST_INIT(&bs
->aio_notifiers
);
1901 void bdrv_close_all(void)
1903 BlockDriverState
*bs
;
1905 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1906 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1908 aio_context_acquire(aio_context
);
1910 aio_context_release(aio_context
);
1914 /* make a BlockDriverState anonymous by removing from bdrv_state and
1915 * graph_bdrv_state list.
1916 Also, NULL terminate the device_name to prevent double remove */
1917 void bdrv_make_anon(BlockDriverState
*bs
)
1920 * Take care to remove bs from bdrv_states only when it's actually
1921 * in it. Note that bs->device_list.tqe_prev is initially null,
1922 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1923 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1924 * resetting it to null on remove.
1926 if (bs
->device_list
.tqe_prev
) {
1927 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1928 bs
->device_list
.tqe_prev
= NULL
;
1930 if (bs
->node_name
[0] != '\0') {
1931 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1933 bs
->node_name
[0] = '\0';
1936 static void bdrv_rebind(BlockDriverState
*bs
)
1938 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1939 bs
->drv
->bdrv_rebind(bs
);
1943 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1944 BlockDriverState
*bs_src
)
1946 /* move some fields that need to stay attached to the device */
1949 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1950 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1952 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1954 /* i/o throttled req */
1955 bs_dest
->throttle_state
= bs_src
->throttle_state
,
1956 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1957 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
1958 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
1959 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1960 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1961 memcpy(&bs_dest
->round_robin
,
1962 &bs_src
->round_robin
,
1963 sizeof(bs_dest
->round_robin
));
1964 memcpy(&bs_dest
->throttle_timers
,
1965 &bs_src
->throttle_timers
,
1966 sizeof(ThrottleTimers
));
1969 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1970 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1973 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1974 bs_dest
->iostatus
= bs_src
->iostatus
;
1977 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1979 /* reference count */
1980 bs_dest
->refcnt
= bs_src
->refcnt
;
1983 bs_dest
->job
= bs_src
->job
;
1985 /* keep the same entry in bdrv_states */
1986 bs_dest
->device_list
= bs_src
->device_list
;
1987 bs_dest
->blk
= bs_src
->blk
;
1989 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1990 sizeof(bs_dest
->op_blockers
));
1994 * Swap bs contents for two image chains while they are live,
1995 * while keeping required fields on the BlockDriverState that is
1996 * actually attached to a device.
1998 * This will modify the BlockDriverState fields, and swap contents
1999 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2001 * bs_new must not be attached to a BlockBackend.
2003 * This function does not create any image files.
2005 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2007 BlockDriverState tmp
;
2013 /* The code needs to swap the node_name but simply swapping node_list won't
2014 * work so first remove the nodes from the graph list, do the swap then
2015 * insert them back if needed.
2017 if (bs_new
->node_name
[0] != '\0') {
2018 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2020 if (bs_old
->node_name
[0] != '\0') {
2021 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2024 /* If the BlockDriverState is part of a throttling group acquire
2025 * its lock since we're going to mess with the protected fields.
2026 * Otherwise there's no need to worry since no one else can touch
2028 if (bs_old
->throttle_state
) {
2029 throttle_group_lock(bs_old
);
2032 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2033 assert(!bs_new
->blk
);
2034 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2035 assert(bs_new
->job
== NULL
);
2036 assert(bs_new
->io_limits_enabled
== false);
2037 assert(bs_new
->throttle_state
== NULL
);
2038 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2044 /* there are some fields that should not be swapped, move them back */
2045 bdrv_move_feature_fields(&tmp
, bs_old
);
2046 bdrv_move_feature_fields(bs_old
, bs_new
);
2047 bdrv_move_feature_fields(bs_new
, &tmp
);
2049 /* bs_new must remain unattached */
2050 assert(!bs_new
->blk
);
2052 /* Check a few fields that should remain attached to the device */
2053 assert(bs_new
->job
== NULL
);
2054 assert(bs_new
->io_limits_enabled
== false);
2055 assert(bs_new
->throttle_state
== NULL
);
2056 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2058 /* Release the ThrottleGroup lock */
2059 if (bs_old
->throttle_state
) {
2060 throttle_group_unlock(bs_old
);
2063 /* insert the nodes back into the graph node list if needed */
2064 if (bs_new
->node_name
[0] != '\0') {
2065 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2067 if (bs_old
->node_name
[0] != '\0') {
2068 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2072 * Update lh_first.le_prev for non-empty lists.
2074 * The head of the op blocker list doesn't change because it is moved back
2075 * in bdrv_move_feature_fields().
2077 assert(QLIST_EMPTY(&bs_old
->tracked_requests
));
2078 assert(QLIST_EMPTY(&bs_new
->tracked_requests
));
2080 QLIST_FIX_HEAD_PTR(&bs_new
->children
, next
);
2081 QLIST_FIX_HEAD_PTR(&bs_old
->children
, next
);
2083 /* Update references in bs->opaque and children */
2084 QLIST_FOREACH(child
, &bs_old
->children
, next
) {
2085 if (child
->bs
->inherits_from
== bs_new
) {
2086 child
->bs
->inherits_from
= bs_old
;
2089 QLIST_FOREACH(child
, &bs_new
->children
, next
) {
2090 if (child
->bs
->inherits_from
== bs_old
) {
2091 child
->bs
->inherits_from
= bs_new
;
2095 bdrv_rebind(bs_new
);
2096 bdrv_rebind(bs_old
);
2100 * Add new bs contents at the top of an image chain while the chain is
2101 * live, while keeping required fields on the top layer.
2103 * This will modify the BlockDriverState fields, and swap contents
2104 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2106 * bs_new must not be attached to a BlockBackend.
2108 * This function does not create any image files.
2110 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2112 bdrv_swap(bs_new
, bs_top
);
2114 /* The contents of 'tmp' will become bs_top, as we are
2115 * swapping bs_new and bs_top contents. */
2116 bdrv_set_backing_hd(bs_top
, bs_new
);
2117 bdrv_attach_child(bs_top
, bs_new
, &child_backing
);
2120 static void bdrv_delete(BlockDriverState
*bs
)
2123 assert(bdrv_op_blocker_is_empty(bs
));
2124 assert(!bs
->refcnt
);
2125 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2129 /* remove from list, if necessary */
2136 * Run consistency checks on an image
2138 * Returns 0 if the check could be completed (it doesn't mean that the image is
2139 * free of errors) or -errno when an internal error occurred. The results of the
2140 * check are stored in res.
2142 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2144 if (bs
->drv
== NULL
) {
2147 if (bs
->drv
->bdrv_check
== NULL
) {
2151 memset(res
, 0, sizeof(*res
));
2152 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2155 #define COMMIT_BUF_SECTORS 2048
2157 /* commit COW file into the raw image */
2158 int bdrv_commit(BlockDriverState
*bs
)
2160 BlockDriver
*drv
= bs
->drv
;
2161 int64_t sector
, total_sectors
, length
, backing_length
;
2162 int n
, ro
, open_flags
;
2164 uint8_t *buf
= NULL
;
2169 if (!bs
->backing_hd
) {
2173 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2174 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2178 ro
= bs
->backing_hd
->read_only
;
2179 open_flags
= bs
->backing_hd
->open_flags
;
2182 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2187 length
= bdrv_getlength(bs
);
2193 backing_length
= bdrv_getlength(bs
->backing_hd
);
2194 if (backing_length
< 0) {
2195 ret
= backing_length
;
2199 /* If our top snapshot is larger than the backing file image,
2200 * grow the backing file image if possible. If not possible,
2201 * we must return an error */
2202 if (length
> backing_length
) {
2203 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2209 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2211 /* qemu_try_blockalign() for bs will choose an alignment that works for
2212 * bs->backing_hd as well, so no need to compare the alignment manually. */
2213 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2219 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2220 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2225 ret
= bdrv_read(bs
, sector
, buf
, n
);
2230 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2237 if (drv
->bdrv_make_empty
) {
2238 ret
= drv
->bdrv_make_empty(bs
);
2246 * Make sure all data we wrote to the backing device is actually
2249 if (bs
->backing_hd
) {
2250 bdrv_flush(bs
->backing_hd
);
2258 /* ignoring error return here */
2259 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2265 int bdrv_commit_all(void)
2267 BlockDriverState
*bs
;
2269 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2270 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2272 aio_context_acquire(aio_context
);
2273 if (bs
->drv
&& bs
->backing_hd
) {
2274 int ret
= bdrv_commit(bs
);
2276 aio_context_release(aio_context
);
2280 aio_context_release(aio_context
);
2288 * -EINVAL - backing format specified, but no file
2289 * -ENOSPC - can't update the backing file because no space is left in the
2291 * -ENOTSUP - format driver doesn't support changing the backing file
2293 int bdrv_change_backing_file(BlockDriverState
*bs
,
2294 const char *backing_file
, const char *backing_fmt
)
2296 BlockDriver
*drv
= bs
->drv
;
2299 /* Backing file format doesn't make sense without a backing file */
2300 if (backing_fmt
&& !backing_file
) {
2304 if (drv
->bdrv_change_backing_file
!= NULL
) {
2305 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2311 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2312 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2318 * Finds the image layer in the chain that has 'bs' as its backing file.
2320 * active is the current topmost image.
2322 * Returns NULL if bs is not found in active's image chain,
2323 * or if active == bs.
2325 * Returns the bottommost base image if bs == NULL.
2327 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2328 BlockDriverState
*bs
)
2330 while (active
&& bs
!= active
->backing_hd
) {
2331 active
= active
->backing_hd
;
2337 /* Given a BDS, searches for the base layer. */
2338 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2340 return bdrv_find_overlay(bs
, NULL
);
2343 typedef struct BlkIntermediateStates
{
2344 BlockDriverState
*bs
;
2345 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2346 } BlkIntermediateStates
;
2350 * Drops images above 'base' up to and including 'top', and sets the image
2351 * above 'top' to have base as its backing file.
2353 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2354 * information in 'bs' can be properly updated.
2356 * E.g., this will convert the following chain:
2357 * bottom <- base <- intermediate <- top <- active
2361 * bottom <- base <- active
2363 * It is allowed for bottom==base, in which case it converts:
2365 * base <- intermediate <- top <- active
2371 * If backing_file_str is non-NULL, it will be used when modifying top's
2372 * overlay image metadata.
2375 * if active == top, that is considered an error
2378 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2379 BlockDriverState
*base
, const char *backing_file_str
)
2381 BlockDriverState
*intermediate
;
2382 BlockDriverState
*base_bs
= NULL
;
2383 BlockDriverState
*new_top_bs
= NULL
;
2384 BlkIntermediateStates
*intermediate_state
, *next
;
2387 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2388 QSIMPLEQ_INIT(&states_to_delete
);
2390 if (!top
->drv
|| !base
->drv
) {
2394 new_top_bs
= bdrv_find_overlay(active
, top
);
2396 if (new_top_bs
== NULL
) {
2397 /* we could not find the image above 'top', this is an error */
2401 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2402 * to do, no intermediate images */
2403 if (new_top_bs
->backing_hd
== base
) {
2410 /* now we will go down through the list, and add each BDS we find
2411 * into our deletion queue, until we hit the 'base'
2413 while (intermediate
) {
2414 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2415 intermediate_state
->bs
= intermediate
;
2416 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2418 if (intermediate
->backing_hd
== base
) {
2419 base_bs
= intermediate
->backing_hd
;
2422 intermediate
= intermediate
->backing_hd
;
2424 if (base_bs
== NULL
) {
2425 /* something went wrong, we did not end at the base. safely
2426 * unravel everything, and exit with error */
2430 /* success - we can delete the intermediate states, and link top->base */
2431 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2432 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2433 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2437 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2439 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2440 /* so that bdrv_close() does not recursively close the chain */
2441 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2442 bdrv_unref(intermediate_state
->bs
);
2447 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2448 g_free(intermediate_state
);
2454 * Truncate file to 'offset' bytes (needed only for file protocols)
2456 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2458 BlockDriver
*drv
= bs
->drv
;
2462 if (!drv
->bdrv_truncate
)
2467 ret
= drv
->bdrv_truncate(bs
, offset
);
2469 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2470 bdrv_dirty_bitmap_truncate(bs
);
2472 blk_dev_resize_cb(bs
->blk
);
2479 * Length of a allocated file in bytes. Sparse files are counted by actual
2480 * allocated space. Return < 0 if error or unknown.
2482 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2484 BlockDriver
*drv
= bs
->drv
;
2488 if (drv
->bdrv_get_allocated_file_size
) {
2489 return drv
->bdrv_get_allocated_file_size(bs
);
2492 return bdrv_get_allocated_file_size(bs
->file
);
2498 * Return number of sectors on success, -errno on error.
2500 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2502 BlockDriver
*drv
= bs
->drv
;
2507 if (drv
->has_variable_length
) {
2508 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2513 return bs
->total_sectors
;
2517 * Return length in bytes on success, -errno on error.
2518 * The length is always a multiple of BDRV_SECTOR_SIZE.
2520 int64_t bdrv_getlength(BlockDriverState
*bs
)
2522 int64_t ret
= bdrv_nb_sectors(bs
);
2524 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2525 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2528 /* return 0 as number of sectors if no device present or error */
2529 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2531 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2533 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2536 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2537 BlockdevOnError on_write_error
)
2539 bs
->on_read_error
= on_read_error
;
2540 bs
->on_write_error
= on_write_error
;
2543 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2545 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2548 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2550 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2553 case BLOCKDEV_ON_ERROR_ENOSPC
:
2554 return (error
== ENOSPC
) ?
2555 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2556 case BLOCKDEV_ON_ERROR_STOP
:
2557 return BLOCK_ERROR_ACTION_STOP
;
2558 case BLOCKDEV_ON_ERROR_REPORT
:
2559 return BLOCK_ERROR_ACTION_REPORT
;
2560 case BLOCKDEV_ON_ERROR_IGNORE
:
2561 return BLOCK_ERROR_ACTION_IGNORE
;
2567 static void send_qmp_error_event(BlockDriverState
*bs
,
2568 BlockErrorAction action
,
2569 bool is_read
, int error
)
2571 IoOperationType optype
;
2573 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2574 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2575 bdrv_iostatus_is_enabled(bs
),
2576 error
== ENOSPC
, strerror(error
),
2580 /* This is done by device models because, while the block layer knows
2581 * about the error, it does not know whether an operation comes from
2582 * the device or the block layer (from a job, for example).
2584 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2585 bool is_read
, int error
)
2589 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2590 /* First set the iostatus, so that "info block" returns an iostatus
2591 * that matches the events raised so far (an additional error iostatus
2592 * is fine, but not a lost one).
2594 bdrv_iostatus_set_err(bs
, error
);
2596 /* Then raise the request to stop the VM and the event.
2597 * qemu_system_vmstop_request_prepare has two effects. First,
2598 * it ensures that the STOP event always comes after the
2599 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2600 * can observe the STOP event and do a "cont" before the STOP
2601 * event is issued, the VM will not stop. In this case, vm_start()
2602 * also ensures that the STOP/RESUME pair of events is emitted.
2604 qemu_system_vmstop_request_prepare();
2605 send_qmp_error_event(bs
, action
, is_read
, error
);
2606 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2608 send_qmp_error_event(bs
, action
, is_read
, error
);
2612 int bdrv_is_read_only(BlockDriverState
*bs
)
2614 return bs
->read_only
;
2617 int bdrv_is_sg(BlockDriverState
*bs
)
2622 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2624 return bs
->enable_write_cache
;
2627 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2629 bs
->enable_write_cache
= wce
;
2631 /* so a reopen() will preserve wce */
2633 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2635 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2639 int bdrv_is_encrypted(BlockDriverState
*bs
)
2641 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2643 return bs
->encrypted
;
2646 int bdrv_key_required(BlockDriverState
*bs
)
2648 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2650 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2652 return (bs
->encrypted
&& !bs
->valid_key
);
2655 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2658 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2659 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2665 if (!bs
->encrypted
) {
2667 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2670 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2673 } else if (!bs
->valid_key
) {
2676 /* call the change callback now, we skipped it on open */
2677 blk_dev_change_media_cb(bs
->blk
, true);
2684 * Provide an encryption key for @bs.
2685 * If @key is non-null:
2686 * If @bs is not encrypted, fail.
2687 * Else if the key is invalid, fail.
2688 * Else set @bs's key to @key, replacing the existing key, if any.
2690 * If @bs is encrypted and still lacks a key, fail.
2692 * On failure, store an error object through @errp if non-null.
2694 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2697 if (!bdrv_is_encrypted(bs
)) {
2698 error_setg(errp
, "Node '%s' is not encrypted",
2699 bdrv_get_device_or_node_name(bs
));
2700 } else if (bdrv_set_key(bs
, key
) < 0) {
2701 error_set(errp
, QERR_INVALID_PASSWORD
);
2704 if (bdrv_key_required(bs
)) {
2705 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2706 "'%s' (%s) is encrypted",
2707 bdrv_get_device_or_node_name(bs
),
2708 bdrv_get_encrypted_filename(bs
));
2713 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2715 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2718 static int qsort_strcmp(const void *a
, const void *b
)
2720 return strcmp(a
, b
);
2723 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2729 const char **formats
= NULL
;
2731 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2732 if (drv
->format_name
) {
2735 while (formats
&& i
&& !found
) {
2736 found
= !strcmp(formats
[--i
], drv
->format_name
);
2740 formats
= g_renew(const char *, formats
, count
+ 1);
2741 formats
[count
++] = drv
->format_name
;
2746 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2748 for (i
= 0; i
< count
; i
++) {
2749 it(opaque
, formats
[i
]);
2755 /* This function is to find a node in the bs graph */
2756 BlockDriverState
*bdrv_find_node(const char *node_name
)
2758 BlockDriverState
*bs
;
2762 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2763 if (!strcmp(node_name
, bs
->node_name
)) {
2770 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2771 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2773 BlockDeviceInfoList
*list
, *entry
;
2774 BlockDriverState
*bs
;
2777 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2778 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2780 qapi_free_BlockDeviceInfoList(list
);
2783 entry
= g_malloc0(sizeof(*entry
));
2784 entry
->value
= info
;
2792 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2793 const char *node_name
,
2797 BlockDriverState
*bs
;
2800 blk
= blk_by_name(device
);
2808 bs
= bdrv_find_node(node_name
);
2815 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2816 device
? device
: "",
2817 node_name
? node_name
: "");
2821 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2822 * return false. If either argument is NULL, return false. */
2823 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2825 while (top
&& top
!= base
) {
2826 top
= top
->backing_hd
;
2832 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2835 return QTAILQ_FIRST(&graph_bdrv_states
);
2837 return QTAILQ_NEXT(bs
, node_list
);
2840 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2843 return QTAILQ_FIRST(&bdrv_states
);
2845 return QTAILQ_NEXT(bs
, device_list
);
2848 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2850 return bs
->node_name
;
2853 /* TODO check what callers really want: bs->node_name or blk_name() */
2854 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2856 return bs
->blk
? blk_name(bs
->blk
) : "";
2859 /* This can be used to identify nodes that might not have a device
2860 * name associated. Since node and device names live in the same
2861 * namespace, the result is unambiguous. The exception is if both are
2862 * absent, then this returns an empty (non-null) string. */
2863 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2865 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2868 int bdrv_get_flags(BlockDriverState
*bs
)
2870 return bs
->open_flags
;
2873 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2878 int bdrv_has_zero_init(BlockDriverState
*bs
)
2882 /* If BS is a copy on write image, it is initialized to
2883 the contents of the base image, which may not be zeroes. */
2884 if (bs
->backing_hd
) {
2887 if (bs
->drv
->bdrv_has_zero_init
) {
2888 return bs
->drv
->bdrv_has_zero_init(bs
);
2895 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2897 BlockDriverInfo bdi
;
2899 if (bs
->backing_hd
) {
2903 if (bdrv_get_info(bs
, &bdi
) == 0) {
2904 return bdi
.unallocated_blocks_are_zero
;
2910 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2912 BlockDriverInfo bdi
;
2914 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2918 if (bdrv_get_info(bs
, &bdi
) == 0) {
2919 return bdi
.can_write_zeroes_with_unmap
;
2925 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2927 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2928 return bs
->backing_file
;
2929 else if (bs
->encrypted
)
2930 return bs
->filename
;
2935 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2936 char *filename
, int filename_size
)
2938 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2941 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2943 BlockDriver
*drv
= bs
->drv
;
2946 if (!drv
->bdrv_get_info
)
2948 memset(bdi
, 0, sizeof(*bdi
));
2949 return drv
->bdrv_get_info(bs
, bdi
);
2952 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2954 BlockDriver
*drv
= bs
->drv
;
2955 if (drv
&& drv
->bdrv_get_specific_info
) {
2956 return drv
->bdrv_get_specific_info(bs
);
2961 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2963 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
2967 bs
->drv
->bdrv_debug_event(bs
, event
);
2970 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
2973 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
2977 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
2978 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
2984 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
2986 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
2990 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
2991 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
2997 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
2999 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3003 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3004 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3010 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3012 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3016 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3017 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3023 int bdrv_is_snapshot(BlockDriverState
*bs
)
3025 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3028 /* backing_file can either be relative, or absolute, or a protocol. If it is
3029 * relative, it must be relative to the chain. So, passing in bs->filename
3030 * from a BDS as backing_file should not be done, as that may be relative to
3031 * the CWD rather than the chain. */
3032 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3033 const char *backing_file
)
3035 char *filename_full
= NULL
;
3036 char *backing_file_full
= NULL
;
3037 char *filename_tmp
= NULL
;
3038 int is_protocol
= 0;
3039 BlockDriverState
*curr_bs
= NULL
;
3040 BlockDriverState
*retval
= NULL
;
3042 if (!bs
|| !bs
->drv
|| !backing_file
) {
3046 filename_full
= g_malloc(PATH_MAX
);
3047 backing_file_full
= g_malloc(PATH_MAX
);
3048 filename_tmp
= g_malloc(PATH_MAX
);
3050 is_protocol
= path_has_protocol(backing_file
);
3052 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3054 /* If either of the filename paths is actually a protocol, then
3055 * compare unmodified paths; otherwise make paths relative */
3056 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3057 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3058 retval
= curr_bs
->backing_hd
;
3062 /* If not an absolute filename path, make it relative to the current
3063 * image's filename path */
3064 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3067 /* We are going to compare absolute pathnames */
3068 if (!realpath(filename_tmp
, filename_full
)) {
3072 /* We need to make sure the backing filename we are comparing against
3073 * is relative to the current image filename (or absolute) */
3074 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3075 curr_bs
->backing_file
);
3077 if (!realpath(filename_tmp
, backing_file_full
)) {
3081 if (strcmp(backing_file_full
, filename_full
) == 0) {
3082 retval
= curr_bs
->backing_hd
;
3088 g_free(filename_full
);
3089 g_free(backing_file_full
);
3090 g_free(filename_tmp
);
3094 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3100 if (!bs
->backing_hd
) {
3104 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3107 void bdrv_init(void)
3109 module_call_init(MODULE_INIT_BLOCK
);
3112 void bdrv_init_with_whitelist(void)
3114 use_bdrv_whitelist
= 1;
3118 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3120 Error
*local_err
= NULL
;
3127 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3130 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3132 if (bs
->drv
->bdrv_invalidate_cache
) {
3133 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3134 } else if (bs
->file
) {
3135 bdrv_invalidate_cache(bs
->file
, &local_err
);
3138 error_propagate(errp
, local_err
);
3142 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3144 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3149 void bdrv_invalidate_cache_all(Error
**errp
)
3151 BlockDriverState
*bs
;
3152 Error
*local_err
= NULL
;
3154 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3155 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3157 aio_context_acquire(aio_context
);
3158 bdrv_invalidate_cache(bs
, &local_err
);
3159 aio_context_release(aio_context
);
3161 error_propagate(errp
, local_err
);
3167 /**************************************************************/
3168 /* removable device support */
3171 * Return TRUE if the media is present
3173 int bdrv_is_inserted(BlockDriverState
*bs
)
3175 BlockDriver
*drv
= bs
->drv
;
3179 if (!drv
->bdrv_is_inserted
)
3181 return drv
->bdrv_is_inserted(bs
);
3185 * Return whether the media changed since the last call to this
3186 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3188 int bdrv_media_changed(BlockDriverState
*bs
)
3190 BlockDriver
*drv
= bs
->drv
;
3192 if (drv
&& drv
->bdrv_media_changed
) {
3193 return drv
->bdrv_media_changed(bs
);
3199 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3201 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3203 BlockDriver
*drv
= bs
->drv
;
3204 const char *device_name
;
3206 if (drv
&& drv
->bdrv_eject
) {
3207 drv
->bdrv_eject(bs
, eject_flag
);
3210 device_name
= bdrv_get_device_name(bs
);
3211 if (device_name
[0] != '\0') {
3212 qapi_event_send_device_tray_moved(device_name
,
3213 eject_flag
, &error_abort
);
3218 * Lock or unlock the media (if it is locked, the user won't be able
3219 * to eject it manually).
3221 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3223 BlockDriver
*drv
= bs
->drv
;
3225 trace_bdrv_lock_medium(bs
, locked
);
3227 if (drv
&& drv
->bdrv_lock_medium
) {
3228 drv
->bdrv_lock_medium(bs
, locked
);
3232 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3234 bs
->guest_block_size
= align
;
3237 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3239 BdrvDirtyBitmap
*bm
;
3242 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3243 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3250 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3252 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3253 g_free(bitmap
->name
);
3254 bitmap
->name
= NULL
;
3257 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3258 uint32_t granularity
,
3262 int64_t bitmap_size
;
3263 BdrvDirtyBitmap
*bitmap
;
3264 uint32_t sector_granularity
;
3266 assert((granularity
& (granularity
- 1)) == 0);
3268 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3269 error_setg(errp
, "Bitmap already exists: %s", name
);
3272 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3273 assert(sector_granularity
);
3274 bitmap_size
= bdrv_nb_sectors(bs
);
3275 if (bitmap_size
< 0) {
3276 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3277 errno
= -bitmap_size
;
3280 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3281 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3282 bitmap
->size
= bitmap_size
;
3283 bitmap
->name
= g_strdup(name
);
3284 bitmap
->disabled
= false;
3285 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3289 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3291 return bitmap
->successor
;
3294 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3296 return !(bitmap
->disabled
|| bitmap
->successor
);
3299 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3301 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3302 return DIRTY_BITMAP_STATUS_FROZEN
;
3303 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3304 return DIRTY_BITMAP_STATUS_DISABLED
;
3306 return DIRTY_BITMAP_STATUS_ACTIVE
;
3311 * Create a successor bitmap destined to replace this bitmap after an operation.
3312 * Requires that the bitmap is not frozen and has no successor.
3314 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3315 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3317 uint64_t granularity
;
3318 BdrvDirtyBitmap
*child
;
3320 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3321 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3322 "currently frozen");
3325 assert(!bitmap
->successor
);
3327 /* Create an anonymous successor */
3328 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3329 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3334 /* Successor will be on or off based on our current state. */
3335 child
->disabled
= bitmap
->disabled
;
3337 /* Install the successor and freeze the parent */
3338 bitmap
->successor
= child
;
3343 * For a bitmap with a successor, yield our name to the successor,
3344 * delete the old bitmap, and return a handle to the new bitmap.
3346 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3347 BdrvDirtyBitmap
*bitmap
,
3351 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3353 if (successor
== NULL
) {
3354 error_setg(errp
, "Cannot relinquish control if "
3355 "there's no successor present");
3359 name
= bitmap
->name
;
3360 bitmap
->name
= NULL
;
3361 successor
->name
= name
;
3362 bitmap
->successor
= NULL
;
3363 bdrv_release_dirty_bitmap(bs
, bitmap
);
3369 * In cases of failure where we can no longer safely delete the parent,
3370 * we may wish to re-join the parent and child/successor.
3371 * The merged parent will be un-frozen, but not explicitly re-enabled.
3373 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3374 BdrvDirtyBitmap
*parent
,
3377 BdrvDirtyBitmap
*successor
= parent
->successor
;
3380 error_setg(errp
, "Cannot reclaim a successor when none is present");
3384 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3385 error_setg(errp
, "Merging of parent and successor bitmap failed");
3388 bdrv_release_dirty_bitmap(bs
, successor
);
3389 parent
->successor
= NULL
;
3395 * Truncates _all_ bitmaps attached to a BDS.
3397 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3399 BdrvDirtyBitmap
*bitmap
;
3400 uint64_t size
= bdrv_nb_sectors(bs
);
3402 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3403 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3404 hbitmap_truncate(bitmap
->bitmap
, size
);
3405 bitmap
->size
= size
;
3409 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3411 BdrvDirtyBitmap
*bm
, *next
;
3412 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3414 assert(!bdrv_dirty_bitmap_frozen(bm
));
3415 QLIST_REMOVE(bitmap
, list
);
3416 hbitmap_free(bitmap
->bitmap
);
3417 g_free(bitmap
->name
);
3424 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3426 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3427 bitmap
->disabled
= true;
3430 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3432 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3433 bitmap
->disabled
= false;
3436 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3438 BdrvDirtyBitmap
*bm
;
3439 BlockDirtyInfoList
*list
= NULL
;
3440 BlockDirtyInfoList
**plist
= &list
;
3442 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3443 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3444 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3445 info
->count
= bdrv_get_dirty_count(bm
);
3446 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3447 info
->has_name
= !!bm
->name
;
3448 info
->name
= g_strdup(bm
->name
);
3449 info
->status
= bdrv_dirty_bitmap_status(bm
);
3450 entry
->value
= info
;
3452 plist
= &entry
->next
;
3458 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3461 return hbitmap_get(bitmap
->bitmap
, sector
);
3468 * Chooses a default granularity based on the existing cluster size,
3469 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3470 * is no cluster size information available.
3472 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3474 BlockDriverInfo bdi
;
3475 uint32_t granularity
;
3477 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3478 granularity
= MAX(4096, bdi
.cluster_size
);
3479 granularity
= MIN(65536, granularity
);
3481 granularity
= 65536;
3487 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3489 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3492 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3494 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3497 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3498 int64_t cur_sector
, int nr_sectors
)
3500 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3501 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3504 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3505 int64_t cur_sector
, int nr_sectors
)
3507 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3508 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3511 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3513 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3514 hbitmap_reset(bitmap
->bitmap
, 0, bitmap
->size
);
3517 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3520 BdrvDirtyBitmap
*bitmap
;
3521 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3522 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3525 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3529 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3532 BdrvDirtyBitmap
*bitmap
;
3533 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3534 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3537 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3542 * Advance an HBitmapIter to an arbitrary offset.
3544 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3547 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3550 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3552 return hbitmap_count(bitmap
->bitmap
);
3555 /* Get a reference to bs */
3556 void bdrv_ref(BlockDriverState
*bs
)
3561 /* Release a previously grabbed reference to bs.
3562 * If after releasing, reference count is zero, the BlockDriverState is
3564 void bdrv_unref(BlockDriverState
*bs
)
3569 assert(bs
->refcnt
> 0);
3570 if (--bs
->refcnt
== 0) {
3575 struct BdrvOpBlocker
{
3577 QLIST_ENTRY(BdrvOpBlocker
) list
;
3580 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3582 BdrvOpBlocker
*blocker
;
3583 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3584 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3585 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3587 error_setg(errp
, "Node '%s' is busy: %s",
3588 bdrv_get_device_or_node_name(bs
),
3589 error_get_pretty(blocker
->reason
));
3596 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3598 BdrvOpBlocker
*blocker
;
3599 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3601 blocker
= g_new0(BdrvOpBlocker
, 1);
3602 blocker
->reason
= reason
;
3603 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3606 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3608 BdrvOpBlocker
*blocker
, *next
;
3609 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3610 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3611 if (blocker
->reason
== reason
) {
3612 QLIST_REMOVE(blocker
, list
);
3618 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3621 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3622 bdrv_op_block(bs
, i
, reason
);
3626 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3629 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3630 bdrv_op_unblock(bs
, i
, reason
);
3634 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3638 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3639 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3646 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3648 bs
->iostatus_enabled
= true;
3649 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3652 /* The I/O status is only enabled if the drive explicitly
3653 * enables it _and_ the VM is configured to stop on errors */
3654 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3656 return (bs
->iostatus_enabled
&&
3657 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3658 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3659 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3662 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3664 bs
->iostatus_enabled
= false;
3667 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3669 if (bdrv_iostatus_is_enabled(bs
)) {
3670 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3672 block_job_iostatus_reset(bs
->job
);
3677 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3679 assert(bdrv_iostatus_is_enabled(bs
));
3680 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3681 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3682 BLOCK_DEVICE_IO_STATUS_FAILED
;
3686 void bdrv_img_create(const char *filename
, const char *fmt
,
3687 const char *base_filename
, const char *base_fmt
,
3688 char *options
, uint64_t img_size
, int flags
,
3689 Error
**errp
, bool quiet
)
3691 QemuOptsList
*create_opts
= NULL
;
3692 QemuOpts
*opts
= NULL
;
3693 const char *backing_fmt
, *backing_file
;
3695 BlockDriver
*drv
, *proto_drv
;
3696 BlockDriver
*backing_drv
= NULL
;
3697 Error
*local_err
= NULL
;
3700 /* Find driver and parse its options */
3701 drv
= bdrv_find_format(fmt
);
3703 error_setg(errp
, "Unknown file format '%s'", fmt
);
3707 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3712 if (!drv
->create_opts
) {
3713 error_setg(errp
, "Format driver '%s' does not support image creation",
3718 if (!proto_drv
->create_opts
) {
3719 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3720 proto_drv
->format_name
);
3724 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3725 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3727 /* Create parameter list with default values */
3728 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3729 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3731 /* Parse -o options */
3733 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3735 error_report_err(local_err
);
3737 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3742 if (base_filename
) {
3743 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3745 error_setg(errp
, "Backing file not supported for file format '%s'",
3752 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3754 error_setg(errp
, "Backing file format not supported for file "
3755 "format '%s'", fmt
);
3760 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3762 if (!strcmp(filename
, backing_file
)) {
3763 error_setg(errp
, "Error: Trying to create an image with the "
3764 "same filename as the backing file");
3769 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3771 backing_drv
= bdrv_find_format(backing_fmt
);
3773 error_setg(errp
, "Unknown backing file format '%s'",
3779 // The size for the image must always be specified, with one exception:
3780 // If we are using a backing file, we can obtain the size from there
3781 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3784 BlockDriverState
*bs
;
3785 char *full_backing
= g_new0(char, PATH_MAX
);
3789 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3790 full_backing
, PATH_MAX
,
3793 g_free(full_backing
);
3797 /* backing files always opened read-only */
3799 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3802 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
3803 backing_drv
, &local_err
);
3804 g_free(full_backing
);
3808 size
= bdrv_getlength(bs
);
3810 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3816 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3820 error_setg(errp
, "Image creation needs a size parameter");
3826 printf("Formatting '%s', fmt=%s", filename
, fmt
);
3827 qemu_opts_print(opts
, " ");
3831 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3833 if (ret
== -EFBIG
) {
3834 /* This is generally a better message than whatever the driver would
3835 * deliver (especially because of the cluster_size_hint), since that
3836 * is most probably not much different from "image too large". */
3837 const char *cluster_size_hint
= "";
3838 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3839 cluster_size_hint
= " (try using a larger cluster size)";
3841 error_setg(errp
, "The image size is too large for file format '%s'"
3842 "%s", fmt
, cluster_size_hint
);
3843 error_free(local_err
);
3848 qemu_opts_del(opts
);
3849 qemu_opts_free(create_opts
);
3851 error_propagate(errp
, local_err
);
3855 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3857 return bs
->aio_context
;
3860 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3862 BdrvAioNotifier
*baf
;
3868 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3869 baf
->detach_aio_context(baf
->opaque
);
3872 if (bs
->io_limits_enabled
) {
3873 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3875 if (bs
->drv
->bdrv_detach_aio_context
) {
3876 bs
->drv
->bdrv_detach_aio_context(bs
);
3879 bdrv_detach_aio_context(bs
->file
);
3881 if (bs
->backing_hd
) {
3882 bdrv_detach_aio_context(bs
->backing_hd
);
3885 bs
->aio_context
= NULL
;
3888 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3889 AioContext
*new_context
)
3891 BdrvAioNotifier
*ban
;
3897 bs
->aio_context
= new_context
;
3899 if (bs
->backing_hd
) {
3900 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3903 bdrv_attach_aio_context(bs
->file
, new_context
);
3905 if (bs
->drv
->bdrv_attach_aio_context
) {
3906 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3908 if (bs
->io_limits_enabled
) {
3909 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3912 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3913 ban
->attached_aio_context(new_context
, ban
->opaque
);
3917 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3919 bdrv_drain_all(); /* ensure there are no in-flight requests */
3921 bdrv_detach_aio_context(bs
);
3923 /* This function executes in the old AioContext so acquire the new one in
3924 * case it runs in a different thread.
3926 aio_context_acquire(new_context
);
3927 bdrv_attach_aio_context(bs
, new_context
);
3928 aio_context_release(new_context
);
3931 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3932 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3933 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3935 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3936 *ban
= (BdrvAioNotifier
){
3937 .attached_aio_context
= attached_aio_context
,
3938 .detach_aio_context
= detach_aio_context
,
3942 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3945 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3946 void (*attached_aio_context
)(AioContext
*,
3948 void (*detach_aio_context
)(void *),
3951 BdrvAioNotifier
*ban
, *ban_next
;
3953 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3954 if (ban
->attached_aio_context
== attached_aio_context
&&
3955 ban
->detach_aio_context
== detach_aio_context
&&
3956 ban
->opaque
== opaque
)
3958 QLIST_REMOVE(ban
, list
);
3968 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3969 BlockDriverAmendStatusCB
*status_cb
)
3971 if (!bs
->drv
->bdrv_amend_options
) {
3974 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3977 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3978 * of block filter and by bdrv_is_first_non_filter.
3979 * It is used to test if the given bs is the candidate or recurse more in the
3982 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3983 BlockDriverState
*candidate
)
3985 /* return false if basic checks fails */
3986 if (!bs
|| !bs
->drv
) {
3990 /* the code reached a non block filter driver -> check if the bs is
3991 * the same as the candidate. It's the recursion termination condition.
3993 if (!bs
->drv
->is_filter
) {
3994 return bs
== candidate
;
3996 /* Down this path the driver is a block filter driver */
3998 /* If the block filter recursion method is defined use it to recurse down
4001 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4002 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4005 /* the driver is a block filter but don't allow to recurse -> return false
4010 /* This function checks if the candidate is the first non filter bs down it's
4011 * bs chain. Since we don't have pointers to parents it explore all bs chains
4012 * from the top. Some filters can choose not to pass down the recursion.
4014 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4016 BlockDriverState
*bs
;
4018 /* walk down the bs forest recursively */
4019 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4022 /* try to recurse in this top level bs */
4023 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4025 /* candidate is the first non filter */
4034 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
4036 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4037 AioContext
*aio_context
;
4039 if (!to_replace_bs
) {
4040 error_setg(errp
, "Node name '%s' not found", node_name
);
4044 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4045 aio_context_acquire(aio_context
);
4047 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4048 to_replace_bs
= NULL
;
4052 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4053 * most non filter in order to prevent data corruption.
4054 * Another benefit is that this tests exclude backing files which are
4055 * blocked by the backing blockers.
4057 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
4058 error_setg(errp
, "Only top most non filter can be replaced");
4059 to_replace_bs
= NULL
;
4064 aio_context_release(aio_context
);
4065 return to_replace_bs
;
4068 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4070 const QDictEntry
*entry
;
4071 bool found_any
= false;
4073 for (entry
= qdict_first(bs
->options
); entry
;
4074 entry
= qdict_next(bs
->options
, entry
))
4076 /* Only take options for this level and exclude all non-driver-specific
4078 if (!strchr(qdict_entry_key(entry
), '.') &&
4079 strcmp(qdict_entry_key(entry
), "node-name"))
4081 qobject_incref(qdict_entry_value(entry
));
4082 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4090 /* Updates the following BDS fields:
4091 * - exact_filename: A filename which may be used for opening a block device
4092 * which (mostly) equals the given BDS (even without any
4093 * other options; so reading and writing must return the same
4094 * results, but caching etc. may be different)
4095 * - full_open_options: Options which, when given when opening a block device
4096 * (without a filename), result in a BDS (mostly)
4097 * equalling the given one
4098 * - filename: If exact_filename is set, it is copied here. Otherwise,
4099 * full_open_options is converted to a JSON object, prefixed with
4100 * "json:" (for use through the JSON pseudo protocol) and put here.
4102 void bdrv_refresh_filename(BlockDriverState
*bs
)
4104 BlockDriver
*drv
= bs
->drv
;
4111 /* This BDS's file name will most probably depend on its file's name, so
4112 * refresh that first */
4114 bdrv_refresh_filename(bs
->file
);
4117 if (drv
->bdrv_refresh_filename
) {
4118 /* Obsolete information is of no use here, so drop the old file name
4119 * information before refreshing it */
4120 bs
->exact_filename
[0] = '\0';
4121 if (bs
->full_open_options
) {
4122 QDECREF(bs
->full_open_options
);
4123 bs
->full_open_options
= NULL
;
4126 drv
->bdrv_refresh_filename(bs
);
4127 } else if (bs
->file
) {
4128 /* Try to reconstruct valid information from the underlying file */
4129 bool has_open_options
;
4131 bs
->exact_filename
[0] = '\0';
4132 if (bs
->full_open_options
) {
4133 QDECREF(bs
->full_open_options
);
4134 bs
->full_open_options
= NULL
;
4138 has_open_options
= append_open_options(opts
, bs
);
4140 /* If no specific options have been given for this BDS, the filename of
4141 * the underlying file should suffice for this one as well */
4142 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
4143 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
4145 /* Reconstructing the full options QDict is simple for most format block
4146 * drivers, as long as the full options are known for the underlying
4147 * file BDS. The full options QDict of that file BDS should somehow
4148 * contain a representation of the filename, therefore the following
4149 * suffices without querying the (exact_)filename of this BDS. */
4150 if (bs
->file
->full_open_options
) {
4151 qdict_put_obj(opts
, "driver",
4152 QOBJECT(qstring_from_str(drv
->format_name
)));
4153 QINCREF(bs
->file
->full_open_options
);
4154 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
4156 bs
->full_open_options
= opts
;
4160 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4161 /* There is no underlying file BDS (at least referenced by BDS.file),
4162 * so the full options QDict should be equal to the options given
4163 * specifically for this block device when it was opened (plus the
4164 * driver specification).
4165 * Because those options don't change, there is no need to update
4166 * full_open_options when it's already set. */
4169 append_open_options(opts
, bs
);
4170 qdict_put_obj(opts
, "driver",
4171 QOBJECT(qstring_from_str(drv
->format_name
)));
4173 if (bs
->exact_filename
[0]) {
4174 /* This may not work for all block protocol drivers (some may
4175 * require this filename to be parsed), but we have to find some
4176 * default solution here, so just include it. If some block driver
4177 * does not support pure options without any filename at all or
4178 * needs some special format of the options QDict, it needs to
4179 * implement the driver-specific bdrv_refresh_filename() function.
4181 qdict_put_obj(opts
, "filename",
4182 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4185 bs
->full_open_options
= opts
;
4188 if (bs
->exact_filename
[0]) {
4189 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4190 } else if (bs
->full_open_options
) {
4191 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4192 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4193 qstring_get_str(json
));
4198 /* This accessor function purpose is to allow the device models to access the
4199 * BlockAcctStats structure embedded inside a BlockDriverState without being
4200 * aware of the BlockDriverState structure layout.
4201 * It will go away when the BlockAcctStats structure will be moved inside
4202 * the device models.
4204 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)