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
,
89 BlockDriver
*drv
, Error
**errp
);
91 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
92 /* If non-zero, use only whitelisted block drivers */
93 static int use_bdrv_whitelist
;
96 static int is_windows_drive_prefix(const char *filename
)
98 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
99 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
103 int is_windows_drive(const char *filename
)
105 if (is_windows_drive_prefix(filename
) &&
108 if (strstart(filename
, "\\\\.\\", NULL
) ||
109 strstart(filename
, "//./", NULL
))
115 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
117 if (!bs
|| !bs
->drv
) {
118 /* page size or 4k (hdd sector size) should be on the safe side */
119 return MAX(4096, getpagesize());
122 return bs
->bl
.opt_mem_alignment
;
125 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
127 if (!bs
|| !bs
->drv
) {
128 /* page size or 4k (hdd sector size) should be on the safe side */
129 return MAX(4096, getpagesize());
132 return bs
->bl
.min_mem_alignment
;
135 /* check if the path starts with "<protocol>:" */
136 int path_has_protocol(const char *path
)
141 if (is_windows_drive(path
) ||
142 is_windows_drive_prefix(path
)) {
145 p
= path
+ strcspn(path
, ":/\\");
147 p
= path
+ strcspn(path
, ":/");
153 int path_is_absolute(const char *path
)
156 /* specific case for names like: "\\.\d:" */
157 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
160 return (*path
== '/' || *path
== '\\');
162 return (*path
== '/');
166 /* if filename is absolute, just copy it to dest. Otherwise, build a
167 path to it by considering it is relative to base_path. URL are
169 void path_combine(char *dest
, int dest_size
,
170 const char *base_path
,
171 const char *filename
)
178 if (path_is_absolute(filename
)) {
179 pstrcpy(dest
, dest_size
, filename
);
181 p
= strchr(base_path
, ':');
186 p1
= strrchr(base_path
, '/');
190 p2
= strrchr(base_path
, '\\');
202 if (len
> dest_size
- 1)
204 memcpy(dest
, base_path
, len
);
206 pstrcat(dest
, dest_size
, filename
);
210 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
212 char *dest
, size_t sz
,
215 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
216 path_is_absolute(backing
))
218 pstrcpy(dest
, sz
, backing
);
219 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
220 error_setg(errp
, "Cannot use relative backing file names for '%s'",
223 path_combine(dest
, sz
, backed
, backing
);
227 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
230 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
232 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
236 void bdrv_register(BlockDriver
*bdrv
)
238 bdrv_setup_io_funcs(bdrv
);
240 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
243 BlockDriverState
*bdrv_new_root(void)
245 BlockDriverState
*bs
= bdrv_new();
247 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
251 BlockDriverState
*bdrv_new(void)
253 BlockDriverState
*bs
;
256 bs
= g_new0(BlockDriverState
, 1);
257 QLIST_INIT(&bs
->dirty_bitmaps
);
258 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
259 QLIST_INIT(&bs
->op_blockers
[i
]);
261 bdrv_iostatus_disable(bs
);
262 notifier_list_init(&bs
->close_notifiers
);
263 notifier_with_return_list_init(&bs
->before_write_notifiers
);
264 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
265 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
267 bs
->aio_context
= qemu_get_aio_context();
272 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
274 notifier_list_add(&bs
->close_notifiers
, notify
);
277 BlockDriver
*bdrv_find_format(const char *format_name
)
280 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
281 if (!strcmp(drv1
->format_name
, format_name
)) {
288 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
290 static const char *whitelist_rw
[] = {
291 CONFIG_BDRV_RW_WHITELIST
293 static const char *whitelist_ro
[] = {
294 CONFIG_BDRV_RO_WHITELIST
298 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
299 return 1; /* no whitelist, anything goes */
302 for (p
= whitelist_rw
; *p
; p
++) {
303 if (!strcmp(drv
->format_name
, *p
)) {
308 for (p
= whitelist_ro
; *p
; p
++) {
309 if (!strcmp(drv
->format_name
, *p
)) {
317 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
320 BlockDriver
*drv
= bdrv_find_format(format_name
);
321 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
324 typedef struct CreateCo
{
332 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
334 Error
*local_err
= NULL
;
337 CreateCo
*cco
= opaque
;
340 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
342 error_propagate(&cco
->err
, local_err
);
347 int bdrv_create(BlockDriver
*drv
, const char* filename
,
348 QemuOpts
*opts
, Error
**errp
)
355 .filename
= g_strdup(filename
),
361 if (!drv
->bdrv_create
) {
362 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
367 if (qemu_in_coroutine()) {
368 /* Fast-path if already in coroutine context */
369 bdrv_create_co_entry(&cco
);
371 co
= qemu_coroutine_create(bdrv_create_co_entry
);
372 qemu_coroutine_enter(co
, &cco
);
373 while (cco
.ret
== NOT_DONE
) {
374 aio_poll(qemu_get_aio_context(), true);
381 error_propagate(errp
, cco
.err
);
383 error_setg_errno(errp
, -ret
, "Could not create image");
388 g_free(cco
.filename
);
392 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
395 Error
*local_err
= NULL
;
398 drv
= bdrv_find_protocol(filename
, true, errp
);
403 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
405 error_propagate(errp
, local_err
);
411 * Try to get @bs's logical and physical block size.
412 * On success, store them in @bsz struct and return 0.
413 * On failure return -errno.
414 * @bs must not be empty.
416 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
418 BlockDriver
*drv
= bs
->drv
;
420 if (drv
&& drv
->bdrv_probe_blocksizes
) {
421 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
428 * Try to get @bs's geometry (cyls, heads, sectors).
429 * On success, store them in @geo struct and return 0.
430 * On failure return -errno.
431 * @bs must not be empty.
433 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
435 BlockDriver
*drv
= bs
->drv
;
437 if (drv
&& drv
->bdrv_probe_geometry
) {
438 return drv
->bdrv_probe_geometry(bs
, geo
);
445 * Create a uniquely-named empty temporary file.
446 * Return 0 upon success, otherwise a negative errno value.
448 int get_tmp_filename(char *filename
, int size
)
451 char temp_dir
[MAX_PATH
];
452 /* GetTempFileName requires that its output buffer (4th param)
453 have length MAX_PATH or greater. */
454 assert(size
>= MAX_PATH
);
455 return (GetTempPath(MAX_PATH
, temp_dir
)
456 && GetTempFileName(temp_dir
, "qem", 0, filename
)
457 ? 0 : -GetLastError());
461 tmpdir
= getenv("TMPDIR");
465 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
468 fd
= mkstemp(filename
);
472 if (close(fd
) != 0) {
481 * Detect host devices. By convention, /dev/cdrom[N] is always
482 * recognized as a host CDROM.
484 static BlockDriver
*find_hdev_driver(const char *filename
)
486 int score_max
= 0, score
;
487 BlockDriver
*drv
= NULL
, *d
;
489 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
490 if (d
->bdrv_probe_device
) {
491 score
= d
->bdrv_probe_device(filename
);
492 if (score
> score_max
) {
502 BlockDriver
*bdrv_find_protocol(const char *filename
,
503 bool allow_protocol_prefix
,
511 /* TODO Drivers without bdrv_file_open must be specified explicitly */
514 * XXX(hch): we really should not let host device detection
515 * override an explicit protocol specification, but moving this
516 * later breaks access to device names with colons in them.
517 * Thanks to the brain-dead persistent naming schemes on udev-
518 * based Linux systems those actually are quite common.
520 drv1
= find_hdev_driver(filename
);
525 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
529 p
= strchr(filename
, ':');
532 if (len
> sizeof(protocol
) - 1)
533 len
= sizeof(protocol
) - 1;
534 memcpy(protocol
, filename
, len
);
535 protocol
[len
] = '\0';
536 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
537 if (drv1
->protocol_name
&&
538 !strcmp(drv1
->protocol_name
, protocol
)) {
543 error_setg(errp
, "Unknown protocol '%s'", protocol
);
548 * Guess image format by probing its contents.
549 * This is not a good idea when your image is raw (CVE-2008-2004), but
550 * we do it anyway for backward compatibility.
552 * @buf contains the image's first @buf_size bytes.
553 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
554 * but can be smaller if the image file is smaller)
555 * @filename is its filename.
557 * For all block drivers, call the bdrv_probe() method to get its
559 * Return the first block driver with the highest probing score.
561 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
562 const char *filename
)
564 int score_max
= 0, score
;
565 BlockDriver
*drv
= NULL
, *d
;
567 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
569 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
570 if (score
> score_max
) {
580 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
581 BlockDriver
**pdrv
, Error
**errp
)
584 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
587 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
588 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
593 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
595 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
601 drv
= bdrv_probe_all(buf
, ret
, filename
);
603 error_setg(errp
, "Could not determine image format: No compatible "
612 * Set the current 'total_sectors' value
613 * Return 0 on success, -errno on error.
615 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
617 BlockDriver
*drv
= bs
->drv
;
619 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
623 /* query actual device if possible, otherwise just trust the hint */
624 if (drv
->bdrv_getlength
) {
625 int64_t length
= drv
->bdrv_getlength(bs
);
629 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
632 bs
->total_sectors
= hint
;
637 * Set open flags for a given discard mode
639 * Return 0 on success, -1 if the discard mode was invalid.
641 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
643 *flags
&= ~BDRV_O_UNMAP
;
645 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
647 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
648 *flags
|= BDRV_O_UNMAP
;
657 * Set open flags for a given cache mode
659 * Return 0 on success, -1 if the cache mode was invalid.
661 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
663 *flags
&= ~BDRV_O_CACHE_MASK
;
665 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
666 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
667 } else if (!strcmp(mode
, "directsync")) {
668 *flags
|= BDRV_O_NOCACHE
;
669 } else if (!strcmp(mode
, "writeback")) {
670 *flags
|= BDRV_O_CACHE_WB
;
671 } else if (!strcmp(mode
, "unsafe")) {
672 *flags
|= BDRV_O_CACHE_WB
;
673 *flags
|= BDRV_O_NO_FLUSH
;
674 } else if (!strcmp(mode
, "writethrough")) {
675 /* this is the default */
684 * Returns the flags that a temporary snapshot should get, based on the
685 * originally requested flags (the originally requested image will have flags
686 * like a backing file)
688 static int bdrv_temp_snapshot_flags(int flags
)
690 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
694 * Returns the flags that bs->file should get if a protocol driver is expected,
695 * based on the given flags for the parent BDS
697 static int bdrv_inherited_flags(int flags
)
699 /* Enable protocol handling, disable format probing for bs->file */
700 flags
|= BDRV_O_PROTOCOL
;
702 /* Our block drivers take care to send flushes and respect unmap policy,
703 * so we can enable both unconditionally on lower layers. */
704 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
706 /* Clear flags that only apply to the top layer */
707 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
712 const BdrvChildRole child_file
= {
713 .inherit_flags
= bdrv_inherited_flags
,
717 * Returns the flags that bs->file should get if the use of formats (and not
718 * only protocols) is permitted for it, based on the given flags for the parent
721 static int bdrv_inherited_fmt_flags(int parent_flags
)
723 int flags
= child_file
.inherit_flags(parent_flags
);
724 return flags
& ~BDRV_O_PROTOCOL
;
727 const BdrvChildRole child_format
= {
728 .inherit_flags
= bdrv_inherited_fmt_flags
,
732 * Returns the flags that bs->backing_hd should get, based on the given flags
735 static int bdrv_backing_flags(int flags
)
737 /* backing files always opened read-only */
738 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
740 /* snapshot=on is handled on the top layer */
741 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
746 static const BdrvChildRole child_backing
= {
747 .inherit_flags
= bdrv_backing_flags
,
750 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
752 int open_flags
= flags
| BDRV_O_CACHE_WB
;
755 * Clear flags that are internal to the block layer before opening the
758 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
761 * Snapshots should be writable.
763 if (flags
& BDRV_O_TEMPORARY
) {
764 open_flags
|= BDRV_O_RDWR
;
770 static void bdrv_assign_node_name(BlockDriverState
*bs
,
771 const char *node_name
,
778 /* Check for empty string or invalid characters */
779 if (!id_wellformed(node_name
)) {
780 error_setg(errp
, "Invalid node name");
784 /* takes care of avoiding namespaces collisions */
785 if (blk_by_name(node_name
)) {
786 error_setg(errp
, "node-name=%s is conflicting with a device id",
791 /* takes care of avoiding duplicates node names */
792 if (bdrv_find_node(node_name
)) {
793 error_setg(errp
, "Duplicate node name");
797 /* copy node name into the bs and insert it into the graph list */
798 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
799 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
802 static QemuOptsList bdrv_runtime_opts
= {
803 .name
= "bdrv_common",
804 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
808 .type
= QEMU_OPT_STRING
,
809 .help
= "Node name of the block device node",
811 { /* end of list */ }
816 * Common part for opening disk images and files
818 * Removes all processed options from *options.
820 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
821 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
824 const char *filename
;
825 const char *node_name
= NULL
;
827 Error
*local_err
= NULL
;
830 assert(bs
->file
== NULL
);
831 assert(options
!= NULL
&& bs
->options
!= options
);
834 filename
= file
->filename
;
836 filename
= qdict_get_try_str(options
, "filename");
839 if (drv
->bdrv_needs_filename
&& !filename
) {
840 error_setg(errp
, "The '%s' block driver requires a file name",
845 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
847 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
848 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
850 error_propagate(errp
, local_err
);
855 node_name
= qemu_opt_get(opts
, "node-name");
856 bdrv_assign_node_name(bs
, node_name
, &local_err
);
858 error_propagate(errp
, local_err
);
863 bs
->guest_block_size
= 512;
864 bs
->request_alignment
= 512;
865 bs
->zero_beyond_eof
= true;
866 open_flags
= bdrv_open_flags(bs
, flags
);
867 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
869 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
871 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
872 ? "Driver '%s' can only be used for read-only devices"
873 : "Driver '%s' is not whitelisted",
879 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
880 if (flags
& BDRV_O_COPY_ON_READ
) {
881 if (!bs
->read_only
) {
882 bdrv_enable_copy_on_read(bs
);
884 error_setg(errp
, "Can't use copy-on-read on read-only device");
890 if (filename
!= NULL
) {
891 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
893 bs
->filename
[0] = '\0';
895 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
898 bs
->opaque
= g_malloc0(drv
->instance_size
);
900 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
902 /* Open the image, either directly or using a protocol */
903 if (drv
->bdrv_file_open
) {
904 assert(file
== NULL
);
905 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
906 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
909 error_setg(errp
, "Can't use '%s' as a block driver for the "
910 "protocol level", drv
->format_name
);
915 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
920 error_propagate(errp
, local_err
);
921 } else if (bs
->filename
[0]) {
922 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
924 error_setg_errno(errp
, -ret
, "Could not open image");
930 error_report("Encrypted images are deprecated");
931 error_printf("Support for them will be removed in a future release.\n"
932 "You can use 'qemu-img convert' to convert your image"
933 " to an unencrypted one.\n");
936 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
938 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
942 bdrv_refresh_limits(bs
, &local_err
);
944 error_propagate(errp
, local_err
);
949 assert(bdrv_opt_mem_align(bs
) != 0);
950 assert(bdrv_min_mem_align(bs
) != 0);
951 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
966 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
968 QObject
*options_obj
;
972 ret
= strstart(filename
, "json:", &filename
);
975 options_obj
= qobject_from_json(filename
);
977 error_setg(errp
, "Could not parse the JSON options");
981 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
982 qobject_decref(options_obj
);
983 error_setg(errp
, "Invalid JSON object given");
987 options
= qobject_to_qdict(options_obj
);
988 qdict_flatten(options
);
994 * Fills in default options for opening images and converts the legacy
995 * filename/flags pair to option QDict entries.
996 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
997 * block driver has been specified explicitly.
999 static int bdrv_fill_options(QDict
**options
, const char **pfilename
,
1000 int *flags
, BlockDriver
*drv
, Error
**errp
)
1002 const char *filename
= *pfilename
;
1003 const char *drvname
;
1004 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1005 bool parse_filename
= false;
1006 BlockDriver
*tmp_drv
;
1007 Error
*local_err
= NULL
;
1009 /* Parse json: pseudo-protocol */
1010 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1011 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1013 error_propagate(errp
, local_err
);
1017 /* Options given in the filename have lower priority than options
1018 * specified directly */
1019 qdict_join(*options
, json_options
, false);
1020 QDECREF(json_options
);
1021 *pfilename
= filename
= NULL
;
1024 drvname
= qdict_get_try_str(*options
, "driver");
1026 /* If the user has explicitly specified the driver, this choice should
1027 * override the BDRV_O_PROTOCOL flag */
1029 if (!tmp_drv
&& drvname
) {
1030 tmp_drv
= bdrv_find_format(drvname
);
1033 protocol
= tmp_drv
->bdrv_file_open
;
1037 *flags
|= BDRV_O_PROTOCOL
;
1039 *flags
&= ~BDRV_O_PROTOCOL
;
1042 /* Fetch the file name from the options QDict if necessary */
1043 if (protocol
&& filename
) {
1044 if (!qdict_haskey(*options
, "filename")) {
1045 qdict_put(*options
, "filename", qstring_from_str(filename
));
1046 parse_filename
= true;
1048 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1054 /* Find the right block driver */
1055 filename
= qdict_get_try_str(*options
, "filename");
1059 error_setg(errp
, "Driver specified twice");
1062 drvname
= drv
->format_name
;
1063 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1065 if (!drvname
&& protocol
) {
1067 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1072 drvname
= drv
->format_name
;
1073 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1075 error_setg(errp
, "Must specify either driver or file");
1078 } else if (drvname
) {
1079 drv
= bdrv_find_format(drvname
);
1081 error_setg(errp
, "Unknown driver '%s'", drvname
);
1087 assert(drv
|| !protocol
);
1089 /* Driver-specific filename parsing */
1090 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1091 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1093 error_propagate(errp
, local_err
);
1097 if (!drv
->bdrv_needs_filename
) {
1098 qdict_del(*options
, "filename");
1105 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1106 BlockDriverState
*child_bs
,
1107 const BdrvChildRole
*child_role
)
1109 BdrvChild
*child
= g_new(BdrvChild
, 1);
1110 *child
= (BdrvChild
) {
1115 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1120 static void bdrv_detach_child(BdrvChild
*child
)
1122 QLIST_REMOVE(child
, next
);
1126 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1128 BlockDriverState
*child_bs
= child
->bs
;
1130 if (child
->bs
->inherits_from
== parent
) {
1131 child
->bs
->inherits_from
= NULL
;
1134 bdrv_detach_child(child
);
1135 bdrv_unref(child_bs
);
1138 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1141 if (bs
->backing_hd
) {
1142 assert(bs
->backing_blocker
);
1143 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1144 } else if (backing_hd
) {
1145 error_setg(&bs
->backing_blocker
,
1146 "node is used as backing hd of '%s'",
1147 bdrv_get_device_or_node_name(bs
));
1150 bs
->backing_hd
= backing_hd
;
1152 error_free(bs
->backing_blocker
);
1153 bs
->backing_blocker
= NULL
;
1156 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1157 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1158 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1159 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1161 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1162 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1163 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1164 bs
->backing_blocker
);
1166 bdrv_refresh_limits(bs
, NULL
);
1170 * Opens the backing file for a BlockDriverState if not yet open
1172 * options is a QDict of options to pass to the block drivers, or NULL for an
1173 * empty set of options. The reference to the QDict is transferred to this
1174 * function (even on failure), so if the caller intends to reuse the dictionary,
1175 * it needs to use QINCREF() before calling bdrv_file_open.
1177 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1179 char *backing_filename
= g_malloc0(PATH_MAX
);
1181 BlockDriverState
*backing_hd
;
1182 Error
*local_err
= NULL
;
1184 if (bs
->backing_hd
!= NULL
) {
1189 /* NULL means an empty set of options */
1190 if (options
== NULL
) {
1191 options
= qdict_new();
1194 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1195 if (qdict_haskey(options
, "file.filename")) {
1196 backing_filename
[0] = '\0';
1197 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1201 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1205 error_propagate(errp
, local_err
);
1211 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1213 error_setg(errp
, "Driver doesn't support backing files");
1218 backing_hd
= bdrv_new();
1220 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1221 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1224 assert(bs
->backing_hd
== NULL
);
1225 ret
= bdrv_open_inherit(&backing_hd
,
1226 *backing_filename
? backing_filename
: NULL
,
1227 NULL
, options
, 0, bs
, &child_backing
,
1230 bdrv_unref(backing_hd
);
1232 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1233 error_setg(errp
, "Could not open backing file: %s",
1234 error_get_pretty(local_err
));
1235 error_free(local_err
);
1239 bdrv_attach_child(bs
, backing_hd
, &child_backing
);
1240 bdrv_set_backing_hd(bs
, backing_hd
);
1243 g_free(backing_filename
);
1248 * Opens a disk image whose options are given as BlockdevRef in another block
1251 * If allow_none is true, no image will be opened if filename is false and no
1252 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1254 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1255 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1256 * itself, all options starting with "${bdref_key}." are considered part of the
1259 * The BlockdevRef will be removed from the options QDict.
1261 BdrvChild
*bdrv_open_child(const char *filename
,
1262 QDict
*options
, const char *bdref_key
,
1263 BlockDriverState
* parent
,
1264 const BdrvChildRole
*child_role
,
1265 bool allow_none
, Error
**errp
)
1267 BdrvChild
*c
= NULL
;
1268 BlockDriverState
*bs
;
1269 QDict
*image_options
;
1271 char *bdref_key_dot
;
1272 const char *reference
;
1274 assert(child_role
!= NULL
);
1276 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1277 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1278 g_free(bdref_key_dot
);
1280 reference
= qdict_get_try_str(options
, bdref_key
);
1281 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1283 error_setg(errp
, "A block device must be specified for \"%s\"",
1286 QDECREF(image_options
);
1291 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1292 parent
, child_role
, NULL
, errp
);
1297 c
= bdrv_attach_child(parent
, bs
, child_role
);
1300 qdict_del(options
, bdref_key
);
1305 * This is a version of bdrv_open_child() that returns 0/-EINVAL instead of
1306 * a BdrvChild object.
1308 * If allow_none is true, no image will be opened if filename is false and no
1309 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1311 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1313 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1314 QDict
*options
, const char *bdref_key
,
1315 BlockDriverState
* parent
, const BdrvChildRole
*child_role
,
1316 bool allow_none
, Error
**errp
)
1318 Error
*local_err
= NULL
;
1322 assert(*pbs
== NULL
);
1324 c
= bdrv_open_child(filename
, options
, bdref_key
, parent
, child_role
,
1325 allow_none
, &local_err
);
1327 error_propagate(errp
, local_err
);
1338 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1340 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1341 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1343 QemuOpts
*opts
= NULL
;
1344 QDict
*snapshot_options
;
1345 BlockDriverState
*bs_snapshot
;
1346 Error
*local_err
= NULL
;
1349 /* if snapshot, we create a temporary backing file and open it
1350 instead of opening 'filename' directly */
1352 /* Get the required size from the image */
1353 total_size
= bdrv_getlength(bs
);
1354 if (total_size
< 0) {
1356 error_setg_errno(errp
, -total_size
, "Could not get image size");
1360 /* Create the temporary image */
1361 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1363 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1367 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1369 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1370 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1371 qemu_opts_del(opts
);
1373 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1374 "'%s': %s", tmp_filename
,
1375 error_get_pretty(local_err
));
1376 error_free(local_err
);
1380 /* Prepare a new options QDict for the temporary file */
1381 snapshot_options
= qdict_new();
1382 qdict_put(snapshot_options
, "file.driver",
1383 qstring_from_str("file"));
1384 qdict_put(snapshot_options
, "file.filename",
1385 qstring_from_str(tmp_filename
));
1387 bs_snapshot
= bdrv_new();
1389 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1390 flags
, &bdrv_qcow2
, &local_err
);
1392 error_propagate(errp
, local_err
);
1396 bdrv_append(bs_snapshot
, bs
);
1399 g_free(tmp_filename
);
1404 * Opens a disk image (raw, qcow2, vmdk, ...)
1406 * options is a QDict of options to pass to the block drivers, or NULL for an
1407 * empty set of options. The reference to the QDict belongs to the block layer
1408 * after the call (even on failure), so if the caller intends to reuse the
1409 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1411 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1412 * If it is not NULL, the referenced BDS will be reused.
1414 * The reference parameter may be used to specify an existing block device which
1415 * should be opened. If specified, neither options nor a filename may be given,
1416 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1418 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1419 const char *reference
, QDict
*options
, int flags
,
1420 BlockDriverState
*parent
,
1421 const BdrvChildRole
*child_role
,
1422 BlockDriver
*drv
, Error
**errp
)
1425 BlockDriverState
*file
= NULL
, *bs
;
1426 const char *drvname
;
1427 Error
*local_err
= NULL
;
1428 int snapshot_flags
= 0;
1431 assert(!child_role
|| !flags
);
1432 assert(!child_role
== !parent
);
1435 bool options_non_empty
= options
? qdict_size(options
) : false;
1439 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1440 "another block device");
1444 if (filename
|| options_non_empty
) {
1445 error_setg(errp
, "Cannot reference an existing block device with "
1446 "additional options or a new filename");
1450 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1465 /* NULL means an empty set of options */
1466 if (options
== NULL
) {
1467 options
= qdict_new();
1471 bs
->inherits_from
= parent
;
1472 flags
= child_role
->inherit_flags(parent
->open_flags
);
1475 ret
= bdrv_fill_options(&options
, &filename
, &flags
, drv
, &local_err
);
1480 /* Find the right image format driver */
1482 drvname
= qdict_get_try_str(options
, "driver");
1484 drv
= bdrv_find_format(drvname
);
1485 qdict_del(options
, "driver");
1487 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1493 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1495 bs
->open_flags
= flags
;
1496 bs
->options
= options
;
1497 options
= qdict_clone_shallow(options
);
1499 /* Open image file without format layer */
1500 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1501 if (flags
& BDRV_O_RDWR
) {
1502 flags
|= BDRV_O_ALLOW_RDWR
;
1504 if (flags
& BDRV_O_SNAPSHOT
) {
1505 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1506 flags
= bdrv_backing_flags(flags
);
1509 assert(file
== NULL
);
1510 bs
->open_flags
= flags
;
1511 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1512 bs
, &child_file
, true, &local_err
);
1518 /* Image format probing */
1521 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1526 error_setg(errp
, "Must specify either driver or file");
1531 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1532 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1533 /* file must be NULL if a protocol BDS is about to be created
1534 * (the inverse results in an error message from bdrv_open_common()) */
1535 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1537 /* Open the image */
1538 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1543 if (file
&& (bs
->file
!= file
)) {
1548 /* If there is a backing file, use it */
1549 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1550 QDict
*backing_options
;
1552 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1553 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1555 goto close_and_fail
;
1559 bdrv_refresh_filename(bs
);
1561 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1562 * temporary snapshot afterwards. */
1563 if (snapshot_flags
) {
1564 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1566 goto close_and_fail
;
1570 /* Check if any unknown options were used */
1571 if (options
&& (qdict_size(options
) != 0)) {
1572 const QDictEntry
*entry
= qdict_first(options
);
1573 if (flags
& BDRV_O_PROTOCOL
) {
1574 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1575 "'%s'", drv
->format_name
, entry
->key
);
1577 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1578 "support the option '%s'", drv
->format_name
,
1579 bdrv_get_device_name(bs
), entry
->key
);
1583 goto close_and_fail
;
1586 if (!bdrv_key_required(bs
)) {
1588 blk_dev_change_media_cb(bs
->blk
, true);
1590 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1591 && !runstate_check(RUN_STATE_INMIGRATE
)
1592 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1594 "Guest must be stopped for opening of encrypted image");
1596 goto close_and_fail
;
1607 QDECREF(bs
->options
);
1611 /* If *pbs is NULL, a new BDS has been created in this function and
1612 needs to be freed now. Otherwise, it does not need to be closed,
1613 since it has not really been opened yet. */
1617 error_propagate(errp
, local_err
);
1622 /* See fail path, but now the BDS has to be always closed */
1630 error_propagate(errp
, local_err
);
1635 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1636 const char *reference
, QDict
*options
, int flags
,
1637 BlockDriver
*drv
, Error
**errp
)
1639 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1643 typedef struct BlockReopenQueueEntry
{
1645 BDRVReopenState state
;
1646 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1647 } BlockReopenQueueEntry
;
1650 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1651 * reopen of multiple devices.
1653 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1654 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1655 * be created and initialized. This newly created BlockReopenQueue should be
1656 * passed back in for subsequent calls that are intended to be of the same
1659 * bs is the BlockDriverState to add to the reopen queue.
1661 * flags contains the open flags for the associated bs
1663 * returns a pointer to bs_queue, which is either the newly allocated
1664 * bs_queue, or the existing bs_queue being used.
1667 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1668 BlockDriverState
*bs
, int flags
)
1672 BlockReopenQueueEntry
*bs_entry
;
1675 if (bs_queue
== NULL
) {
1676 bs_queue
= g_new0(BlockReopenQueue
, 1);
1677 QSIMPLEQ_INIT(bs_queue
);
1680 /* bdrv_open() masks this flag out */
1681 flags
&= ~BDRV_O_PROTOCOL
;
1683 QLIST_FOREACH(child
, &bs
->children
, next
) {
1686 if (child
->bs
->inherits_from
!= bs
) {
1690 child_flags
= child
->role
->inherit_flags(flags
);
1691 bdrv_reopen_queue(bs_queue
, child
->bs
, child_flags
);
1694 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1695 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1697 bs_entry
->state
.bs
= bs
;
1698 bs_entry
->state
.flags
= flags
;
1704 * Reopen multiple BlockDriverStates atomically & transactionally.
1706 * The queue passed in (bs_queue) must have been built up previous
1707 * via bdrv_reopen_queue().
1709 * Reopens all BDS specified in the queue, with the appropriate
1710 * flags. All devices are prepared for reopen, and failure of any
1711 * device will cause all device changes to be abandonded, and intermediate
1714 * If all devices prepare successfully, then the changes are committed
1718 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1721 BlockReopenQueueEntry
*bs_entry
, *next
;
1722 Error
*local_err
= NULL
;
1724 assert(bs_queue
!= NULL
);
1728 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1729 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1730 error_propagate(errp
, local_err
);
1733 bs_entry
->prepared
= true;
1736 /* If we reach this point, we have success and just need to apply the
1739 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1740 bdrv_reopen_commit(&bs_entry
->state
);
1746 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1747 if (ret
&& bs_entry
->prepared
) {
1748 bdrv_reopen_abort(&bs_entry
->state
);
1757 /* Reopen a single BlockDriverState with the specified flags. */
1758 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1761 Error
*local_err
= NULL
;
1762 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1764 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1765 if (local_err
!= NULL
) {
1766 error_propagate(errp
, local_err
);
1773 * Prepares a BlockDriverState for reopen. All changes are staged in the
1774 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1775 * the block driver layer .bdrv_reopen_prepare()
1777 * bs is the BlockDriverState to reopen
1778 * flags are the new open flags
1779 * queue is the reopen queue
1781 * Returns 0 on success, non-zero on error. On error errp will be set
1784 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1785 * It is the responsibility of the caller to then call the abort() or
1786 * commit() for any other BDS that have been left in a prepare() state
1789 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1793 Error
*local_err
= NULL
;
1796 assert(reopen_state
!= NULL
);
1797 assert(reopen_state
->bs
->drv
!= NULL
);
1798 drv
= reopen_state
->bs
->drv
;
1800 /* if we are to stay read-only, do not allow permission change
1802 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1803 reopen_state
->flags
& BDRV_O_RDWR
) {
1804 error_setg(errp
, "Node '%s' is read only",
1805 bdrv_get_device_or_node_name(reopen_state
->bs
));
1810 ret
= bdrv_flush(reopen_state
->bs
);
1812 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1817 if (drv
->bdrv_reopen_prepare
) {
1818 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1820 if (local_err
!= NULL
) {
1821 error_propagate(errp
, local_err
);
1823 error_setg(errp
, "failed while preparing to reopen image '%s'",
1824 reopen_state
->bs
->filename
);
1829 /* It is currently mandatory to have a bdrv_reopen_prepare()
1830 * handler for each supported drv. */
1831 error_setg(errp
, "Block format '%s' used by node '%s' "
1832 "does not support reopening files", drv
->format_name
,
1833 bdrv_get_device_or_node_name(reopen_state
->bs
));
1845 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1846 * makes them final by swapping the staging BlockDriverState contents into
1847 * the active BlockDriverState contents.
1849 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1853 assert(reopen_state
!= NULL
);
1854 drv
= reopen_state
->bs
->drv
;
1855 assert(drv
!= NULL
);
1857 /* If there are any driver level actions to take */
1858 if (drv
->bdrv_reopen_commit
) {
1859 drv
->bdrv_reopen_commit(reopen_state
);
1862 /* set BDS specific flags now */
1863 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1864 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1866 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1868 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1872 * Abort the reopen, and delete and free the staged changes in
1875 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1879 assert(reopen_state
!= NULL
);
1880 drv
= reopen_state
->bs
->drv
;
1881 assert(drv
!= NULL
);
1883 if (drv
->bdrv_reopen_abort
) {
1884 drv
->bdrv_reopen_abort(reopen_state
);
1889 void bdrv_close(BlockDriverState
*bs
)
1891 BdrvAioNotifier
*ban
, *ban_next
;
1894 block_job_cancel_sync(bs
->job
);
1896 bdrv_drain(bs
); /* complete I/O */
1898 bdrv_drain(bs
); /* in case flush left pending I/O */
1899 notifier_list_notify(&bs
->close_notifiers
, bs
);
1902 BdrvChild
*child
, *next
;
1904 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
1905 /* TODO Remove bdrv_unref() from drivers' close function and use
1906 * bdrv_unref_child() here */
1907 if (child
->bs
->inherits_from
== bs
) {
1908 child
->bs
->inherits_from
= NULL
;
1910 bdrv_detach_child(child
);
1913 if (bs
->backing_hd
) {
1914 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1915 bdrv_set_backing_hd(bs
, NULL
);
1916 bdrv_unref(backing_hd
);
1918 bs
->drv
->bdrv_close(bs
);
1922 bs
->copy_on_read
= 0;
1923 bs
->backing_file
[0] = '\0';
1924 bs
->backing_format
[0] = '\0';
1925 bs
->total_sectors
= 0;
1929 bs
->zero_beyond_eof
= false;
1930 QDECREF(bs
->options
);
1932 QDECREF(bs
->full_open_options
);
1933 bs
->full_open_options
= NULL
;
1935 if (bs
->file
!= NULL
) {
1936 bdrv_unref(bs
->file
);
1942 blk_dev_change_media_cb(bs
->blk
, false);
1945 /*throttling disk I/O limits*/
1946 if (bs
->io_limits_enabled
) {
1947 bdrv_io_limits_disable(bs
);
1950 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1953 QLIST_INIT(&bs
->aio_notifiers
);
1956 void bdrv_close_all(void)
1958 BlockDriverState
*bs
;
1960 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1961 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1963 aio_context_acquire(aio_context
);
1965 aio_context_release(aio_context
);
1969 /* make a BlockDriverState anonymous by removing from bdrv_state and
1970 * graph_bdrv_state list.
1971 Also, NULL terminate the device_name to prevent double remove */
1972 void bdrv_make_anon(BlockDriverState
*bs
)
1975 * Take care to remove bs from bdrv_states only when it's actually
1976 * in it. Note that bs->device_list.tqe_prev is initially null,
1977 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1978 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1979 * resetting it to null on remove.
1981 if (bs
->device_list
.tqe_prev
) {
1982 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1983 bs
->device_list
.tqe_prev
= NULL
;
1985 if (bs
->node_name
[0] != '\0') {
1986 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1988 bs
->node_name
[0] = '\0';
1991 static void bdrv_rebind(BlockDriverState
*bs
)
1993 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1994 bs
->drv
->bdrv_rebind(bs
);
1998 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1999 BlockDriverState
*bs_src
)
2001 /* move some fields that need to stay attached to the device */
2004 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
2005 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2007 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2009 /* i/o throttled req */
2010 bs_dest
->throttle_state
= bs_src
->throttle_state
,
2011 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
2012 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
2013 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
2014 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2015 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2016 memcpy(&bs_dest
->round_robin
,
2017 &bs_src
->round_robin
,
2018 sizeof(bs_dest
->round_robin
));
2019 memcpy(&bs_dest
->throttle_timers
,
2020 &bs_src
->throttle_timers
,
2021 sizeof(ThrottleTimers
));
2024 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2025 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2028 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2029 bs_dest
->iostatus
= bs_src
->iostatus
;
2032 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2034 /* reference count */
2035 bs_dest
->refcnt
= bs_src
->refcnt
;
2038 bs_dest
->job
= bs_src
->job
;
2040 /* keep the same entry in bdrv_states */
2041 bs_dest
->device_list
= bs_src
->device_list
;
2042 bs_dest
->blk
= bs_src
->blk
;
2044 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2045 sizeof(bs_dest
->op_blockers
));
2049 * Swap bs contents for two image chains while they are live,
2050 * while keeping required fields on the BlockDriverState that is
2051 * actually attached to a device.
2053 * This will modify the BlockDriverState fields, and swap contents
2054 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2056 * bs_new must not be attached to a BlockBackend.
2058 * This function does not create any image files.
2060 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2062 BlockDriverState tmp
;
2068 /* The code needs to swap the node_name but simply swapping node_list won't
2069 * work so first remove the nodes from the graph list, do the swap then
2070 * insert them back if needed.
2072 if (bs_new
->node_name
[0] != '\0') {
2073 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2075 if (bs_old
->node_name
[0] != '\0') {
2076 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2079 /* If the BlockDriverState is part of a throttling group acquire
2080 * its lock since we're going to mess with the protected fields.
2081 * Otherwise there's no need to worry since no one else can touch
2083 if (bs_old
->throttle_state
) {
2084 throttle_group_lock(bs_old
);
2087 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2088 assert(!bs_new
->blk
);
2089 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2090 assert(bs_new
->job
== NULL
);
2091 assert(bs_new
->io_limits_enabled
== false);
2092 assert(bs_new
->throttle_state
== NULL
);
2093 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2099 /* there are some fields that should not be swapped, move them back */
2100 bdrv_move_feature_fields(&tmp
, bs_old
);
2101 bdrv_move_feature_fields(bs_old
, bs_new
);
2102 bdrv_move_feature_fields(bs_new
, &tmp
);
2104 /* bs_new must remain unattached */
2105 assert(!bs_new
->blk
);
2107 /* Check a few fields that should remain attached to the device */
2108 assert(bs_new
->job
== NULL
);
2109 assert(bs_new
->io_limits_enabled
== false);
2110 assert(bs_new
->throttle_state
== NULL
);
2111 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2113 /* Release the ThrottleGroup lock */
2114 if (bs_old
->throttle_state
) {
2115 throttle_group_unlock(bs_old
);
2118 /* insert the nodes back into the graph node list if needed */
2119 if (bs_new
->node_name
[0] != '\0') {
2120 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2122 if (bs_old
->node_name
[0] != '\0') {
2123 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2127 * Update lh_first.le_prev for non-empty lists.
2129 * The head of the op blocker list doesn't change because it is moved back
2130 * in bdrv_move_feature_fields().
2132 assert(QLIST_EMPTY(&bs_old
->tracked_requests
));
2133 assert(QLIST_EMPTY(&bs_new
->tracked_requests
));
2135 QLIST_FIX_HEAD_PTR(&bs_new
->children
, next
);
2136 QLIST_FIX_HEAD_PTR(&bs_old
->children
, next
);
2138 /* Update references in bs->opaque and children */
2139 QLIST_FOREACH(child
, &bs_old
->children
, next
) {
2140 if (child
->bs
->inherits_from
== bs_new
) {
2141 child
->bs
->inherits_from
= bs_old
;
2144 QLIST_FOREACH(child
, &bs_new
->children
, next
) {
2145 if (child
->bs
->inherits_from
== bs_old
) {
2146 child
->bs
->inherits_from
= bs_new
;
2150 bdrv_rebind(bs_new
);
2151 bdrv_rebind(bs_old
);
2155 * Add new bs contents at the top of an image chain while the chain is
2156 * live, while keeping required fields on the top layer.
2158 * This will modify the BlockDriverState fields, and swap contents
2159 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2161 * bs_new must not be attached to a BlockBackend.
2163 * This function does not create any image files.
2165 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2167 bdrv_swap(bs_new
, bs_top
);
2169 /* The contents of 'tmp' will become bs_top, as we are
2170 * swapping bs_new and bs_top contents. */
2171 bdrv_set_backing_hd(bs_top
, bs_new
);
2172 bdrv_attach_child(bs_top
, bs_new
, &child_backing
);
2175 static void bdrv_delete(BlockDriverState
*bs
)
2178 assert(bdrv_op_blocker_is_empty(bs
));
2179 assert(!bs
->refcnt
);
2180 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2184 /* remove from list, if necessary */
2191 * Run consistency checks on an image
2193 * Returns 0 if the check could be completed (it doesn't mean that the image is
2194 * free of errors) or -errno when an internal error occurred. The results of the
2195 * check are stored in res.
2197 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2199 if (bs
->drv
== NULL
) {
2202 if (bs
->drv
->bdrv_check
== NULL
) {
2206 memset(res
, 0, sizeof(*res
));
2207 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2210 #define COMMIT_BUF_SECTORS 2048
2212 /* commit COW file into the raw image */
2213 int bdrv_commit(BlockDriverState
*bs
)
2215 BlockDriver
*drv
= bs
->drv
;
2216 int64_t sector
, total_sectors
, length
, backing_length
;
2217 int n
, ro
, open_flags
;
2219 uint8_t *buf
= NULL
;
2224 if (!bs
->backing_hd
) {
2228 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2229 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2233 ro
= bs
->backing_hd
->read_only
;
2234 open_flags
= bs
->backing_hd
->open_flags
;
2237 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2242 length
= bdrv_getlength(bs
);
2248 backing_length
= bdrv_getlength(bs
->backing_hd
);
2249 if (backing_length
< 0) {
2250 ret
= backing_length
;
2254 /* If our top snapshot is larger than the backing file image,
2255 * grow the backing file image if possible. If not possible,
2256 * we must return an error */
2257 if (length
> backing_length
) {
2258 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2264 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2266 /* qemu_try_blockalign() for bs will choose an alignment that works for
2267 * bs->backing_hd as well, so no need to compare the alignment manually. */
2268 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2274 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2275 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2280 ret
= bdrv_read(bs
, sector
, buf
, n
);
2285 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2292 if (drv
->bdrv_make_empty
) {
2293 ret
= drv
->bdrv_make_empty(bs
);
2301 * Make sure all data we wrote to the backing device is actually
2304 if (bs
->backing_hd
) {
2305 bdrv_flush(bs
->backing_hd
);
2313 /* ignoring error return here */
2314 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2320 int bdrv_commit_all(void)
2322 BlockDriverState
*bs
;
2324 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2325 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2327 aio_context_acquire(aio_context
);
2328 if (bs
->drv
&& bs
->backing_hd
) {
2329 int ret
= bdrv_commit(bs
);
2331 aio_context_release(aio_context
);
2335 aio_context_release(aio_context
);
2343 * -EINVAL - backing format specified, but no file
2344 * -ENOSPC - can't update the backing file because no space is left in the
2346 * -ENOTSUP - format driver doesn't support changing the backing file
2348 int bdrv_change_backing_file(BlockDriverState
*bs
,
2349 const char *backing_file
, const char *backing_fmt
)
2351 BlockDriver
*drv
= bs
->drv
;
2354 /* Backing file format doesn't make sense without a backing file */
2355 if (backing_fmt
&& !backing_file
) {
2359 if (drv
->bdrv_change_backing_file
!= NULL
) {
2360 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2366 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2367 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2373 * Finds the image layer in the chain that has 'bs' as its backing file.
2375 * active is the current topmost image.
2377 * Returns NULL if bs is not found in active's image chain,
2378 * or if active == bs.
2380 * Returns the bottommost base image if bs == NULL.
2382 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2383 BlockDriverState
*bs
)
2385 while (active
&& bs
!= active
->backing_hd
) {
2386 active
= active
->backing_hd
;
2392 /* Given a BDS, searches for the base layer. */
2393 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2395 return bdrv_find_overlay(bs
, NULL
);
2398 typedef struct BlkIntermediateStates
{
2399 BlockDriverState
*bs
;
2400 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2401 } BlkIntermediateStates
;
2405 * Drops images above 'base' up to and including 'top', and sets the image
2406 * above 'top' to have base as its backing file.
2408 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2409 * information in 'bs' can be properly updated.
2411 * E.g., this will convert the following chain:
2412 * bottom <- base <- intermediate <- top <- active
2416 * bottom <- base <- active
2418 * It is allowed for bottom==base, in which case it converts:
2420 * base <- intermediate <- top <- active
2426 * If backing_file_str is non-NULL, it will be used when modifying top's
2427 * overlay image metadata.
2430 * if active == top, that is considered an error
2433 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2434 BlockDriverState
*base
, const char *backing_file_str
)
2436 BlockDriverState
*intermediate
;
2437 BlockDriverState
*base_bs
= NULL
;
2438 BlockDriverState
*new_top_bs
= NULL
;
2439 BlkIntermediateStates
*intermediate_state
, *next
;
2442 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2443 QSIMPLEQ_INIT(&states_to_delete
);
2445 if (!top
->drv
|| !base
->drv
) {
2449 new_top_bs
= bdrv_find_overlay(active
, top
);
2451 if (new_top_bs
== NULL
) {
2452 /* we could not find the image above 'top', this is an error */
2456 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2457 * to do, no intermediate images */
2458 if (new_top_bs
->backing_hd
== base
) {
2465 /* now we will go down through the list, and add each BDS we find
2466 * into our deletion queue, until we hit the 'base'
2468 while (intermediate
) {
2469 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2470 intermediate_state
->bs
= intermediate
;
2471 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2473 if (intermediate
->backing_hd
== base
) {
2474 base_bs
= intermediate
->backing_hd
;
2477 intermediate
= intermediate
->backing_hd
;
2479 if (base_bs
== NULL
) {
2480 /* something went wrong, we did not end at the base. safely
2481 * unravel everything, and exit with error */
2485 /* success - we can delete the intermediate states, and link top->base */
2486 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2487 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2488 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2492 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2494 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2495 /* so that bdrv_close() does not recursively close the chain */
2496 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2497 bdrv_unref(intermediate_state
->bs
);
2502 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2503 g_free(intermediate_state
);
2509 * Truncate file to 'offset' bytes (needed only for file protocols)
2511 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2513 BlockDriver
*drv
= bs
->drv
;
2517 if (!drv
->bdrv_truncate
)
2522 ret
= drv
->bdrv_truncate(bs
, offset
);
2524 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2525 bdrv_dirty_bitmap_truncate(bs
);
2527 blk_dev_resize_cb(bs
->blk
);
2534 * Length of a allocated file in bytes. Sparse files are counted by actual
2535 * allocated space. Return < 0 if error or unknown.
2537 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2539 BlockDriver
*drv
= bs
->drv
;
2543 if (drv
->bdrv_get_allocated_file_size
) {
2544 return drv
->bdrv_get_allocated_file_size(bs
);
2547 return bdrv_get_allocated_file_size(bs
->file
);
2553 * Return number of sectors on success, -errno on error.
2555 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2557 BlockDriver
*drv
= bs
->drv
;
2562 if (drv
->has_variable_length
) {
2563 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2568 return bs
->total_sectors
;
2572 * Return length in bytes on success, -errno on error.
2573 * The length is always a multiple of BDRV_SECTOR_SIZE.
2575 int64_t bdrv_getlength(BlockDriverState
*bs
)
2577 int64_t ret
= bdrv_nb_sectors(bs
);
2579 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2580 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2583 /* return 0 as number of sectors if no device present or error */
2584 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2586 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2588 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2591 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2592 BlockdevOnError on_write_error
)
2594 bs
->on_read_error
= on_read_error
;
2595 bs
->on_write_error
= on_write_error
;
2598 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2600 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2603 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2605 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2608 case BLOCKDEV_ON_ERROR_ENOSPC
:
2609 return (error
== ENOSPC
) ?
2610 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2611 case BLOCKDEV_ON_ERROR_STOP
:
2612 return BLOCK_ERROR_ACTION_STOP
;
2613 case BLOCKDEV_ON_ERROR_REPORT
:
2614 return BLOCK_ERROR_ACTION_REPORT
;
2615 case BLOCKDEV_ON_ERROR_IGNORE
:
2616 return BLOCK_ERROR_ACTION_IGNORE
;
2622 static void send_qmp_error_event(BlockDriverState
*bs
,
2623 BlockErrorAction action
,
2624 bool is_read
, int error
)
2626 IoOperationType optype
;
2628 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2629 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2630 bdrv_iostatus_is_enabled(bs
),
2631 error
== ENOSPC
, strerror(error
),
2635 /* This is done by device models because, while the block layer knows
2636 * about the error, it does not know whether an operation comes from
2637 * the device or the block layer (from a job, for example).
2639 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2640 bool is_read
, int error
)
2644 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2645 /* First set the iostatus, so that "info block" returns an iostatus
2646 * that matches the events raised so far (an additional error iostatus
2647 * is fine, but not a lost one).
2649 bdrv_iostatus_set_err(bs
, error
);
2651 /* Then raise the request to stop the VM and the event.
2652 * qemu_system_vmstop_request_prepare has two effects. First,
2653 * it ensures that the STOP event always comes after the
2654 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2655 * can observe the STOP event and do a "cont" before the STOP
2656 * event is issued, the VM will not stop. In this case, vm_start()
2657 * also ensures that the STOP/RESUME pair of events is emitted.
2659 qemu_system_vmstop_request_prepare();
2660 send_qmp_error_event(bs
, action
, is_read
, error
);
2661 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2663 send_qmp_error_event(bs
, action
, is_read
, error
);
2667 int bdrv_is_read_only(BlockDriverState
*bs
)
2669 return bs
->read_only
;
2672 int bdrv_is_sg(BlockDriverState
*bs
)
2677 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2679 return bs
->enable_write_cache
;
2682 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2684 bs
->enable_write_cache
= wce
;
2686 /* so a reopen() will preserve wce */
2688 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2690 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2694 int bdrv_is_encrypted(BlockDriverState
*bs
)
2696 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2698 return bs
->encrypted
;
2701 int bdrv_key_required(BlockDriverState
*bs
)
2703 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2705 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2707 return (bs
->encrypted
&& !bs
->valid_key
);
2710 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2713 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2714 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2720 if (!bs
->encrypted
) {
2722 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2725 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2728 } else if (!bs
->valid_key
) {
2731 /* call the change callback now, we skipped it on open */
2732 blk_dev_change_media_cb(bs
->blk
, true);
2739 * Provide an encryption key for @bs.
2740 * If @key is non-null:
2741 * If @bs is not encrypted, fail.
2742 * Else if the key is invalid, fail.
2743 * Else set @bs's key to @key, replacing the existing key, if any.
2745 * If @bs is encrypted and still lacks a key, fail.
2747 * On failure, store an error object through @errp if non-null.
2749 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2752 if (!bdrv_is_encrypted(bs
)) {
2753 error_setg(errp
, "Node '%s' is not encrypted",
2754 bdrv_get_device_or_node_name(bs
));
2755 } else if (bdrv_set_key(bs
, key
) < 0) {
2756 error_setg(errp
, QERR_INVALID_PASSWORD
);
2759 if (bdrv_key_required(bs
)) {
2760 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2761 "'%s' (%s) is encrypted",
2762 bdrv_get_device_or_node_name(bs
),
2763 bdrv_get_encrypted_filename(bs
));
2768 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2770 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2773 static int qsort_strcmp(const void *a
, const void *b
)
2775 return strcmp(a
, b
);
2778 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2784 const char **formats
= NULL
;
2786 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2787 if (drv
->format_name
) {
2790 while (formats
&& i
&& !found
) {
2791 found
= !strcmp(formats
[--i
], drv
->format_name
);
2795 formats
= g_renew(const char *, formats
, count
+ 1);
2796 formats
[count
++] = drv
->format_name
;
2801 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2803 for (i
= 0; i
< count
; i
++) {
2804 it(opaque
, formats
[i
]);
2810 /* This function is to find a node in the bs graph */
2811 BlockDriverState
*bdrv_find_node(const char *node_name
)
2813 BlockDriverState
*bs
;
2817 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2818 if (!strcmp(node_name
, bs
->node_name
)) {
2825 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2826 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2828 BlockDeviceInfoList
*list
, *entry
;
2829 BlockDriverState
*bs
;
2832 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2833 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2835 qapi_free_BlockDeviceInfoList(list
);
2838 entry
= g_malloc0(sizeof(*entry
));
2839 entry
->value
= info
;
2847 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2848 const char *node_name
,
2852 BlockDriverState
*bs
;
2855 blk
= blk_by_name(device
);
2863 bs
= bdrv_find_node(node_name
);
2870 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2871 device
? device
: "",
2872 node_name
? node_name
: "");
2876 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2877 * return false. If either argument is NULL, return false. */
2878 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2880 while (top
&& top
!= base
) {
2881 top
= top
->backing_hd
;
2887 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2890 return QTAILQ_FIRST(&graph_bdrv_states
);
2892 return QTAILQ_NEXT(bs
, node_list
);
2895 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2898 return QTAILQ_FIRST(&bdrv_states
);
2900 return QTAILQ_NEXT(bs
, device_list
);
2903 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2905 return bs
->node_name
;
2908 /* TODO check what callers really want: bs->node_name or blk_name() */
2909 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2911 return bs
->blk
? blk_name(bs
->blk
) : "";
2914 /* This can be used to identify nodes that might not have a device
2915 * name associated. Since node and device names live in the same
2916 * namespace, the result is unambiguous. The exception is if both are
2917 * absent, then this returns an empty (non-null) string. */
2918 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2920 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2923 int bdrv_get_flags(BlockDriverState
*bs
)
2925 return bs
->open_flags
;
2928 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2933 int bdrv_has_zero_init(BlockDriverState
*bs
)
2937 /* If BS is a copy on write image, it is initialized to
2938 the contents of the base image, which may not be zeroes. */
2939 if (bs
->backing_hd
) {
2942 if (bs
->drv
->bdrv_has_zero_init
) {
2943 return bs
->drv
->bdrv_has_zero_init(bs
);
2950 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2952 BlockDriverInfo bdi
;
2954 if (bs
->backing_hd
) {
2958 if (bdrv_get_info(bs
, &bdi
) == 0) {
2959 return bdi
.unallocated_blocks_are_zero
;
2965 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2967 BlockDriverInfo bdi
;
2969 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2973 if (bdrv_get_info(bs
, &bdi
) == 0) {
2974 return bdi
.can_write_zeroes_with_unmap
;
2980 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2982 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2983 return bs
->backing_file
;
2984 else if (bs
->encrypted
)
2985 return bs
->filename
;
2990 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2991 char *filename
, int filename_size
)
2993 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2996 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2998 BlockDriver
*drv
= bs
->drv
;
3001 if (!drv
->bdrv_get_info
)
3003 memset(bdi
, 0, sizeof(*bdi
));
3004 return drv
->bdrv_get_info(bs
, bdi
);
3007 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3009 BlockDriver
*drv
= bs
->drv
;
3010 if (drv
&& drv
->bdrv_get_specific_info
) {
3011 return drv
->bdrv_get_specific_info(bs
);
3016 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
3018 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3022 bs
->drv
->bdrv_debug_event(bs
, event
);
3025 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3028 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3032 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3033 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3039 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3041 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3045 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3046 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3052 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3054 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3058 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3059 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3065 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3067 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3071 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3072 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3078 int bdrv_is_snapshot(BlockDriverState
*bs
)
3080 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3083 /* backing_file can either be relative, or absolute, or a protocol. If it is
3084 * relative, it must be relative to the chain. So, passing in bs->filename
3085 * from a BDS as backing_file should not be done, as that may be relative to
3086 * the CWD rather than the chain. */
3087 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3088 const char *backing_file
)
3090 char *filename_full
= NULL
;
3091 char *backing_file_full
= NULL
;
3092 char *filename_tmp
= NULL
;
3093 int is_protocol
= 0;
3094 BlockDriverState
*curr_bs
= NULL
;
3095 BlockDriverState
*retval
= NULL
;
3097 if (!bs
|| !bs
->drv
|| !backing_file
) {
3101 filename_full
= g_malloc(PATH_MAX
);
3102 backing_file_full
= g_malloc(PATH_MAX
);
3103 filename_tmp
= g_malloc(PATH_MAX
);
3105 is_protocol
= path_has_protocol(backing_file
);
3107 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3109 /* If either of the filename paths is actually a protocol, then
3110 * compare unmodified paths; otherwise make paths relative */
3111 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3112 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3113 retval
= curr_bs
->backing_hd
;
3117 /* If not an absolute filename path, make it relative to the current
3118 * image's filename path */
3119 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3122 /* We are going to compare absolute pathnames */
3123 if (!realpath(filename_tmp
, filename_full
)) {
3127 /* We need to make sure the backing filename we are comparing against
3128 * is relative to the current image filename (or absolute) */
3129 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3130 curr_bs
->backing_file
);
3132 if (!realpath(filename_tmp
, backing_file_full
)) {
3136 if (strcmp(backing_file_full
, filename_full
) == 0) {
3137 retval
= curr_bs
->backing_hd
;
3143 g_free(filename_full
);
3144 g_free(backing_file_full
);
3145 g_free(filename_tmp
);
3149 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3155 if (!bs
->backing_hd
) {
3159 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3162 void bdrv_init(void)
3164 module_call_init(MODULE_INIT_BLOCK
);
3167 void bdrv_init_with_whitelist(void)
3169 use_bdrv_whitelist
= 1;
3173 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3175 Error
*local_err
= NULL
;
3182 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3185 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3187 if (bs
->drv
->bdrv_invalidate_cache
) {
3188 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3189 } else if (bs
->file
) {
3190 bdrv_invalidate_cache(bs
->file
, &local_err
);
3193 error_propagate(errp
, local_err
);
3197 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3199 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3204 void bdrv_invalidate_cache_all(Error
**errp
)
3206 BlockDriverState
*bs
;
3207 Error
*local_err
= NULL
;
3209 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3210 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3212 aio_context_acquire(aio_context
);
3213 bdrv_invalidate_cache(bs
, &local_err
);
3214 aio_context_release(aio_context
);
3216 error_propagate(errp
, local_err
);
3222 /**************************************************************/
3223 /* removable device support */
3226 * Return TRUE if the media is present
3228 int bdrv_is_inserted(BlockDriverState
*bs
)
3230 BlockDriver
*drv
= bs
->drv
;
3234 if (!drv
->bdrv_is_inserted
)
3236 return drv
->bdrv_is_inserted(bs
);
3240 * Return whether the media changed since the last call to this
3241 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3243 int bdrv_media_changed(BlockDriverState
*bs
)
3245 BlockDriver
*drv
= bs
->drv
;
3247 if (drv
&& drv
->bdrv_media_changed
) {
3248 return drv
->bdrv_media_changed(bs
);
3254 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3256 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3258 BlockDriver
*drv
= bs
->drv
;
3259 const char *device_name
;
3261 if (drv
&& drv
->bdrv_eject
) {
3262 drv
->bdrv_eject(bs
, eject_flag
);
3265 device_name
= bdrv_get_device_name(bs
);
3266 if (device_name
[0] != '\0') {
3267 qapi_event_send_device_tray_moved(device_name
,
3268 eject_flag
, &error_abort
);
3273 * Lock or unlock the media (if it is locked, the user won't be able
3274 * to eject it manually).
3276 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3278 BlockDriver
*drv
= bs
->drv
;
3280 trace_bdrv_lock_medium(bs
, locked
);
3282 if (drv
&& drv
->bdrv_lock_medium
) {
3283 drv
->bdrv_lock_medium(bs
, locked
);
3287 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3289 bs
->guest_block_size
= align
;
3292 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3294 BdrvDirtyBitmap
*bm
;
3297 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3298 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3305 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3307 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3308 g_free(bitmap
->name
);
3309 bitmap
->name
= NULL
;
3312 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3313 uint32_t granularity
,
3317 int64_t bitmap_size
;
3318 BdrvDirtyBitmap
*bitmap
;
3319 uint32_t sector_granularity
;
3321 assert((granularity
& (granularity
- 1)) == 0);
3323 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3324 error_setg(errp
, "Bitmap already exists: %s", name
);
3327 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3328 assert(sector_granularity
);
3329 bitmap_size
= bdrv_nb_sectors(bs
);
3330 if (bitmap_size
< 0) {
3331 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3332 errno
= -bitmap_size
;
3335 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3336 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3337 bitmap
->size
= bitmap_size
;
3338 bitmap
->name
= g_strdup(name
);
3339 bitmap
->disabled
= false;
3340 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3344 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3346 return bitmap
->successor
;
3349 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3351 return !(bitmap
->disabled
|| bitmap
->successor
);
3354 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3356 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3357 return DIRTY_BITMAP_STATUS_FROZEN
;
3358 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3359 return DIRTY_BITMAP_STATUS_DISABLED
;
3361 return DIRTY_BITMAP_STATUS_ACTIVE
;
3366 * Create a successor bitmap destined to replace this bitmap after an operation.
3367 * Requires that the bitmap is not frozen and has no successor.
3369 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3370 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3372 uint64_t granularity
;
3373 BdrvDirtyBitmap
*child
;
3375 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3376 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3377 "currently frozen");
3380 assert(!bitmap
->successor
);
3382 /* Create an anonymous successor */
3383 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3384 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3389 /* Successor will be on or off based on our current state. */
3390 child
->disabled
= bitmap
->disabled
;
3392 /* Install the successor and freeze the parent */
3393 bitmap
->successor
= child
;
3398 * For a bitmap with a successor, yield our name to the successor,
3399 * delete the old bitmap, and return a handle to the new bitmap.
3401 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3402 BdrvDirtyBitmap
*bitmap
,
3406 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3408 if (successor
== NULL
) {
3409 error_setg(errp
, "Cannot relinquish control if "
3410 "there's no successor present");
3414 name
= bitmap
->name
;
3415 bitmap
->name
= NULL
;
3416 successor
->name
= name
;
3417 bitmap
->successor
= NULL
;
3418 bdrv_release_dirty_bitmap(bs
, bitmap
);
3424 * In cases of failure where we can no longer safely delete the parent,
3425 * we may wish to re-join the parent and child/successor.
3426 * The merged parent will be un-frozen, but not explicitly re-enabled.
3428 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3429 BdrvDirtyBitmap
*parent
,
3432 BdrvDirtyBitmap
*successor
= parent
->successor
;
3435 error_setg(errp
, "Cannot reclaim a successor when none is present");
3439 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3440 error_setg(errp
, "Merging of parent and successor bitmap failed");
3443 bdrv_release_dirty_bitmap(bs
, successor
);
3444 parent
->successor
= NULL
;
3450 * Truncates _all_ bitmaps attached to a BDS.
3452 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3454 BdrvDirtyBitmap
*bitmap
;
3455 uint64_t size
= bdrv_nb_sectors(bs
);
3457 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3458 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3459 hbitmap_truncate(bitmap
->bitmap
, size
);
3460 bitmap
->size
= size
;
3464 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3466 BdrvDirtyBitmap
*bm
, *next
;
3467 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3469 assert(!bdrv_dirty_bitmap_frozen(bm
));
3470 QLIST_REMOVE(bitmap
, list
);
3471 hbitmap_free(bitmap
->bitmap
);
3472 g_free(bitmap
->name
);
3479 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3481 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3482 bitmap
->disabled
= true;
3485 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3487 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3488 bitmap
->disabled
= false;
3491 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3493 BdrvDirtyBitmap
*bm
;
3494 BlockDirtyInfoList
*list
= NULL
;
3495 BlockDirtyInfoList
**plist
= &list
;
3497 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3498 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3499 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3500 info
->count
= bdrv_get_dirty_count(bm
);
3501 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3502 info
->has_name
= !!bm
->name
;
3503 info
->name
= g_strdup(bm
->name
);
3504 info
->status
= bdrv_dirty_bitmap_status(bm
);
3505 entry
->value
= info
;
3507 plist
= &entry
->next
;
3513 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3516 return hbitmap_get(bitmap
->bitmap
, sector
);
3523 * Chooses a default granularity based on the existing cluster size,
3524 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3525 * is no cluster size information available.
3527 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3529 BlockDriverInfo bdi
;
3530 uint32_t granularity
;
3532 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3533 granularity
= MAX(4096, bdi
.cluster_size
);
3534 granularity
= MIN(65536, granularity
);
3536 granularity
= 65536;
3542 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3544 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3547 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3549 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3552 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3553 int64_t cur_sector
, int nr_sectors
)
3555 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3556 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3559 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3560 int64_t cur_sector
, int nr_sectors
)
3562 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3563 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3566 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3568 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3569 hbitmap_reset_all(bitmap
->bitmap
);
3572 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3575 BdrvDirtyBitmap
*bitmap
;
3576 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3577 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3580 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3585 * Advance an HBitmapIter to an arbitrary offset.
3587 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3590 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3593 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3595 return hbitmap_count(bitmap
->bitmap
);
3598 /* Get a reference to bs */
3599 void bdrv_ref(BlockDriverState
*bs
)
3604 /* Release a previously grabbed reference to bs.
3605 * If after releasing, reference count is zero, the BlockDriverState is
3607 void bdrv_unref(BlockDriverState
*bs
)
3612 assert(bs
->refcnt
> 0);
3613 if (--bs
->refcnt
== 0) {
3618 struct BdrvOpBlocker
{
3620 QLIST_ENTRY(BdrvOpBlocker
) list
;
3623 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3625 BdrvOpBlocker
*blocker
;
3626 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3627 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3628 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3630 error_setg(errp
, "Node '%s' is busy: %s",
3631 bdrv_get_device_or_node_name(bs
),
3632 error_get_pretty(blocker
->reason
));
3639 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3641 BdrvOpBlocker
*blocker
;
3642 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3644 blocker
= g_new0(BdrvOpBlocker
, 1);
3645 blocker
->reason
= reason
;
3646 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3649 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3651 BdrvOpBlocker
*blocker
, *next
;
3652 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3653 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3654 if (blocker
->reason
== reason
) {
3655 QLIST_REMOVE(blocker
, list
);
3661 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3664 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3665 bdrv_op_block(bs
, i
, reason
);
3669 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3672 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3673 bdrv_op_unblock(bs
, i
, reason
);
3677 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3681 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3682 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3689 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3691 bs
->iostatus_enabled
= true;
3692 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3695 /* The I/O status is only enabled if the drive explicitly
3696 * enables it _and_ the VM is configured to stop on errors */
3697 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3699 return (bs
->iostatus_enabled
&&
3700 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3701 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3702 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3705 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3707 bs
->iostatus_enabled
= false;
3710 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3712 if (bdrv_iostatus_is_enabled(bs
)) {
3713 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3715 block_job_iostatus_reset(bs
->job
);
3720 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3722 assert(bdrv_iostatus_is_enabled(bs
));
3723 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3724 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3725 BLOCK_DEVICE_IO_STATUS_FAILED
;
3729 void bdrv_img_create(const char *filename
, const char *fmt
,
3730 const char *base_filename
, const char *base_fmt
,
3731 char *options
, uint64_t img_size
, int flags
,
3732 Error
**errp
, bool quiet
)
3734 QemuOptsList
*create_opts
= NULL
;
3735 QemuOpts
*opts
= NULL
;
3736 const char *backing_fmt
, *backing_file
;
3738 BlockDriver
*drv
, *proto_drv
;
3739 BlockDriver
*backing_drv
= NULL
;
3740 Error
*local_err
= NULL
;
3743 /* Find driver and parse its options */
3744 drv
= bdrv_find_format(fmt
);
3746 error_setg(errp
, "Unknown file format '%s'", fmt
);
3750 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3755 if (!drv
->create_opts
) {
3756 error_setg(errp
, "Format driver '%s' does not support image creation",
3761 if (!proto_drv
->create_opts
) {
3762 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3763 proto_drv
->format_name
);
3767 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3768 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3770 /* Create parameter list with default values */
3771 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3772 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3774 /* Parse -o options */
3776 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3778 error_report_err(local_err
);
3780 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3785 if (base_filename
) {
3786 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3788 error_setg(errp
, "Backing file not supported for file format '%s'",
3795 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3797 error_setg(errp
, "Backing file format not supported for file "
3798 "format '%s'", fmt
);
3803 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3805 if (!strcmp(filename
, backing_file
)) {
3806 error_setg(errp
, "Error: Trying to create an image with the "
3807 "same filename as the backing file");
3812 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3814 backing_drv
= bdrv_find_format(backing_fmt
);
3816 error_setg(errp
, "Unknown backing file format '%s'",
3822 // The size for the image must always be specified, with one exception:
3823 // If we are using a backing file, we can obtain the size from there
3824 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3827 BlockDriverState
*bs
;
3828 char *full_backing
= g_new0(char, PATH_MAX
);
3832 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3833 full_backing
, PATH_MAX
,
3836 g_free(full_backing
);
3840 /* backing files always opened read-only */
3842 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3845 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
3846 backing_drv
, &local_err
);
3847 g_free(full_backing
);
3851 size
= bdrv_getlength(bs
);
3853 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3859 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3863 error_setg(errp
, "Image creation needs a size parameter");
3869 printf("Formatting '%s', fmt=%s", filename
, fmt
);
3870 qemu_opts_print(opts
, " ");
3874 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3876 if (ret
== -EFBIG
) {
3877 /* This is generally a better message than whatever the driver would
3878 * deliver (especially because of the cluster_size_hint), since that
3879 * is most probably not much different from "image too large". */
3880 const char *cluster_size_hint
= "";
3881 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3882 cluster_size_hint
= " (try using a larger cluster size)";
3884 error_setg(errp
, "The image size is too large for file format '%s'"
3885 "%s", fmt
, cluster_size_hint
);
3886 error_free(local_err
);
3891 qemu_opts_del(opts
);
3892 qemu_opts_free(create_opts
);
3894 error_propagate(errp
, local_err
);
3898 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3900 return bs
->aio_context
;
3903 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3905 BdrvAioNotifier
*baf
;
3911 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3912 baf
->detach_aio_context(baf
->opaque
);
3915 if (bs
->io_limits_enabled
) {
3916 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3918 if (bs
->drv
->bdrv_detach_aio_context
) {
3919 bs
->drv
->bdrv_detach_aio_context(bs
);
3922 bdrv_detach_aio_context(bs
->file
);
3924 if (bs
->backing_hd
) {
3925 bdrv_detach_aio_context(bs
->backing_hd
);
3928 bs
->aio_context
= NULL
;
3931 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3932 AioContext
*new_context
)
3934 BdrvAioNotifier
*ban
;
3940 bs
->aio_context
= new_context
;
3942 if (bs
->backing_hd
) {
3943 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3946 bdrv_attach_aio_context(bs
->file
, new_context
);
3948 if (bs
->drv
->bdrv_attach_aio_context
) {
3949 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3951 if (bs
->io_limits_enabled
) {
3952 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3955 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3956 ban
->attached_aio_context(new_context
, ban
->opaque
);
3960 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3962 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3964 bdrv_detach_aio_context(bs
);
3966 /* This function executes in the old AioContext so acquire the new one in
3967 * case it runs in a different thread.
3969 aio_context_acquire(new_context
);
3970 bdrv_attach_aio_context(bs
, new_context
);
3971 aio_context_release(new_context
);
3974 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3975 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3976 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3978 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3979 *ban
= (BdrvAioNotifier
){
3980 .attached_aio_context
= attached_aio_context
,
3981 .detach_aio_context
= detach_aio_context
,
3985 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3988 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3989 void (*attached_aio_context
)(AioContext
*,
3991 void (*detach_aio_context
)(void *),
3994 BdrvAioNotifier
*ban
, *ban_next
;
3996 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3997 if (ban
->attached_aio_context
== attached_aio_context
&&
3998 ban
->detach_aio_context
== detach_aio_context
&&
3999 ban
->opaque
== opaque
)
4001 QLIST_REMOVE(ban
, list
);
4011 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
4012 BlockDriverAmendStatusCB
*status_cb
)
4014 if (!bs
->drv
->bdrv_amend_options
) {
4017 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
4020 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4021 * of block filter and by bdrv_is_first_non_filter.
4022 * It is used to test if the given bs is the candidate or recurse more in the
4025 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
4026 BlockDriverState
*candidate
)
4028 /* return false if basic checks fails */
4029 if (!bs
|| !bs
->drv
) {
4033 /* the code reached a non block filter driver -> check if the bs is
4034 * the same as the candidate. It's the recursion termination condition.
4036 if (!bs
->drv
->is_filter
) {
4037 return bs
== candidate
;
4039 /* Down this path the driver is a block filter driver */
4041 /* If the block filter recursion method is defined use it to recurse down
4044 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4045 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4048 /* the driver is a block filter but don't allow to recurse -> return false
4053 /* This function checks if the candidate is the first non filter bs down it's
4054 * bs chain. Since we don't have pointers to parents it explore all bs chains
4055 * from the top. Some filters can choose not to pass down the recursion.
4057 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4059 BlockDriverState
*bs
;
4061 /* walk down the bs forest recursively */
4062 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4065 /* try to recurse in this top level bs */
4066 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4068 /* candidate is the first non filter */
4077 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
4079 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4080 AioContext
*aio_context
;
4082 if (!to_replace_bs
) {
4083 error_setg(errp
, "Node name '%s' not found", node_name
);
4087 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4088 aio_context_acquire(aio_context
);
4090 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4091 to_replace_bs
= NULL
;
4095 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4096 * most non filter in order to prevent data corruption.
4097 * Another benefit is that this tests exclude backing files which are
4098 * blocked by the backing blockers.
4100 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
4101 error_setg(errp
, "Only top most non filter can be replaced");
4102 to_replace_bs
= NULL
;
4107 aio_context_release(aio_context
);
4108 return to_replace_bs
;
4111 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4113 const QDictEntry
*entry
;
4114 bool found_any
= false;
4116 for (entry
= qdict_first(bs
->options
); entry
;
4117 entry
= qdict_next(bs
->options
, entry
))
4119 /* Only take options for this level and exclude all non-driver-specific
4121 if (!strchr(qdict_entry_key(entry
), '.') &&
4122 strcmp(qdict_entry_key(entry
), "node-name"))
4124 qobject_incref(qdict_entry_value(entry
));
4125 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4133 /* Updates the following BDS fields:
4134 * - exact_filename: A filename which may be used for opening a block device
4135 * which (mostly) equals the given BDS (even without any
4136 * other options; so reading and writing must return the same
4137 * results, but caching etc. may be different)
4138 * - full_open_options: Options which, when given when opening a block device
4139 * (without a filename), result in a BDS (mostly)
4140 * equalling the given one
4141 * - filename: If exact_filename is set, it is copied here. Otherwise,
4142 * full_open_options is converted to a JSON object, prefixed with
4143 * "json:" (for use through the JSON pseudo protocol) and put here.
4145 void bdrv_refresh_filename(BlockDriverState
*bs
)
4147 BlockDriver
*drv
= bs
->drv
;
4154 /* This BDS's file name will most probably depend on its file's name, so
4155 * refresh that first */
4157 bdrv_refresh_filename(bs
->file
);
4160 if (drv
->bdrv_refresh_filename
) {
4161 /* Obsolete information is of no use here, so drop the old file name
4162 * information before refreshing it */
4163 bs
->exact_filename
[0] = '\0';
4164 if (bs
->full_open_options
) {
4165 QDECREF(bs
->full_open_options
);
4166 bs
->full_open_options
= NULL
;
4169 drv
->bdrv_refresh_filename(bs
);
4170 } else if (bs
->file
) {
4171 /* Try to reconstruct valid information from the underlying file */
4172 bool has_open_options
;
4174 bs
->exact_filename
[0] = '\0';
4175 if (bs
->full_open_options
) {
4176 QDECREF(bs
->full_open_options
);
4177 bs
->full_open_options
= NULL
;
4181 has_open_options
= append_open_options(opts
, bs
);
4183 /* If no specific options have been given for this BDS, the filename of
4184 * the underlying file should suffice for this one as well */
4185 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
4186 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
4188 /* Reconstructing the full options QDict is simple for most format block
4189 * drivers, as long as the full options are known for the underlying
4190 * file BDS. The full options QDict of that file BDS should somehow
4191 * contain a representation of the filename, therefore the following
4192 * suffices without querying the (exact_)filename of this BDS. */
4193 if (bs
->file
->full_open_options
) {
4194 qdict_put_obj(opts
, "driver",
4195 QOBJECT(qstring_from_str(drv
->format_name
)));
4196 QINCREF(bs
->file
->full_open_options
);
4197 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
4199 bs
->full_open_options
= opts
;
4203 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4204 /* There is no underlying file BDS (at least referenced by BDS.file),
4205 * so the full options QDict should be equal to the options given
4206 * specifically for this block device when it was opened (plus the
4207 * driver specification).
4208 * Because those options don't change, there is no need to update
4209 * full_open_options when it's already set. */
4212 append_open_options(opts
, bs
);
4213 qdict_put_obj(opts
, "driver",
4214 QOBJECT(qstring_from_str(drv
->format_name
)));
4216 if (bs
->exact_filename
[0]) {
4217 /* This may not work for all block protocol drivers (some may
4218 * require this filename to be parsed), but we have to find some
4219 * default solution here, so just include it. If some block driver
4220 * does not support pure options without any filename at all or
4221 * needs some special format of the options QDict, it needs to
4222 * implement the driver-specific bdrv_refresh_filename() function.
4224 qdict_put_obj(opts
, "filename",
4225 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4228 bs
->full_open_options
= opts
;
4231 if (bs
->exact_filename
[0]) {
4232 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4233 } else if (bs
->full_open_options
) {
4234 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4235 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4236 qstring_get_str(json
));
4241 /* This accessor function purpose is to allow the device models to access the
4242 * BlockAcctStats structure embedded inside a BlockDriverState without being
4243 * aware of the BlockDriverState structure layout.
4244 * It will go away when the BlockAcctStats structure will be moved inside
4245 * the device models.
4247 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)