2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "block/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
44 #include <sys/types.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
65 struct BdrvDirtyBitmap
{
66 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
68 char *name
; /* Optional non-empty unique ID */
69 int64_t size
; /* Size of the bitmap (Number of sectors) */
70 bool disabled
; /* Bitmap is read-only */
71 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
76 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
77 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
79 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
82 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
83 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
85 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
86 const char *reference
, QDict
*options
, int flags
,
87 BlockDriverState
*parent
,
88 const BdrvChildRole
*child_role
, Error
**errp
);
90 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
91 /* If non-zero, use only whitelisted block drivers */
92 static int use_bdrv_whitelist
;
95 static int is_windows_drive_prefix(const char *filename
)
97 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
98 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
102 int is_windows_drive(const char *filename
)
104 if (is_windows_drive_prefix(filename
) &&
107 if (strstart(filename
, "\\\\.\\", NULL
) ||
108 strstart(filename
, "//./", NULL
))
114 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
116 if (!bs
|| !bs
->drv
) {
117 /* page size or 4k (hdd sector size) should be on the safe side */
118 return MAX(4096, getpagesize());
121 return bs
->bl
.opt_mem_alignment
;
124 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
126 if (!bs
|| !bs
->drv
) {
127 /* page size or 4k (hdd sector size) should be on the safe side */
128 return MAX(4096, getpagesize());
131 return bs
->bl
.min_mem_alignment
;
134 /* check if the path starts with "<protocol>:" */
135 int path_has_protocol(const char *path
)
140 if (is_windows_drive(path
) ||
141 is_windows_drive_prefix(path
)) {
144 p
= path
+ strcspn(path
, ":/\\");
146 p
= path
+ strcspn(path
, ":/");
152 int path_is_absolute(const char *path
)
155 /* specific case for names like: "\\.\d:" */
156 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
159 return (*path
== '/' || *path
== '\\');
161 return (*path
== '/');
165 /* if filename is absolute, just copy it to dest. Otherwise, build a
166 path to it by considering it is relative to base_path. URL are
168 void path_combine(char *dest
, int dest_size
,
169 const char *base_path
,
170 const char *filename
)
177 if (path_is_absolute(filename
)) {
178 pstrcpy(dest
, dest_size
, filename
);
180 p
= strchr(base_path
, ':');
185 p1
= strrchr(base_path
, '/');
189 p2
= strrchr(base_path
, '\\');
201 if (len
> dest_size
- 1)
203 memcpy(dest
, base_path
, len
);
205 pstrcat(dest
, dest_size
, filename
);
209 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
211 char *dest
, size_t sz
,
214 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
215 path_is_absolute(backing
))
217 pstrcpy(dest
, sz
, backing
);
218 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
219 error_setg(errp
, "Cannot use relative backing file names for '%s'",
222 path_combine(dest
, sz
, backed
, backing
);
226 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
229 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
231 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
235 void bdrv_register(BlockDriver
*bdrv
)
237 bdrv_setup_io_funcs(bdrv
);
239 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
242 BlockDriverState
*bdrv_new_root(void)
244 BlockDriverState
*bs
= bdrv_new();
246 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
250 BlockDriverState
*bdrv_new(void)
252 BlockDriverState
*bs
;
255 bs
= g_new0(BlockDriverState
, 1);
256 QLIST_INIT(&bs
->dirty_bitmaps
);
257 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
258 QLIST_INIT(&bs
->op_blockers
[i
]);
260 bdrv_iostatus_disable(bs
);
261 notifier_list_init(&bs
->close_notifiers
);
262 notifier_with_return_list_init(&bs
->before_write_notifiers
);
263 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
264 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
266 bs
->aio_context
= qemu_get_aio_context();
271 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
273 notifier_list_add(&bs
->close_notifiers
, notify
);
276 BlockDriver
*bdrv_find_format(const char *format_name
)
279 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
280 if (!strcmp(drv1
->format_name
, format_name
)) {
287 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
289 static const char *whitelist_rw
[] = {
290 CONFIG_BDRV_RW_WHITELIST
292 static const char *whitelist_ro
[] = {
293 CONFIG_BDRV_RO_WHITELIST
297 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
298 return 1; /* no whitelist, anything goes */
301 for (p
= whitelist_rw
; *p
; p
++) {
302 if (!strcmp(drv
->format_name
, *p
)) {
307 for (p
= whitelist_ro
; *p
; p
++) {
308 if (!strcmp(drv
->format_name
, *p
)) {
316 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
319 BlockDriver
*drv
= bdrv_find_format(format_name
);
320 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
323 typedef struct CreateCo
{
331 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
333 Error
*local_err
= NULL
;
336 CreateCo
*cco
= opaque
;
339 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
341 error_propagate(&cco
->err
, local_err
);
346 int bdrv_create(BlockDriver
*drv
, const char* filename
,
347 QemuOpts
*opts
, Error
**errp
)
354 .filename
= g_strdup(filename
),
360 if (!drv
->bdrv_create
) {
361 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
366 if (qemu_in_coroutine()) {
367 /* Fast-path if already in coroutine context */
368 bdrv_create_co_entry(&cco
);
370 co
= qemu_coroutine_create(bdrv_create_co_entry
);
371 qemu_coroutine_enter(co
, &cco
);
372 while (cco
.ret
== NOT_DONE
) {
373 aio_poll(qemu_get_aio_context(), true);
380 error_propagate(errp
, cco
.err
);
382 error_setg_errno(errp
, -ret
, "Could not create image");
387 g_free(cco
.filename
);
391 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
394 Error
*local_err
= NULL
;
397 drv
= bdrv_find_protocol(filename
, true, errp
);
402 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
404 error_propagate(errp
, local_err
);
410 * Try to get @bs's logical and physical block size.
411 * On success, store them in @bsz struct and return 0.
412 * On failure return -errno.
413 * @bs must not be empty.
415 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
417 BlockDriver
*drv
= bs
->drv
;
419 if (drv
&& drv
->bdrv_probe_blocksizes
) {
420 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
427 * Try to get @bs's geometry (cyls, heads, sectors).
428 * On success, store them in @geo struct and return 0.
429 * On failure return -errno.
430 * @bs must not be empty.
432 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
434 BlockDriver
*drv
= bs
->drv
;
436 if (drv
&& drv
->bdrv_probe_geometry
) {
437 return drv
->bdrv_probe_geometry(bs
, geo
);
444 * Create a uniquely-named empty temporary file.
445 * Return 0 upon success, otherwise a negative errno value.
447 int get_tmp_filename(char *filename
, int size
)
450 char temp_dir
[MAX_PATH
];
451 /* GetTempFileName requires that its output buffer (4th param)
452 have length MAX_PATH or greater. */
453 assert(size
>= MAX_PATH
);
454 return (GetTempPath(MAX_PATH
, temp_dir
)
455 && GetTempFileName(temp_dir
, "qem", 0, filename
)
456 ? 0 : -GetLastError());
460 tmpdir
= getenv("TMPDIR");
464 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
467 fd
= mkstemp(filename
);
471 if (close(fd
) != 0) {
480 * Detect host devices. By convention, /dev/cdrom[N] is always
481 * recognized as a host CDROM.
483 static BlockDriver
*find_hdev_driver(const char *filename
)
485 int score_max
= 0, score
;
486 BlockDriver
*drv
= NULL
, *d
;
488 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
489 if (d
->bdrv_probe_device
) {
490 score
= d
->bdrv_probe_device(filename
);
491 if (score
> score_max
) {
501 BlockDriver
*bdrv_find_protocol(const char *filename
,
502 bool allow_protocol_prefix
,
510 /* TODO Drivers without bdrv_file_open must be specified explicitly */
513 * XXX(hch): we really should not let host device detection
514 * override an explicit protocol specification, but moving this
515 * later breaks access to device names with colons in them.
516 * Thanks to the brain-dead persistent naming schemes on udev-
517 * based Linux systems those actually are quite common.
519 drv1
= find_hdev_driver(filename
);
524 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
528 p
= strchr(filename
, ':');
531 if (len
> sizeof(protocol
) - 1)
532 len
= sizeof(protocol
) - 1;
533 memcpy(protocol
, filename
, len
);
534 protocol
[len
] = '\0';
535 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
536 if (drv1
->protocol_name
&&
537 !strcmp(drv1
->protocol_name
, protocol
)) {
542 error_setg(errp
, "Unknown protocol '%s'", protocol
);
547 * Guess image format by probing its contents.
548 * This is not a good idea when your image is raw (CVE-2008-2004), but
549 * we do it anyway for backward compatibility.
551 * @buf contains the image's first @buf_size bytes.
552 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
553 * but can be smaller if the image file is smaller)
554 * @filename is its filename.
556 * For all block drivers, call the bdrv_probe() method to get its
558 * Return the first block driver with the highest probing score.
560 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
561 const char *filename
)
563 int score_max
= 0, score
;
564 BlockDriver
*drv
= NULL
, *d
;
566 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
568 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
569 if (score
> score_max
) {
579 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
580 BlockDriver
**pdrv
, Error
**errp
)
583 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
586 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
587 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
592 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
594 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
600 drv
= bdrv_probe_all(buf
, ret
, filename
);
602 error_setg(errp
, "Could not determine image format: No compatible "
611 * Set the current 'total_sectors' value
612 * Return 0 on success, -errno on error.
614 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
616 BlockDriver
*drv
= bs
->drv
;
618 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
622 /* query actual device if possible, otherwise just trust the hint */
623 if (drv
->bdrv_getlength
) {
624 int64_t length
= drv
->bdrv_getlength(bs
);
628 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
631 bs
->total_sectors
= hint
;
636 * Set open flags for a given discard mode
638 * Return 0 on success, -1 if the discard mode was invalid.
640 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
642 *flags
&= ~BDRV_O_UNMAP
;
644 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
646 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
647 *flags
|= BDRV_O_UNMAP
;
656 * Set open flags for a given cache mode
658 * Return 0 on success, -1 if the cache mode was invalid.
660 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
662 *flags
&= ~BDRV_O_CACHE_MASK
;
664 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
665 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
666 } else if (!strcmp(mode
, "directsync")) {
667 *flags
|= BDRV_O_NOCACHE
;
668 } else if (!strcmp(mode
, "writeback")) {
669 *flags
|= BDRV_O_CACHE_WB
;
670 } else if (!strcmp(mode
, "unsafe")) {
671 *flags
|= BDRV_O_CACHE_WB
;
672 *flags
|= BDRV_O_NO_FLUSH
;
673 } else if (!strcmp(mode
, "writethrough")) {
674 /* this is the default */
683 * Returns the flags that a temporary snapshot should get, based on the
684 * originally requested flags (the originally requested image will have flags
685 * like a backing file)
687 static int bdrv_temp_snapshot_flags(int flags
)
689 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
693 * Returns the flags that bs->file should get if a protocol driver is expected,
694 * based on the given flags for the parent BDS
696 static int bdrv_inherited_flags(int flags
)
698 /* Enable protocol handling, disable format probing for bs->file */
699 flags
|= BDRV_O_PROTOCOL
;
701 /* Our block drivers take care to send flushes and respect unmap policy,
702 * so we can enable both unconditionally on lower layers. */
703 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
705 /* Clear flags that only apply to the top layer */
706 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
711 const BdrvChildRole child_file
= {
712 .inherit_flags
= bdrv_inherited_flags
,
716 * Returns the flags that bs->file should get if the use of formats (and not
717 * only protocols) is permitted for it, based on the given flags for the parent
720 static int bdrv_inherited_fmt_flags(int parent_flags
)
722 int flags
= child_file
.inherit_flags(parent_flags
);
723 return flags
& ~BDRV_O_PROTOCOL
;
726 const BdrvChildRole child_format
= {
727 .inherit_flags
= bdrv_inherited_fmt_flags
,
731 * Returns the flags that bs->backing_hd should get, based on the given flags
734 static int bdrv_backing_flags(int flags
)
736 /* backing files always opened read-only */
737 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
739 /* snapshot=on is handled on the top layer */
740 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
745 static const BdrvChildRole child_backing
= {
746 .inherit_flags
= bdrv_backing_flags
,
749 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
751 int open_flags
= flags
| BDRV_O_CACHE_WB
;
754 * Clear flags that are internal to the block layer before opening the
757 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
760 * Snapshots should be writable.
762 if (flags
& BDRV_O_TEMPORARY
) {
763 open_flags
|= BDRV_O_RDWR
;
769 static void bdrv_assign_node_name(BlockDriverState
*bs
,
770 const char *node_name
,
777 /* Check for empty string or invalid characters */
778 if (!id_wellformed(node_name
)) {
779 error_setg(errp
, "Invalid node name");
783 /* takes care of avoiding namespaces collisions */
784 if (blk_by_name(node_name
)) {
785 error_setg(errp
, "node-name=%s is conflicting with a device id",
790 /* takes care of avoiding duplicates node names */
791 if (bdrv_find_node(node_name
)) {
792 error_setg(errp
, "Duplicate node name");
796 /* copy node name into the bs and insert it into the graph list */
797 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
798 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
801 static QemuOptsList bdrv_runtime_opts
= {
802 .name
= "bdrv_common",
803 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
807 .type
= QEMU_OPT_STRING
,
808 .help
= "Node name of the block device node",
810 { /* end of list */ }
815 * Common part for opening disk images and files
817 * Removes all processed options from *options.
819 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
820 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
823 const char *filename
;
824 const char *node_name
= NULL
;
826 Error
*local_err
= NULL
;
829 assert(bs
->file
== NULL
);
830 assert(options
!= NULL
&& bs
->options
!= options
);
833 filename
= file
->filename
;
835 filename
= qdict_get_try_str(options
, "filename");
838 if (drv
->bdrv_needs_filename
&& !filename
) {
839 error_setg(errp
, "The '%s' block driver requires a file name",
844 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
846 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
847 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
849 error_propagate(errp
, local_err
);
854 node_name
= qemu_opt_get(opts
, "node-name");
855 bdrv_assign_node_name(bs
, node_name
, &local_err
);
857 error_propagate(errp
, local_err
);
862 bs
->guest_block_size
= 512;
863 bs
->request_alignment
= 512;
864 bs
->zero_beyond_eof
= true;
865 open_flags
= bdrv_open_flags(bs
, flags
);
866 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
868 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
870 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
871 ? "Driver '%s' can only be used for read-only devices"
872 : "Driver '%s' is not whitelisted",
878 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
879 if (flags
& BDRV_O_COPY_ON_READ
) {
880 if (!bs
->read_only
) {
881 bdrv_enable_copy_on_read(bs
);
883 error_setg(errp
, "Can't use copy-on-read on read-only device");
889 if (filename
!= NULL
) {
890 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
892 bs
->filename
[0] = '\0';
894 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
897 bs
->opaque
= g_malloc0(drv
->instance_size
);
899 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
901 /* Open the image, either directly or using a protocol */
902 if (drv
->bdrv_file_open
) {
903 assert(file
== NULL
);
904 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
905 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
908 error_setg(errp
, "Can't use '%s' as a block driver for the "
909 "protocol level", drv
->format_name
);
914 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
919 error_propagate(errp
, local_err
);
920 } else if (bs
->filename
[0]) {
921 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
923 error_setg_errno(errp
, -ret
, "Could not open image");
929 error_report("Encrypted images are deprecated");
930 error_printf("Support for them will be removed in a future release.\n"
931 "You can use 'qemu-img convert' to convert your image"
932 " to an unencrypted one.\n");
935 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
937 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
941 bdrv_refresh_limits(bs
, &local_err
);
943 error_propagate(errp
, local_err
);
948 assert(bdrv_opt_mem_align(bs
) != 0);
949 assert(bdrv_min_mem_align(bs
) != 0);
950 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
965 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
967 QObject
*options_obj
;
971 ret
= strstart(filename
, "json:", &filename
);
974 options_obj
= qobject_from_json(filename
);
976 error_setg(errp
, "Could not parse the JSON options");
980 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
981 qobject_decref(options_obj
);
982 error_setg(errp
, "Invalid JSON object given");
986 options
= qobject_to_qdict(options_obj
);
987 qdict_flatten(options
);
993 * Fills in default options for opening images and converts the legacy
994 * filename/flags pair to option QDict entries.
995 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
996 * block driver has been specified explicitly.
998 static int bdrv_fill_options(QDict
**options
, const char **pfilename
,
999 int *flags
, Error
**errp
)
1001 const char *filename
= *pfilename
;
1002 const char *drvname
;
1003 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1004 bool parse_filename
= false;
1005 BlockDriver
*drv
= NULL
;
1006 Error
*local_err
= NULL
;
1008 /* Parse json: pseudo-protocol */
1009 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1010 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1012 error_propagate(errp
, local_err
);
1016 /* Options given in the filename have lower priority than options
1017 * specified directly */
1018 qdict_join(*options
, json_options
, false);
1019 QDECREF(json_options
);
1020 *pfilename
= filename
= NULL
;
1023 drvname
= qdict_get_try_str(*options
, "driver");
1025 drv
= bdrv_find_format(drvname
);
1027 error_setg(errp
, "Unknown driver '%s'", drvname
);
1030 /* If the user has explicitly specified the driver, this choice should
1031 * override the BDRV_O_PROTOCOL flag */
1032 protocol
= drv
->bdrv_file_open
;
1036 *flags
|= BDRV_O_PROTOCOL
;
1038 *flags
&= ~BDRV_O_PROTOCOL
;
1041 /* Fetch the file name from the options QDict if necessary */
1042 if (protocol
&& filename
) {
1043 if (!qdict_haskey(*options
, "filename")) {
1044 qdict_put(*options
, "filename", qstring_from_str(filename
));
1045 parse_filename
= true;
1047 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1053 /* Find the right block driver */
1054 filename
= qdict_get_try_str(*options
, "filename");
1056 if (!drvname
&& protocol
) {
1058 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1063 drvname
= drv
->format_name
;
1064 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1066 error_setg(errp
, "Must specify either driver or file");
1071 assert(drv
|| !protocol
);
1073 /* Driver-specific filename parsing */
1074 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1075 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1077 error_propagate(errp
, local_err
);
1081 if (!drv
->bdrv_needs_filename
) {
1082 qdict_del(*options
, "filename");
1089 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1090 BlockDriverState
*child_bs
,
1091 const BdrvChildRole
*child_role
)
1093 BdrvChild
*child
= g_new(BdrvChild
, 1);
1094 *child
= (BdrvChild
) {
1099 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1104 static void bdrv_detach_child(BdrvChild
*child
)
1106 QLIST_REMOVE(child
, next
);
1110 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1112 BlockDriverState
*child_bs
= child
->bs
;
1114 if (child
->bs
->inherits_from
== parent
) {
1115 child
->bs
->inherits_from
= NULL
;
1118 bdrv_detach_child(child
);
1119 bdrv_unref(child_bs
);
1122 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1125 if (bs
->backing_hd
) {
1126 assert(bs
->backing_blocker
);
1127 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1128 bdrv_detach_child(bs
->backing_child
);
1129 } else if (backing_hd
) {
1130 error_setg(&bs
->backing_blocker
,
1131 "node is used as backing hd of '%s'",
1132 bdrv_get_device_or_node_name(bs
));
1135 bs
->backing_hd
= backing_hd
;
1137 error_free(bs
->backing_blocker
);
1138 bs
->backing_blocker
= NULL
;
1139 bs
->backing_child
= NULL
;
1142 bs
->backing_child
= bdrv_attach_child(bs
, backing_hd
, &child_backing
);
1143 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1144 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1145 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1146 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1148 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1149 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1150 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1151 bs
->backing_blocker
);
1153 bdrv_refresh_limits(bs
, NULL
);
1157 * Opens the backing file for a BlockDriverState if not yet open
1159 * options is a QDict of options to pass to the block drivers, or NULL for an
1160 * empty set of options. The reference to the QDict is transferred to this
1161 * function (even on failure), so if the caller intends to reuse the dictionary,
1162 * it needs to use QINCREF() before calling bdrv_file_open.
1164 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1166 char *backing_filename
= g_malloc0(PATH_MAX
);
1168 BlockDriverState
*backing_hd
;
1169 Error
*local_err
= NULL
;
1171 if (bs
->backing_hd
!= NULL
) {
1176 /* NULL means an empty set of options */
1177 if (options
== NULL
) {
1178 options
= qdict_new();
1181 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1182 if (qdict_haskey(options
, "file.filename")) {
1183 backing_filename
[0] = '\0';
1184 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1188 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1192 error_propagate(errp
, local_err
);
1198 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1200 error_setg(errp
, "Driver doesn't support backing files");
1205 backing_hd
= bdrv_new();
1207 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1208 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1211 assert(bs
->backing_hd
== NULL
);
1212 ret
= bdrv_open_inherit(&backing_hd
,
1213 *backing_filename
? backing_filename
: NULL
,
1214 NULL
, options
, 0, bs
, &child_backing
, &local_err
);
1216 bdrv_unref(backing_hd
);
1218 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1219 error_setg(errp
, "Could not open backing file: %s",
1220 error_get_pretty(local_err
));
1221 error_free(local_err
);
1225 bdrv_set_backing_hd(bs
, backing_hd
);
1228 g_free(backing_filename
);
1233 * Opens a disk image whose options are given as BlockdevRef in another block
1236 * If allow_none is true, no image will be opened if filename is false and no
1237 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1239 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1240 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1241 * itself, all options starting with "${bdref_key}." are considered part of the
1244 * The BlockdevRef will be removed from the options QDict.
1246 BdrvChild
*bdrv_open_child(const char *filename
,
1247 QDict
*options
, const char *bdref_key
,
1248 BlockDriverState
* parent
,
1249 const BdrvChildRole
*child_role
,
1250 bool allow_none
, Error
**errp
)
1252 BdrvChild
*c
= NULL
;
1253 BlockDriverState
*bs
;
1254 QDict
*image_options
;
1256 char *bdref_key_dot
;
1257 const char *reference
;
1259 assert(child_role
!= NULL
);
1261 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1262 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1263 g_free(bdref_key_dot
);
1265 reference
= qdict_get_try_str(options
, bdref_key
);
1266 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1268 error_setg(errp
, "A block device must be specified for \"%s\"",
1271 QDECREF(image_options
);
1276 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1277 parent
, child_role
, errp
);
1282 c
= bdrv_attach_child(parent
, bs
, child_role
);
1285 qdict_del(options
, bdref_key
);
1290 * This is a version of bdrv_open_child() that returns 0/-EINVAL instead of
1291 * a BdrvChild object.
1293 * If allow_none is true, no image will be opened if filename is false and no
1294 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1296 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1298 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1299 QDict
*options
, const char *bdref_key
,
1300 BlockDriverState
* parent
, const BdrvChildRole
*child_role
,
1301 bool allow_none
, Error
**errp
)
1303 Error
*local_err
= NULL
;
1307 assert(*pbs
== NULL
);
1309 c
= bdrv_open_child(filename
, options
, bdref_key
, parent
, child_role
,
1310 allow_none
, &local_err
);
1312 error_propagate(errp
, local_err
);
1323 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1325 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1326 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1328 QemuOpts
*opts
= NULL
;
1329 QDict
*snapshot_options
;
1330 BlockDriverState
*bs_snapshot
;
1331 Error
*local_err
= NULL
;
1334 /* if snapshot, we create a temporary backing file and open it
1335 instead of opening 'filename' directly */
1337 /* Get the required size from the image */
1338 total_size
= bdrv_getlength(bs
);
1339 if (total_size
< 0) {
1341 error_setg_errno(errp
, -total_size
, "Could not get image size");
1345 /* Create the temporary image */
1346 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1348 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1352 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1354 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1355 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1356 qemu_opts_del(opts
);
1358 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1359 "'%s': %s", tmp_filename
,
1360 error_get_pretty(local_err
));
1361 error_free(local_err
);
1365 /* Prepare a new options QDict for the temporary file */
1366 snapshot_options
= qdict_new();
1367 qdict_put(snapshot_options
, "file.driver",
1368 qstring_from_str("file"));
1369 qdict_put(snapshot_options
, "file.filename",
1370 qstring_from_str(tmp_filename
));
1371 qdict_put(snapshot_options
, "driver",
1372 qstring_from_str("qcow2"));
1374 bs_snapshot
= bdrv_new();
1376 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1379 error_propagate(errp
, local_err
);
1383 bdrv_append(bs_snapshot
, bs
);
1386 g_free(tmp_filename
);
1391 * Opens a disk image (raw, qcow2, vmdk, ...)
1393 * options is a QDict of options to pass to the block drivers, or NULL for an
1394 * empty set of options. The reference to the QDict belongs to the block layer
1395 * after the call (even on failure), so if the caller intends to reuse the
1396 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1398 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1399 * If it is not NULL, the referenced BDS will be reused.
1401 * The reference parameter may be used to specify an existing block device which
1402 * should be opened. If specified, neither options nor a filename may be given,
1403 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1405 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1406 const char *reference
, QDict
*options
, int flags
,
1407 BlockDriverState
*parent
,
1408 const BdrvChildRole
*child_role
, Error
**errp
)
1411 BlockDriverState
*file
= NULL
, *bs
;
1412 BlockDriver
*drv
= NULL
;
1413 const char *drvname
;
1414 Error
*local_err
= NULL
;
1415 int snapshot_flags
= 0;
1418 assert(!child_role
|| !flags
);
1419 assert(!child_role
== !parent
);
1422 bool options_non_empty
= options
? qdict_size(options
) : false;
1426 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1427 "another block device");
1431 if (filename
|| options_non_empty
) {
1432 error_setg(errp
, "Cannot reference an existing block device with "
1433 "additional options or a new filename");
1437 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1452 /* NULL means an empty set of options */
1453 if (options
== NULL
) {
1454 options
= qdict_new();
1458 bs
->inherits_from
= parent
;
1459 flags
= child_role
->inherit_flags(parent
->open_flags
);
1462 ret
= bdrv_fill_options(&options
, &filename
, &flags
, &local_err
);
1467 /* Find the right image format driver */
1468 drvname
= qdict_get_try_str(options
, "driver");
1470 drv
= bdrv_find_format(drvname
);
1471 qdict_del(options
, "driver");
1473 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1479 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1481 bs
->open_flags
= flags
;
1482 bs
->options
= options
;
1483 options
= qdict_clone_shallow(options
);
1485 /* Open image file without format layer */
1486 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1487 if (flags
& BDRV_O_RDWR
) {
1488 flags
|= BDRV_O_ALLOW_RDWR
;
1490 if (flags
& BDRV_O_SNAPSHOT
) {
1491 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1492 flags
= bdrv_backing_flags(flags
);
1495 assert(file
== NULL
);
1496 bs
->open_flags
= flags
;
1497 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1498 bs
, &child_file
, true, &local_err
);
1504 /* Image format probing */
1507 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1512 error_setg(errp
, "Must specify either driver or file");
1517 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1518 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1519 /* file must be NULL if a protocol BDS is about to be created
1520 * (the inverse results in an error message from bdrv_open_common()) */
1521 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1523 /* Open the image */
1524 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1529 if (file
&& (bs
->file
!= file
)) {
1534 /* If there is a backing file, use it */
1535 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1536 QDict
*backing_options
;
1538 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1539 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1541 goto close_and_fail
;
1545 bdrv_refresh_filename(bs
);
1547 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1548 * temporary snapshot afterwards. */
1549 if (snapshot_flags
) {
1550 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1552 goto close_and_fail
;
1556 /* Check if any unknown options were used */
1557 if (options
&& (qdict_size(options
) != 0)) {
1558 const QDictEntry
*entry
= qdict_first(options
);
1559 if (flags
& BDRV_O_PROTOCOL
) {
1560 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1561 "'%s'", drv
->format_name
, entry
->key
);
1563 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1564 "support the option '%s'", drv
->format_name
,
1565 bdrv_get_device_name(bs
), entry
->key
);
1569 goto close_and_fail
;
1572 if (!bdrv_key_required(bs
)) {
1574 blk_dev_change_media_cb(bs
->blk
, true);
1576 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1577 && !runstate_check(RUN_STATE_INMIGRATE
)
1578 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1580 "Guest must be stopped for opening of encrypted image");
1582 goto close_and_fail
;
1593 QDECREF(bs
->options
);
1597 /* If *pbs is NULL, a new BDS has been created in this function and
1598 needs to be freed now. Otherwise, it does not need to be closed,
1599 since it has not really been opened yet. */
1603 error_propagate(errp
, local_err
);
1608 /* See fail path, but now the BDS has to be always closed */
1616 error_propagate(errp
, local_err
);
1621 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1622 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1624 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1628 typedef struct BlockReopenQueueEntry
{
1630 BDRVReopenState state
;
1631 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1632 } BlockReopenQueueEntry
;
1635 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1636 * reopen of multiple devices.
1638 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1639 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1640 * be created and initialized. This newly created BlockReopenQueue should be
1641 * passed back in for subsequent calls that are intended to be of the same
1644 * bs is the BlockDriverState to add to the reopen queue.
1646 * flags contains the open flags for the associated bs
1648 * returns a pointer to bs_queue, which is either the newly allocated
1649 * bs_queue, or the existing bs_queue being used.
1652 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1653 BlockDriverState
*bs
, int flags
)
1657 BlockReopenQueueEntry
*bs_entry
;
1660 if (bs_queue
== NULL
) {
1661 bs_queue
= g_new0(BlockReopenQueue
, 1);
1662 QSIMPLEQ_INIT(bs_queue
);
1665 /* bdrv_open() masks this flag out */
1666 flags
&= ~BDRV_O_PROTOCOL
;
1668 QLIST_FOREACH(child
, &bs
->children
, next
) {
1671 if (child
->bs
->inherits_from
!= bs
) {
1675 child_flags
= child
->role
->inherit_flags(flags
);
1676 bdrv_reopen_queue(bs_queue
, child
->bs
, child_flags
);
1679 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1680 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1682 bs_entry
->state
.bs
= bs
;
1683 bs_entry
->state
.flags
= flags
;
1689 * Reopen multiple BlockDriverStates atomically & transactionally.
1691 * The queue passed in (bs_queue) must have been built up previous
1692 * via bdrv_reopen_queue().
1694 * Reopens all BDS specified in the queue, with the appropriate
1695 * flags. All devices are prepared for reopen, and failure of any
1696 * device will cause all device changes to be abandonded, and intermediate
1699 * If all devices prepare successfully, then the changes are committed
1703 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1706 BlockReopenQueueEntry
*bs_entry
, *next
;
1707 Error
*local_err
= NULL
;
1709 assert(bs_queue
!= NULL
);
1713 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1714 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1715 error_propagate(errp
, local_err
);
1718 bs_entry
->prepared
= true;
1721 /* If we reach this point, we have success and just need to apply the
1724 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1725 bdrv_reopen_commit(&bs_entry
->state
);
1731 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1732 if (ret
&& bs_entry
->prepared
) {
1733 bdrv_reopen_abort(&bs_entry
->state
);
1742 /* Reopen a single BlockDriverState with the specified flags. */
1743 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1746 Error
*local_err
= NULL
;
1747 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1749 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1750 if (local_err
!= NULL
) {
1751 error_propagate(errp
, local_err
);
1758 * Prepares a BlockDriverState for reopen. All changes are staged in the
1759 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1760 * the block driver layer .bdrv_reopen_prepare()
1762 * bs is the BlockDriverState to reopen
1763 * flags are the new open flags
1764 * queue is the reopen queue
1766 * Returns 0 on success, non-zero on error. On error errp will be set
1769 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1770 * It is the responsibility of the caller to then call the abort() or
1771 * commit() for any other BDS that have been left in a prepare() state
1774 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1778 Error
*local_err
= NULL
;
1781 assert(reopen_state
!= NULL
);
1782 assert(reopen_state
->bs
->drv
!= NULL
);
1783 drv
= reopen_state
->bs
->drv
;
1785 /* if we are to stay read-only, do not allow permission change
1787 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1788 reopen_state
->flags
& BDRV_O_RDWR
) {
1789 error_setg(errp
, "Node '%s' is read only",
1790 bdrv_get_device_or_node_name(reopen_state
->bs
));
1795 ret
= bdrv_flush(reopen_state
->bs
);
1797 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1802 if (drv
->bdrv_reopen_prepare
) {
1803 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1805 if (local_err
!= NULL
) {
1806 error_propagate(errp
, local_err
);
1808 error_setg(errp
, "failed while preparing to reopen image '%s'",
1809 reopen_state
->bs
->filename
);
1814 /* It is currently mandatory to have a bdrv_reopen_prepare()
1815 * handler for each supported drv. */
1816 error_setg(errp
, "Block format '%s' used by node '%s' "
1817 "does not support reopening files", drv
->format_name
,
1818 bdrv_get_device_or_node_name(reopen_state
->bs
));
1830 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1831 * makes them final by swapping the staging BlockDriverState contents into
1832 * the active BlockDriverState contents.
1834 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1838 assert(reopen_state
!= NULL
);
1839 drv
= reopen_state
->bs
->drv
;
1840 assert(drv
!= NULL
);
1842 /* If there are any driver level actions to take */
1843 if (drv
->bdrv_reopen_commit
) {
1844 drv
->bdrv_reopen_commit(reopen_state
);
1847 /* set BDS specific flags now */
1848 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1849 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1851 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1853 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1857 * Abort the reopen, and delete and free the staged changes in
1860 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1864 assert(reopen_state
!= NULL
);
1865 drv
= reopen_state
->bs
->drv
;
1866 assert(drv
!= NULL
);
1868 if (drv
->bdrv_reopen_abort
) {
1869 drv
->bdrv_reopen_abort(reopen_state
);
1874 void bdrv_close(BlockDriverState
*bs
)
1876 BdrvAioNotifier
*ban
, *ban_next
;
1879 block_job_cancel_sync(bs
->job
);
1881 bdrv_drain(bs
); /* complete I/O */
1883 bdrv_drain(bs
); /* in case flush left pending I/O */
1884 notifier_list_notify(&bs
->close_notifiers
, bs
);
1887 BdrvChild
*child
, *next
;
1889 bs
->drv
->bdrv_close(bs
);
1891 if (bs
->backing_hd
) {
1892 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1893 bdrv_set_backing_hd(bs
, NULL
);
1894 bdrv_unref(backing_hd
);
1897 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
1898 /* TODO Remove bdrv_unref() from drivers' close function and use
1899 * bdrv_unref_child() here */
1900 if (child
->bs
->inherits_from
== bs
) {
1901 child
->bs
->inherits_from
= NULL
;
1903 bdrv_detach_child(child
);
1909 bs
->copy_on_read
= 0;
1910 bs
->backing_file
[0] = '\0';
1911 bs
->backing_format
[0] = '\0';
1912 bs
->total_sectors
= 0;
1916 bs
->zero_beyond_eof
= false;
1917 QDECREF(bs
->options
);
1919 QDECREF(bs
->full_open_options
);
1920 bs
->full_open_options
= NULL
;
1922 if (bs
->file
!= NULL
) {
1923 bdrv_unref(bs
->file
);
1929 blk_dev_change_media_cb(bs
->blk
, false);
1932 /*throttling disk I/O limits*/
1933 if (bs
->io_limits_enabled
) {
1934 bdrv_io_limits_disable(bs
);
1937 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1940 QLIST_INIT(&bs
->aio_notifiers
);
1943 void bdrv_close_all(void)
1945 BlockDriverState
*bs
;
1947 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1948 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1950 aio_context_acquire(aio_context
);
1952 aio_context_release(aio_context
);
1956 /* make a BlockDriverState anonymous by removing from bdrv_state and
1957 * graph_bdrv_state list.
1958 Also, NULL terminate the device_name to prevent double remove */
1959 void bdrv_make_anon(BlockDriverState
*bs
)
1962 * Take care to remove bs from bdrv_states only when it's actually
1963 * in it. Note that bs->device_list.tqe_prev is initially null,
1964 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1965 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1966 * resetting it to null on remove.
1968 if (bs
->device_list
.tqe_prev
) {
1969 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1970 bs
->device_list
.tqe_prev
= NULL
;
1972 if (bs
->node_name
[0] != '\0') {
1973 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1975 bs
->node_name
[0] = '\0';
1978 static void bdrv_rebind(BlockDriverState
*bs
)
1980 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1981 bs
->drv
->bdrv_rebind(bs
);
1985 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1986 BlockDriverState
*bs_src
)
1988 /* move some fields that need to stay attached to the device */
1991 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1992 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1994 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1996 /* i/o throttled req */
1997 bs_dest
->throttle_state
= bs_src
->throttle_state
,
1998 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1999 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
2000 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
2001 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2002 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2003 memcpy(&bs_dest
->round_robin
,
2004 &bs_src
->round_robin
,
2005 sizeof(bs_dest
->round_robin
));
2006 memcpy(&bs_dest
->throttle_timers
,
2007 &bs_src
->throttle_timers
,
2008 sizeof(ThrottleTimers
));
2011 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2012 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2015 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2016 bs_dest
->iostatus
= bs_src
->iostatus
;
2019 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2021 /* reference count */
2022 bs_dest
->refcnt
= bs_src
->refcnt
;
2025 bs_dest
->job
= bs_src
->job
;
2027 /* keep the same entry in bdrv_states */
2028 bs_dest
->device_list
= bs_src
->device_list
;
2029 bs_dest
->blk
= bs_src
->blk
;
2031 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2032 sizeof(bs_dest
->op_blockers
));
2036 * Swap bs contents for two image chains while they are live,
2037 * while keeping required fields on the BlockDriverState that is
2038 * actually attached to a device.
2040 * This will modify the BlockDriverState fields, and swap contents
2041 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2043 * bs_new must not be attached to a BlockBackend.
2045 * This function does not create any image files.
2047 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2049 BlockDriverState tmp
;
2055 /* The code needs to swap the node_name but simply swapping node_list won't
2056 * work so first remove the nodes from the graph list, do the swap then
2057 * insert them back if needed.
2059 if (bs_new
->node_name
[0] != '\0') {
2060 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2062 if (bs_old
->node_name
[0] != '\0') {
2063 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2066 /* If the BlockDriverState is part of a throttling group acquire
2067 * its lock since we're going to mess with the protected fields.
2068 * Otherwise there's no need to worry since no one else can touch
2070 if (bs_old
->throttle_state
) {
2071 throttle_group_lock(bs_old
);
2074 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2075 assert(!bs_new
->blk
);
2076 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2077 assert(bs_new
->job
== NULL
);
2078 assert(bs_new
->io_limits_enabled
== false);
2079 assert(bs_new
->throttle_state
== NULL
);
2080 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2086 /* there are some fields that should not be swapped, move them back */
2087 bdrv_move_feature_fields(&tmp
, bs_old
);
2088 bdrv_move_feature_fields(bs_old
, bs_new
);
2089 bdrv_move_feature_fields(bs_new
, &tmp
);
2091 /* bs_new must remain unattached */
2092 assert(!bs_new
->blk
);
2094 /* Check a few fields that should remain attached to the device */
2095 assert(bs_new
->job
== NULL
);
2096 assert(bs_new
->io_limits_enabled
== false);
2097 assert(bs_new
->throttle_state
== NULL
);
2098 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2100 /* Release the ThrottleGroup lock */
2101 if (bs_old
->throttle_state
) {
2102 throttle_group_unlock(bs_old
);
2105 /* insert the nodes back into the graph node list if needed */
2106 if (bs_new
->node_name
[0] != '\0') {
2107 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2109 if (bs_old
->node_name
[0] != '\0') {
2110 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2114 * Update lh_first.le_prev for non-empty lists.
2116 * The head of the op blocker list doesn't change because it is moved back
2117 * in bdrv_move_feature_fields().
2119 assert(QLIST_EMPTY(&bs_old
->tracked_requests
));
2120 assert(QLIST_EMPTY(&bs_new
->tracked_requests
));
2122 QLIST_FIX_HEAD_PTR(&bs_new
->children
, next
);
2123 QLIST_FIX_HEAD_PTR(&bs_old
->children
, next
);
2125 /* Update references in bs->opaque and children */
2126 QLIST_FOREACH(child
, &bs_old
->children
, next
) {
2127 if (child
->bs
->inherits_from
== bs_new
) {
2128 child
->bs
->inherits_from
= bs_old
;
2131 QLIST_FOREACH(child
, &bs_new
->children
, next
) {
2132 if (child
->bs
->inherits_from
== bs_old
) {
2133 child
->bs
->inherits_from
= bs_new
;
2137 bdrv_rebind(bs_new
);
2138 bdrv_rebind(bs_old
);
2142 * Add new bs contents at the top of an image chain while the chain is
2143 * live, while keeping required fields on the top layer.
2145 * This will modify the BlockDriverState fields, and swap contents
2146 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2148 * bs_new must not be attached to a BlockBackend.
2150 * This function does not create any image files.
2152 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2154 bdrv_swap(bs_new
, bs_top
);
2156 /* The contents of 'tmp' will become bs_top, as we are
2157 * swapping bs_new and bs_top contents. */
2158 bdrv_set_backing_hd(bs_top
, bs_new
);
2161 static void bdrv_delete(BlockDriverState
*bs
)
2164 assert(bdrv_op_blocker_is_empty(bs
));
2165 assert(!bs
->refcnt
);
2166 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2170 /* remove from list, if necessary */
2177 * Run consistency checks on an image
2179 * Returns 0 if the check could be completed (it doesn't mean that the image is
2180 * free of errors) or -errno when an internal error occurred. The results of the
2181 * check are stored in res.
2183 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2185 if (bs
->drv
== NULL
) {
2188 if (bs
->drv
->bdrv_check
== NULL
) {
2192 memset(res
, 0, sizeof(*res
));
2193 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2196 #define COMMIT_BUF_SECTORS 2048
2198 /* commit COW file into the raw image */
2199 int bdrv_commit(BlockDriverState
*bs
)
2201 BlockDriver
*drv
= bs
->drv
;
2202 int64_t sector
, total_sectors
, length
, backing_length
;
2203 int n
, ro
, open_flags
;
2205 uint8_t *buf
= NULL
;
2210 if (!bs
->backing_hd
) {
2214 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2215 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2219 ro
= bs
->backing_hd
->read_only
;
2220 open_flags
= bs
->backing_hd
->open_flags
;
2223 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2228 length
= bdrv_getlength(bs
);
2234 backing_length
= bdrv_getlength(bs
->backing_hd
);
2235 if (backing_length
< 0) {
2236 ret
= backing_length
;
2240 /* If our top snapshot is larger than the backing file image,
2241 * grow the backing file image if possible. If not possible,
2242 * we must return an error */
2243 if (length
> backing_length
) {
2244 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2250 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2252 /* qemu_try_blockalign() for bs will choose an alignment that works for
2253 * bs->backing_hd as well, so no need to compare the alignment manually. */
2254 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2260 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2261 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2266 ret
= bdrv_read(bs
, sector
, buf
, n
);
2271 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2278 if (drv
->bdrv_make_empty
) {
2279 ret
= drv
->bdrv_make_empty(bs
);
2287 * Make sure all data we wrote to the backing device is actually
2290 if (bs
->backing_hd
) {
2291 bdrv_flush(bs
->backing_hd
);
2299 /* ignoring error return here */
2300 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2306 int bdrv_commit_all(void)
2308 BlockDriverState
*bs
;
2310 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2311 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2313 aio_context_acquire(aio_context
);
2314 if (bs
->drv
&& bs
->backing_hd
) {
2315 int ret
= bdrv_commit(bs
);
2317 aio_context_release(aio_context
);
2321 aio_context_release(aio_context
);
2329 * -EINVAL - backing format specified, but no file
2330 * -ENOSPC - can't update the backing file because no space is left in the
2332 * -ENOTSUP - format driver doesn't support changing the backing file
2334 int bdrv_change_backing_file(BlockDriverState
*bs
,
2335 const char *backing_file
, const char *backing_fmt
)
2337 BlockDriver
*drv
= bs
->drv
;
2340 /* Backing file format doesn't make sense without a backing file */
2341 if (backing_fmt
&& !backing_file
) {
2345 if (drv
->bdrv_change_backing_file
!= NULL
) {
2346 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2352 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2353 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2359 * Finds the image layer in the chain that has 'bs' as its backing file.
2361 * active is the current topmost image.
2363 * Returns NULL if bs is not found in active's image chain,
2364 * or if active == bs.
2366 * Returns the bottommost base image if bs == NULL.
2368 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2369 BlockDriverState
*bs
)
2371 while (active
&& bs
!= active
->backing_hd
) {
2372 active
= active
->backing_hd
;
2378 /* Given a BDS, searches for the base layer. */
2379 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2381 return bdrv_find_overlay(bs
, NULL
);
2384 typedef struct BlkIntermediateStates
{
2385 BlockDriverState
*bs
;
2386 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2387 } BlkIntermediateStates
;
2391 * Drops images above 'base' up to and including 'top', and sets the image
2392 * above 'top' to have base as its backing file.
2394 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2395 * information in 'bs' can be properly updated.
2397 * E.g., this will convert the following chain:
2398 * bottom <- base <- intermediate <- top <- active
2402 * bottom <- base <- active
2404 * It is allowed for bottom==base, in which case it converts:
2406 * base <- intermediate <- top <- active
2412 * If backing_file_str is non-NULL, it will be used when modifying top's
2413 * overlay image metadata.
2416 * if active == top, that is considered an error
2419 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2420 BlockDriverState
*base
, const char *backing_file_str
)
2422 BlockDriverState
*intermediate
;
2423 BlockDriverState
*base_bs
= NULL
;
2424 BlockDriverState
*new_top_bs
= NULL
;
2425 BlkIntermediateStates
*intermediate_state
, *next
;
2428 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2429 QSIMPLEQ_INIT(&states_to_delete
);
2431 if (!top
->drv
|| !base
->drv
) {
2435 new_top_bs
= bdrv_find_overlay(active
, top
);
2437 if (new_top_bs
== NULL
) {
2438 /* we could not find the image above 'top', this is an error */
2442 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2443 * to do, no intermediate images */
2444 if (new_top_bs
->backing_hd
== base
) {
2451 /* now we will go down through the list, and add each BDS we find
2452 * into our deletion queue, until we hit the 'base'
2454 while (intermediate
) {
2455 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2456 intermediate_state
->bs
= intermediate
;
2457 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2459 if (intermediate
->backing_hd
== base
) {
2460 base_bs
= intermediate
->backing_hd
;
2463 intermediate
= intermediate
->backing_hd
;
2465 if (base_bs
== NULL
) {
2466 /* something went wrong, we did not end at the base. safely
2467 * unravel everything, and exit with error */
2471 /* success - we can delete the intermediate states, and link top->base */
2472 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2473 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2474 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2478 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2480 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2481 /* so that bdrv_close() does not recursively close the chain */
2482 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2483 bdrv_unref(intermediate_state
->bs
);
2488 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2489 g_free(intermediate_state
);
2495 * Truncate file to 'offset' bytes (needed only for file protocols)
2497 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2499 BlockDriver
*drv
= bs
->drv
;
2503 if (!drv
->bdrv_truncate
)
2508 ret
= drv
->bdrv_truncate(bs
, offset
);
2510 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2511 bdrv_dirty_bitmap_truncate(bs
);
2513 blk_dev_resize_cb(bs
->blk
);
2520 * Length of a allocated file in bytes. Sparse files are counted by actual
2521 * allocated space. Return < 0 if error or unknown.
2523 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2525 BlockDriver
*drv
= bs
->drv
;
2529 if (drv
->bdrv_get_allocated_file_size
) {
2530 return drv
->bdrv_get_allocated_file_size(bs
);
2533 return bdrv_get_allocated_file_size(bs
->file
);
2539 * Return number of sectors on success, -errno on error.
2541 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2543 BlockDriver
*drv
= bs
->drv
;
2548 if (drv
->has_variable_length
) {
2549 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2554 return bs
->total_sectors
;
2558 * Return length in bytes on success, -errno on error.
2559 * The length is always a multiple of BDRV_SECTOR_SIZE.
2561 int64_t bdrv_getlength(BlockDriverState
*bs
)
2563 int64_t ret
= bdrv_nb_sectors(bs
);
2565 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2566 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2569 /* return 0 as number of sectors if no device present or error */
2570 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2572 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2574 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2577 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2578 BlockdevOnError on_write_error
)
2580 bs
->on_read_error
= on_read_error
;
2581 bs
->on_write_error
= on_write_error
;
2584 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2586 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2589 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2591 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2594 case BLOCKDEV_ON_ERROR_ENOSPC
:
2595 return (error
== ENOSPC
) ?
2596 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2597 case BLOCKDEV_ON_ERROR_STOP
:
2598 return BLOCK_ERROR_ACTION_STOP
;
2599 case BLOCKDEV_ON_ERROR_REPORT
:
2600 return BLOCK_ERROR_ACTION_REPORT
;
2601 case BLOCKDEV_ON_ERROR_IGNORE
:
2602 return BLOCK_ERROR_ACTION_IGNORE
;
2608 static void send_qmp_error_event(BlockDriverState
*bs
,
2609 BlockErrorAction action
,
2610 bool is_read
, int error
)
2612 IoOperationType optype
;
2614 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2615 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2616 bdrv_iostatus_is_enabled(bs
),
2617 error
== ENOSPC
, strerror(error
),
2621 /* This is done by device models because, while the block layer knows
2622 * about the error, it does not know whether an operation comes from
2623 * the device or the block layer (from a job, for example).
2625 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2626 bool is_read
, int error
)
2630 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2631 /* First set the iostatus, so that "info block" returns an iostatus
2632 * that matches the events raised so far (an additional error iostatus
2633 * is fine, but not a lost one).
2635 bdrv_iostatus_set_err(bs
, error
);
2637 /* Then raise the request to stop the VM and the event.
2638 * qemu_system_vmstop_request_prepare has two effects. First,
2639 * it ensures that the STOP event always comes after the
2640 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2641 * can observe the STOP event and do a "cont" before the STOP
2642 * event is issued, the VM will not stop. In this case, vm_start()
2643 * also ensures that the STOP/RESUME pair of events is emitted.
2645 qemu_system_vmstop_request_prepare();
2646 send_qmp_error_event(bs
, action
, is_read
, error
);
2647 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2649 send_qmp_error_event(bs
, action
, is_read
, error
);
2653 int bdrv_is_read_only(BlockDriverState
*bs
)
2655 return bs
->read_only
;
2658 int bdrv_is_sg(BlockDriverState
*bs
)
2663 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2665 return bs
->enable_write_cache
;
2668 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2670 bs
->enable_write_cache
= wce
;
2672 /* so a reopen() will preserve wce */
2674 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2676 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2680 int bdrv_is_encrypted(BlockDriverState
*bs
)
2682 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2684 return bs
->encrypted
;
2687 int bdrv_key_required(BlockDriverState
*bs
)
2689 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2691 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2693 return (bs
->encrypted
&& !bs
->valid_key
);
2696 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2699 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2700 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2706 if (!bs
->encrypted
) {
2708 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2711 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2714 } else if (!bs
->valid_key
) {
2717 /* call the change callback now, we skipped it on open */
2718 blk_dev_change_media_cb(bs
->blk
, true);
2725 * Provide an encryption key for @bs.
2726 * If @key is non-null:
2727 * If @bs is not encrypted, fail.
2728 * Else if the key is invalid, fail.
2729 * Else set @bs's key to @key, replacing the existing key, if any.
2731 * If @bs is encrypted and still lacks a key, fail.
2733 * On failure, store an error object through @errp if non-null.
2735 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2738 if (!bdrv_is_encrypted(bs
)) {
2739 error_setg(errp
, "Node '%s' is not encrypted",
2740 bdrv_get_device_or_node_name(bs
));
2741 } else if (bdrv_set_key(bs
, key
) < 0) {
2742 error_setg(errp
, QERR_INVALID_PASSWORD
);
2745 if (bdrv_key_required(bs
)) {
2746 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2747 "'%s' (%s) is encrypted",
2748 bdrv_get_device_or_node_name(bs
),
2749 bdrv_get_encrypted_filename(bs
));
2754 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2756 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2759 static int qsort_strcmp(const void *a
, const void *b
)
2761 return strcmp(a
, b
);
2764 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2770 const char **formats
= NULL
;
2772 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2773 if (drv
->format_name
) {
2776 while (formats
&& i
&& !found
) {
2777 found
= !strcmp(formats
[--i
], drv
->format_name
);
2781 formats
= g_renew(const char *, formats
, count
+ 1);
2782 formats
[count
++] = drv
->format_name
;
2787 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2789 for (i
= 0; i
< count
; i
++) {
2790 it(opaque
, formats
[i
]);
2796 /* This function is to find a node in the bs graph */
2797 BlockDriverState
*bdrv_find_node(const char *node_name
)
2799 BlockDriverState
*bs
;
2803 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2804 if (!strcmp(node_name
, bs
->node_name
)) {
2811 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2812 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2814 BlockDeviceInfoList
*list
, *entry
;
2815 BlockDriverState
*bs
;
2818 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2819 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2821 qapi_free_BlockDeviceInfoList(list
);
2824 entry
= g_malloc0(sizeof(*entry
));
2825 entry
->value
= info
;
2833 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2834 const char *node_name
,
2838 BlockDriverState
*bs
;
2841 blk
= blk_by_name(device
);
2849 bs
= bdrv_find_node(node_name
);
2856 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2857 device
? device
: "",
2858 node_name
? node_name
: "");
2862 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2863 * return false. If either argument is NULL, return false. */
2864 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2866 while (top
&& top
!= base
) {
2867 top
= top
->backing_hd
;
2873 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2876 return QTAILQ_FIRST(&graph_bdrv_states
);
2878 return QTAILQ_NEXT(bs
, node_list
);
2881 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2884 return QTAILQ_FIRST(&bdrv_states
);
2886 return QTAILQ_NEXT(bs
, device_list
);
2889 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2891 return bs
->node_name
;
2894 /* TODO check what callers really want: bs->node_name or blk_name() */
2895 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2897 return bs
->blk
? blk_name(bs
->blk
) : "";
2900 /* This can be used to identify nodes that might not have a device
2901 * name associated. Since node and device names live in the same
2902 * namespace, the result is unambiguous. The exception is if both are
2903 * absent, then this returns an empty (non-null) string. */
2904 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2906 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2909 int bdrv_get_flags(BlockDriverState
*bs
)
2911 return bs
->open_flags
;
2914 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2919 int bdrv_has_zero_init(BlockDriverState
*bs
)
2923 /* If BS is a copy on write image, it is initialized to
2924 the contents of the base image, which may not be zeroes. */
2925 if (bs
->backing_hd
) {
2928 if (bs
->drv
->bdrv_has_zero_init
) {
2929 return bs
->drv
->bdrv_has_zero_init(bs
);
2936 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2938 BlockDriverInfo bdi
;
2940 if (bs
->backing_hd
) {
2944 if (bdrv_get_info(bs
, &bdi
) == 0) {
2945 return bdi
.unallocated_blocks_are_zero
;
2951 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2953 BlockDriverInfo bdi
;
2955 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2959 if (bdrv_get_info(bs
, &bdi
) == 0) {
2960 return bdi
.can_write_zeroes_with_unmap
;
2966 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2968 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2969 return bs
->backing_file
;
2970 else if (bs
->encrypted
)
2971 return bs
->filename
;
2976 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2977 char *filename
, int filename_size
)
2979 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2982 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2984 BlockDriver
*drv
= bs
->drv
;
2987 if (!drv
->bdrv_get_info
)
2989 memset(bdi
, 0, sizeof(*bdi
));
2990 return drv
->bdrv_get_info(bs
, bdi
);
2993 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2995 BlockDriver
*drv
= bs
->drv
;
2996 if (drv
&& drv
->bdrv_get_specific_info
) {
2997 return drv
->bdrv_get_specific_info(bs
);
3002 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
3004 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3008 bs
->drv
->bdrv_debug_event(bs
, event
);
3011 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3014 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3018 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3019 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3025 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3027 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3031 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3032 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3038 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3040 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3044 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3045 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3051 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3053 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3057 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3058 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3064 int bdrv_is_snapshot(BlockDriverState
*bs
)
3066 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3069 /* backing_file can either be relative, or absolute, or a protocol. If it is
3070 * relative, it must be relative to the chain. So, passing in bs->filename
3071 * from a BDS as backing_file should not be done, as that may be relative to
3072 * the CWD rather than the chain. */
3073 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3074 const char *backing_file
)
3076 char *filename_full
= NULL
;
3077 char *backing_file_full
= NULL
;
3078 char *filename_tmp
= NULL
;
3079 int is_protocol
= 0;
3080 BlockDriverState
*curr_bs
= NULL
;
3081 BlockDriverState
*retval
= NULL
;
3083 if (!bs
|| !bs
->drv
|| !backing_file
) {
3087 filename_full
= g_malloc(PATH_MAX
);
3088 backing_file_full
= g_malloc(PATH_MAX
);
3089 filename_tmp
= g_malloc(PATH_MAX
);
3091 is_protocol
= path_has_protocol(backing_file
);
3093 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3095 /* If either of the filename paths is actually a protocol, then
3096 * compare unmodified paths; otherwise make paths relative */
3097 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3098 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3099 retval
= curr_bs
->backing_hd
;
3103 /* If not an absolute filename path, make it relative to the current
3104 * image's filename path */
3105 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3108 /* We are going to compare absolute pathnames */
3109 if (!realpath(filename_tmp
, filename_full
)) {
3113 /* We need to make sure the backing filename we are comparing against
3114 * is relative to the current image filename (or absolute) */
3115 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3116 curr_bs
->backing_file
);
3118 if (!realpath(filename_tmp
, backing_file_full
)) {
3122 if (strcmp(backing_file_full
, filename_full
) == 0) {
3123 retval
= curr_bs
->backing_hd
;
3129 g_free(filename_full
);
3130 g_free(backing_file_full
);
3131 g_free(filename_tmp
);
3135 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3141 if (!bs
->backing_hd
) {
3145 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3148 void bdrv_init(void)
3150 module_call_init(MODULE_INIT_BLOCK
);
3153 void bdrv_init_with_whitelist(void)
3155 use_bdrv_whitelist
= 1;
3159 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3161 Error
*local_err
= NULL
;
3168 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3171 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3173 if (bs
->drv
->bdrv_invalidate_cache
) {
3174 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3175 } else if (bs
->file
) {
3176 bdrv_invalidate_cache(bs
->file
, &local_err
);
3179 error_propagate(errp
, local_err
);
3183 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3185 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3190 void bdrv_invalidate_cache_all(Error
**errp
)
3192 BlockDriverState
*bs
;
3193 Error
*local_err
= NULL
;
3195 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3196 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3198 aio_context_acquire(aio_context
);
3199 bdrv_invalidate_cache(bs
, &local_err
);
3200 aio_context_release(aio_context
);
3202 error_propagate(errp
, local_err
);
3208 /**************************************************************/
3209 /* removable device support */
3212 * Return TRUE if the media is present
3214 int bdrv_is_inserted(BlockDriverState
*bs
)
3216 BlockDriver
*drv
= bs
->drv
;
3220 if (!drv
->bdrv_is_inserted
)
3222 return drv
->bdrv_is_inserted(bs
);
3226 * Return whether the media changed since the last call to this
3227 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3229 int bdrv_media_changed(BlockDriverState
*bs
)
3231 BlockDriver
*drv
= bs
->drv
;
3233 if (drv
&& drv
->bdrv_media_changed
) {
3234 return drv
->bdrv_media_changed(bs
);
3240 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3242 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3244 BlockDriver
*drv
= bs
->drv
;
3245 const char *device_name
;
3247 if (drv
&& drv
->bdrv_eject
) {
3248 drv
->bdrv_eject(bs
, eject_flag
);
3251 device_name
= bdrv_get_device_name(bs
);
3252 if (device_name
[0] != '\0') {
3253 qapi_event_send_device_tray_moved(device_name
,
3254 eject_flag
, &error_abort
);
3259 * Lock or unlock the media (if it is locked, the user won't be able
3260 * to eject it manually).
3262 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3264 BlockDriver
*drv
= bs
->drv
;
3266 trace_bdrv_lock_medium(bs
, locked
);
3268 if (drv
&& drv
->bdrv_lock_medium
) {
3269 drv
->bdrv_lock_medium(bs
, locked
);
3273 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3275 bs
->guest_block_size
= align
;
3278 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3280 BdrvDirtyBitmap
*bm
;
3283 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3284 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3291 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3293 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3294 g_free(bitmap
->name
);
3295 bitmap
->name
= NULL
;
3298 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3299 uint32_t granularity
,
3303 int64_t bitmap_size
;
3304 BdrvDirtyBitmap
*bitmap
;
3305 uint32_t sector_granularity
;
3307 assert((granularity
& (granularity
- 1)) == 0);
3309 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3310 error_setg(errp
, "Bitmap already exists: %s", name
);
3313 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3314 assert(sector_granularity
);
3315 bitmap_size
= bdrv_nb_sectors(bs
);
3316 if (bitmap_size
< 0) {
3317 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3318 errno
= -bitmap_size
;
3321 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3322 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3323 bitmap
->size
= bitmap_size
;
3324 bitmap
->name
= g_strdup(name
);
3325 bitmap
->disabled
= false;
3326 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3330 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3332 return bitmap
->successor
;
3335 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3337 return !(bitmap
->disabled
|| bitmap
->successor
);
3340 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3342 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3343 return DIRTY_BITMAP_STATUS_FROZEN
;
3344 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3345 return DIRTY_BITMAP_STATUS_DISABLED
;
3347 return DIRTY_BITMAP_STATUS_ACTIVE
;
3352 * Create a successor bitmap destined to replace this bitmap after an operation.
3353 * Requires that the bitmap is not frozen and has no successor.
3355 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3356 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3358 uint64_t granularity
;
3359 BdrvDirtyBitmap
*child
;
3361 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3362 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3363 "currently frozen");
3366 assert(!bitmap
->successor
);
3368 /* Create an anonymous successor */
3369 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3370 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3375 /* Successor will be on or off based on our current state. */
3376 child
->disabled
= bitmap
->disabled
;
3378 /* Install the successor and freeze the parent */
3379 bitmap
->successor
= child
;
3384 * For a bitmap with a successor, yield our name to the successor,
3385 * delete the old bitmap, and return a handle to the new bitmap.
3387 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3388 BdrvDirtyBitmap
*bitmap
,
3392 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3394 if (successor
== NULL
) {
3395 error_setg(errp
, "Cannot relinquish control if "
3396 "there's no successor present");
3400 name
= bitmap
->name
;
3401 bitmap
->name
= NULL
;
3402 successor
->name
= name
;
3403 bitmap
->successor
= NULL
;
3404 bdrv_release_dirty_bitmap(bs
, bitmap
);
3410 * In cases of failure where we can no longer safely delete the parent,
3411 * we may wish to re-join the parent and child/successor.
3412 * The merged parent will be un-frozen, but not explicitly re-enabled.
3414 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3415 BdrvDirtyBitmap
*parent
,
3418 BdrvDirtyBitmap
*successor
= parent
->successor
;
3421 error_setg(errp
, "Cannot reclaim a successor when none is present");
3425 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3426 error_setg(errp
, "Merging of parent and successor bitmap failed");
3429 bdrv_release_dirty_bitmap(bs
, successor
);
3430 parent
->successor
= NULL
;
3436 * Truncates _all_ bitmaps attached to a BDS.
3438 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3440 BdrvDirtyBitmap
*bitmap
;
3441 uint64_t size
= bdrv_nb_sectors(bs
);
3443 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3444 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3445 hbitmap_truncate(bitmap
->bitmap
, size
);
3446 bitmap
->size
= size
;
3450 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3452 BdrvDirtyBitmap
*bm
, *next
;
3453 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3455 assert(!bdrv_dirty_bitmap_frozen(bm
));
3456 QLIST_REMOVE(bitmap
, list
);
3457 hbitmap_free(bitmap
->bitmap
);
3458 g_free(bitmap
->name
);
3465 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3467 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3468 bitmap
->disabled
= true;
3471 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3473 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3474 bitmap
->disabled
= false;
3477 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3479 BdrvDirtyBitmap
*bm
;
3480 BlockDirtyInfoList
*list
= NULL
;
3481 BlockDirtyInfoList
**plist
= &list
;
3483 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3484 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3485 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3486 info
->count
= bdrv_get_dirty_count(bm
);
3487 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3488 info
->has_name
= !!bm
->name
;
3489 info
->name
= g_strdup(bm
->name
);
3490 info
->status
= bdrv_dirty_bitmap_status(bm
);
3491 entry
->value
= info
;
3493 plist
= &entry
->next
;
3499 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3502 return hbitmap_get(bitmap
->bitmap
, sector
);
3509 * Chooses a default granularity based on the existing cluster size,
3510 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3511 * is no cluster size information available.
3513 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3515 BlockDriverInfo bdi
;
3516 uint32_t granularity
;
3518 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3519 granularity
= MAX(4096, bdi
.cluster_size
);
3520 granularity
= MIN(65536, granularity
);
3522 granularity
= 65536;
3528 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3530 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3533 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3535 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3538 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3539 int64_t cur_sector
, int nr_sectors
)
3541 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3542 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3545 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3546 int64_t cur_sector
, int nr_sectors
)
3548 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3549 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3552 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3554 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3555 hbitmap_reset_all(bitmap
->bitmap
);
3558 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3561 BdrvDirtyBitmap
*bitmap
;
3562 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3563 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3566 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3571 * Advance an HBitmapIter to an arbitrary offset.
3573 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3576 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3579 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3581 return hbitmap_count(bitmap
->bitmap
);
3584 /* Get a reference to bs */
3585 void bdrv_ref(BlockDriverState
*bs
)
3590 /* Release a previously grabbed reference to bs.
3591 * If after releasing, reference count is zero, the BlockDriverState is
3593 void bdrv_unref(BlockDriverState
*bs
)
3598 assert(bs
->refcnt
> 0);
3599 if (--bs
->refcnt
== 0) {
3604 struct BdrvOpBlocker
{
3606 QLIST_ENTRY(BdrvOpBlocker
) list
;
3609 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3611 BdrvOpBlocker
*blocker
;
3612 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3613 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3614 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3616 error_setg(errp
, "Node '%s' is busy: %s",
3617 bdrv_get_device_or_node_name(bs
),
3618 error_get_pretty(blocker
->reason
));
3625 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3627 BdrvOpBlocker
*blocker
;
3628 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3630 blocker
= g_new0(BdrvOpBlocker
, 1);
3631 blocker
->reason
= reason
;
3632 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3635 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3637 BdrvOpBlocker
*blocker
, *next
;
3638 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3639 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3640 if (blocker
->reason
== reason
) {
3641 QLIST_REMOVE(blocker
, list
);
3647 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3650 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3651 bdrv_op_block(bs
, i
, reason
);
3655 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3658 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3659 bdrv_op_unblock(bs
, i
, reason
);
3663 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3667 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3668 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3675 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3677 bs
->iostatus_enabled
= true;
3678 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3681 /* The I/O status is only enabled if the drive explicitly
3682 * enables it _and_ the VM is configured to stop on errors */
3683 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3685 return (bs
->iostatus_enabled
&&
3686 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3687 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3688 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3691 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3693 bs
->iostatus_enabled
= false;
3696 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3698 if (bdrv_iostatus_is_enabled(bs
)) {
3699 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3701 block_job_iostatus_reset(bs
->job
);
3706 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3708 assert(bdrv_iostatus_is_enabled(bs
));
3709 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3710 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3711 BLOCK_DEVICE_IO_STATUS_FAILED
;
3715 void bdrv_img_create(const char *filename
, const char *fmt
,
3716 const char *base_filename
, const char *base_fmt
,
3717 char *options
, uint64_t img_size
, int flags
,
3718 Error
**errp
, bool quiet
)
3720 QemuOptsList
*create_opts
= NULL
;
3721 QemuOpts
*opts
= NULL
;
3722 const char *backing_fmt
, *backing_file
;
3724 BlockDriver
*drv
, *proto_drv
;
3725 Error
*local_err
= NULL
;
3728 /* Find driver and parse its options */
3729 drv
= bdrv_find_format(fmt
);
3731 error_setg(errp
, "Unknown file format '%s'", fmt
);
3735 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3740 if (!drv
->create_opts
) {
3741 error_setg(errp
, "Format driver '%s' does not support image creation",
3746 if (!proto_drv
->create_opts
) {
3747 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3748 proto_drv
->format_name
);
3752 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3753 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3755 /* Create parameter list with default values */
3756 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3757 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3759 /* Parse -o options */
3761 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3763 error_report_err(local_err
);
3765 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3770 if (base_filename
) {
3771 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3773 error_setg(errp
, "Backing file not supported for file format '%s'",
3780 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3782 error_setg(errp
, "Backing file format not supported for file "
3783 "format '%s'", fmt
);
3788 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3790 if (!strcmp(filename
, backing_file
)) {
3791 error_setg(errp
, "Error: Trying to create an image with the "
3792 "same filename as the backing file");
3797 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3799 // The size for the image must always be specified, with one exception:
3800 // If we are using a backing file, we can obtain the size from there
3801 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3804 BlockDriverState
*bs
;
3805 char *full_backing
= g_new0(char, PATH_MAX
);
3808 QDict
*backing_options
= NULL
;
3810 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3811 full_backing
, PATH_MAX
,
3814 g_free(full_backing
);
3818 /* backing files always opened read-only */
3820 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3823 backing_options
= qdict_new();
3824 qdict_put(backing_options
, "driver",
3825 qstring_from_str(backing_fmt
));
3829 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3830 back_flags
, &local_err
);
3831 g_free(full_backing
);
3835 size
= bdrv_getlength(bs
);
3837 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3843 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3847 error_setg(errp
, "Image creation needs a size parameter");
3853 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3854 qemu_opts_print(opts
, " ");
3858 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3860 if (ret
== -EFBIG
) {
3861 /* This is generally a better message than whatever the driver would
3862 * deliver (especially because of the cluster_size_hint), since that
3863 * is most probably not much different from "image too large". */
3864 const char *cluster_size_hint
= "";
3865 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3866 cluster_size_hint
= " (try using a larger cluster size)";
3868 error_setg(errp
, "The image size is too large for file format '%s'"
3869 "%s", fmt
, cluster_size_hint
);
3870 error_free(local_err
);
3875 qemu_opts_del(opts
);
3876 qemu_opts_free(create_opts
);
3878 error_propagate(errp
, local_err
);
3882 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3884 return bs
->aio_context
;
3887 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3889 BdrvAioNotifier
*baf
;
3895 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3896 baf
->detach_aio_context(baf
->opaque
);
3899 if (bs
->io_limits_enabled
) {
3900 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3902 if (bs
->drv
->bdrv_detach_aio_context
) {
3903 bs
->drv
->bdrv_detach_aio_context(bs
);
3906 bdrv_detach_aio_context(bs
->file
);
3908 if (bs
->backing_hd
) {
3909 bdrv_detach_aio_context(bs
->backing_hd
);
3912 bs
->aio_context
= NULL
;
3915 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3916 AioContext
*new_context
)
3918 BdrvAioNotifier
*ban
;
3924 bs
->aio_context
= new_context
;
3926 if (bs
->backing_hd
) {
3927 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3930 bdrv_attach_aio_context(bs
->file
, new_context
);
3932 if (bs
->drv
->bdrv_attach_aio_context
) {
3933 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3935 if (bs
->io_limits_enabled
) {
3936 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3939 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3940 ban
->attached_aio_context(new_context
, ban
->opaque
);
3944 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3946 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3948 bdrv_detach_aio_context(bs
);
3950 /* This function executes in the old AioContext so acquire the new one in
3951 * case it runs in a different thread.
3953 aio_context_acquire(new_context
);
3954 bdrv_attach_aio_context(bs
, new_context
);
3955 aio_context_release(new_context
);
3958 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3959 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3960 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3962 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3963 *ban
= (BdrvAioNotifier
){
3964 .attached_aio_context
= attached_aio_context
,
3965 .detach_aio_context
= detach_aio_context
,
3969 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3972 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3973 void (*attached_aio_context
)(AioContext
*,
3975 void (*detach_aio_context
)(void *),
3978 BdrvAioNotifier
*ban
, *ban_next
;
3980 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3981 if (ban
->attached_aio_context
== attached_aio_context
&&
3982 ban
->detach_aio_context
== detach_aio_context
&&
3983 ban
->opaque
== opaque
)
3985 QLIST_REMOVE(ban
, list
);
3995 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3996 BlockDriverAmendStatusCB
*status_cb
)
3998 if (!bs
->drv
->bdrv_amend_options
) {
4001 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
4004 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4005 * of block filter and by bdrv_is_first_non_filter.
4006 * It is used to test if the given bs is the candidate or recurse more in the
4009 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
4010 BlockDriverState
*candidate
)
4012 /* return false if basic checks fails */
4013 if (!bs
|| !bs
->drv
) {
4017 /* the code reached a non block filter driver -> check if the bs is
4018 * the same as the candidate. It's the recursion termination condition.
4020 if (!bs
->drv
->is_filter
) {
4021 return bs
== candidate
;
4023 /* Down this path the driver is a block filter driver */
4025 /* If the block filter recursion method is defined use it to recurse down
4028 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4029 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4032 /* the driver is a block filter but don't allow to recurse -> return false
4037 /* This function checks if the candidate is the first non filter bs down it's
4038 * bs chain. Since we don't have pointers to parents it explore all bs chains
4039 * from the top. Some filters can choose not to pass down the recursion.
4041 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4043 BlockDriverState
*bs
;
4045 /* walk down the bs forest recursively */
4046 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4049 /* try to recurse in this top level bs */
4050 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4052 /* candidate is the first non filter */
4061 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
4062 const char *node_name
, Error
**errp
)
4064 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4065 AioContext
*aio_context
;
4067 if (!to_replace_bs
) {
4068 error_setg(errp
, "Node name '%s' not found", node_name
);
4072 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4073 aio_context_acquire(aio_context
);
4075 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4076 to_replace_bs
= NULL
;
4080 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4081 * most non filter in order to prevent data corruption.
4082 * Another benefit is that this tests exclude backing files which are
4083 * blocked by the backing blockers.
4085 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
4086 error_setg(errp
, "Only top most non filter can be replaced");
4087 to_replace_bs
= NULL
;
4092 aio_context_release(aio_context
);
4093 return to_replace_bs
;
4096 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4098 const QDictEntry
*entry
;
4099 bool found_any
= false;
4101 for (entry
= qdict_first(bs
->options
); entry
;
4102 entry
= qdict_next(bs
->options
, entry
))
4104 /* Only take options for this level and exclude all non-driver-specific
4106 if (!strchr(qdict_entry_key(entry
), '.') &&
4107 strcmp(qdict_entry_key(entry
), "node-name"))
4109 qobject_incref(qdict_entry_value(entry
));
4110 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4118 /* Updates the following BDS fields:
4119 * - exact_filename: A filename which may be used for opening a block device
4120 * which (mostly) equals the given BDS (even without any
4121 * other options; so reading and writing must return the same
4122 * results, but caching etc. may be different)
4123 * - full_open_options: Options which, when given when opening a block device
4124 * (without a filename), result in a BDS (mostly)
4125 * equalling the given one
4126 * - filename: If exact_filename is set, it is copied here. Otherwise,
4127 * full_open_options is converted to a JSON object, prefixed with
4128 * "json:" (for use through the JSON pseudo protocol) and put here.
4130 void bdrv_refresh_filename(BlockDriverState
*bs
)
4132 BlockDriver
*drv
= bs
->drv
;
4139 /* This BDS's file name will most probably depend on its file's name, so
4140 * refresh that first */
4142 bdrv_refresh_filename(bs
->file
);
4145 if (drv
->bdrv_refresh_filename
) {
4146 /* Obsolete information is of no use here, so drop the old file name
4147 * information before refreshing it */
4148 bs
->exact_filename
[0] = '\0';
4149 if (bs
->full_open_options
) {
4150 QDECREF(bs
->full_open_options
);
4151 bs
->full_open_options
= NULL
;
4154 drv
->bdrv_refresh_filename(bs
);
4155 } else if (bs
->file
) {
4156 /* Try to reconstruct valid information from the underlying file */
4157 bool has_open_options
;
4159 bs
->exact_filename
[0] = '\0';
4160 if (bs
->full_open_options
) {
4161 QDECREF(bs
->full_open_options
);
4162 bs
->full_open_options
= NULL
;
4166 has_open_options
= append_open_options(opts
, bs
);
4168 /* If no specific options have been given for this BDS, the filename of
4169 * the underlying file should suffice for this one as well */
4170 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
4171 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
4173 /* Reconstructing the full options QDict is simple for most format block
4174 * drivers, as long as the full options are known for the underlying
4175 * file BDS. The full options QDict of that file BDS should somehow
4176 * contain a representation of the filename, therefore the following
4177 * suffices without querying the (exact_)filename of this BDS. */
4178 if (bs
->file
->full_open_options
) {
4179 qdict_put_obj(opts
, "driver",
4180 QOBJECT(qstring_from_str(drv
->format_name
)));
4181 QINCREF(bs
->file
->full_open_options
);
4182 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
4184 bs
->full_open_options
= opts
;
4188 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4189 /* There is no underlying file BDS (at least referenced by BDS.file),
4190 * so the full options QDict should be equal to the options given
4191 * specifically for this block device when it was opened (plus the
4192 * driver specification).
4193 * Because those options don't change, there is no need to update
4194 * full_open_options when it's already set. */
4197 append_open_options(opts
, bs
);
4198 qdict_put_obj(opts
, "driver",
4199 QOBJECT(qstring_from_str(drv
->format_name
)));
4201 if (bs
->exact_filename
[0]) {
4202 /* This may not work for all block protocol drivers (some may
4203 * require this filename to be parsed), but we have to find some
4204 * default solution here, so just include it. If some block driver
4205 * does not support pure options without any filename at all or
4206 * needs some special format of the options QDict, it needs to
4207 * implement the driver-specific bdrv_refresh_filename() function.
4209 qdict_put_obj(opts
, "filename",
4210 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4213 bs
->full_open_options
= opts
;
4216 if (bs
->exact_filename
[0]) {
4217 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4218 } else if (bs
->full_open_options
) {
4219 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4220 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4221 qstring_get_str(json
));
4226 /* This accessor function purpose is to allow the device models to access the
4227 * BlockAcctStats structure embedded inside a BlockDriverState without being
4228 * aware of the BlockDriverState structure layout.
4229 * It will go away when the BlockAcctStats structure will be moved inside
4230 * the device models.
4232 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)