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/qjson.h"
32 #include "sysemu/block-backend.h"
33 #include "sysemu/sysemu.h"
34 #include "qemu/notify.h"
35 #include "block/coroutine.h"
36 #include "block/qapi.h"
37 #include "qmp-commands.h"
38 #include "qemu/timer.h"
39 #include "qapi-event.h"
40 #include "block/throttle-groups.h"
43 #include <sys/types.h>
45 #include <sys/ioctl.h>
46 #include <sys/queue.h>
57 * A BdrvDirtyBitmap can be in three possible states:
58 * (1) successor is NULL and disabled is false: full r/w mode
59 * (2) successor is NULL and disabled is true: read only mode ("disabled")
60 * (3) successor is set: frozen mode.
61 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
62 * or enabled. A frozen bitmap can only abdicate() or reclaim().
64 struct BdrvDirtyBitmap
{
65 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
66 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
67 char *name
; /* Optional non-empty unique ID */
68 int64_t size
; /* Size of the bitmap (Number of sectors) */
69 bool disabled
; /* Bitmap is read-only */
70 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
73 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
75 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
76 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
78 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
79 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
81 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
82 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
84 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
85 const char *reference
, QDict
*options
, int flags
,
86 BlockDriverState
*parent
,
87 const BdrvChildRole
*child_role
,
88 BlockDriver
*drv
, Error
**errp
);
90 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
91 /* If non-zero, use only whitelisted block drivers */
92 static int use_bdrv_whitelist
;
95 static int is_windows_drive_prefix(const char *filename
)
97 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
98 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
102 int is_windows_drive(const char *filename
)
104 if (is_windows_drive_prefix(filename
) &&
107 if (strstart(filename
, "\\\\.\\", NULL
) ||
108 strstart(filename
, "//./", NULL
))
114 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
116 if (!bs
|| !bs
->drv
) {
117 /* page size or 4k (hdd sector size) should be on the safe side */
118 return MAX(4096, getpagesize());
121 return bs
->bl
.opt_mem_alignment
;
124 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
126 if (!bs
|| !bs
->drv
) {
127 /* page size or 4k (hdd sector size) should be on the safe side */
128 return MAX(4096, getpagesize());
131 return bs
->bl
.min_mem_alignment
;
134 /* check if the path starts with "<protocol>:" */
135 int path_has_protocol(const char *path
)
140 if (is_windows_drive(path
) ||
141 is_windows_drive_prefix(path
)) {
144 p
= path
+ strcspn(path
, ":/\\");
146 p
= path
+ strcspn(path
, ":/");
152 int path_is_absolute(const char *path
)
155 /* specific case for names like: "\\.\d:" */
156 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
159 return (*path
== '/' || *path
== '\\');
161 return (*path
== '/');
165 /* if filename is absolute, just copy it to dest. Otherwise, build a
166 path to it by considering it is relative to base_path. URL are
168 void path_combine(char *dest
, int dest_size
,
169 const char *base_path
,
170 const char *filename
)
177 if (path_is_absolute(filename
)) {
178 pstrcpy(dest
, dest_size
, filename
);
180 p
= strchr(base_path
, ':');
185 p1
= strrchr(base_path
, '/');
189 p2
= strrchr(base_path
, '\\');
201 if (len
> dest_size
- 1)
203 memcpy(dest
, base_path
, len
);
205 pstrcat(dest
, dest_size
, filename
);
209 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
211 char *dest
, size_t sz
,
214 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
215 path_is_absolute(backing
))
217 pstrcpy(dest
, sz
, backing
);
218 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
219 error_setg(errp
, "Cannot use relative backing file names for '%s'",
222 path_combine(dest
, sz
, backed
, backing
);
226 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
229 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
231 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
235 void bdrv_register(BlockDriver
*bdrv
)
237 bdrv_setup_io_funcs(bdrv
);
239 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
242 BlockDriverState
*bdrv_new_root(void)
244 BlockDriverState
*bs
= bdrv_new();
246 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
250 BlockDriverState
*bdrv_new(void)
252 BlockDriverState
*bs
;
255 bs
= g_new0(BlockDriverState
, 1);
256 QLIST_INIT(&bs
->dirty_bitmaps
);
257 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
258 QLIST_INIT(&bs
->op_blockers
[i
]);
260 bdrv_iostatus_disable(bs
);
261 notifier_list_init(&bs
->close_notifiers
);
262 notifier_with_return_list_init(&bs
->before_write_notifiers
);
263 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
264 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
266 bs
->aio_context
= qemu_get_aio_context();
271 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
273 notifier_list_add(&bs
->close_notifiers
, notify
);
276 BlockDriver
*bdrv_find_format(const char *format_name
)
279 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
280 if (!strcmp(drv1
->format_name
, format_name
)) {
287 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
289 static const char *whitelist_rw
[] = {
290 CONFIG_BDRV_RW_WHITELIST
292 static const char *whitelist_ro
[] = {
293 CONFIG_BDRV_RO_WHITELIST
297 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
298 return 1; /* no whitelist, anything goes */
301 for (p
= whitelist_rw
; *p
; p
++) {
302 if (!strcmp(drv
->format_name
, *p
)) {
307 for (p
= whitelist_ro
; *p
; p
++) {
308 if (!strcmp(drv
->format_name
, *p
)) {
316 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
319 BlockDriver
*drv
= bdrv_find_format(format_name
);
320 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
323 typedef struct CreateCo
{
331 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
333 Error
*local_err
= NULL
;
336 CreateCo
*cco
= opaque
;
339 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
341 error_propagate(&cco
->err
, local_err
);
346 int bdrv_create(BlockDriver
*drv
, const char* filename
,
347 QemuOpts
*opts
, Error
**errp
)
354 .filename
= g_strdup(filename
),
360 if (!drv
->bdrv_create
) {
361 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
366 if (qemu_in_coroutine()) {
367 /* Fast-path if already in coroutine context */
368 bdrv_create_co_entry(&cco
);
370 co
= qemu_coroutine_create(bdrv_create_co_entry
);
371 qemu_coroutine_enter(co
, &cco
);
372 while (cco
.ret
== NOT_DONE
) {
373 aio_poll(qemu_get_aio_context(), true);
380 error_propagate(errp
, cco
.err
);
382 error_setg_errno(errp
, -ret
, "Could not create image");
387 g_free(cco
.filename
);
391 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
394 Error
*local_err
= NULL
;
397 drv
= bdrv_find_protocol(filename
, true, errp
);
402 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
404 error_propagate(errp
, local_err
);
410 * Try to get @bs's logical and physical block size.
411 * On success, store them in @bsz struct and return 0.
412 * On failure return -errno.
413 * @bs must not be empty.
415 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
417 BlockDriver
*drv
= bs
->drv
;
419 if (drv
&& drv
->bdrv_probe_blocksizes
) {
420 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
427 * Try to get @bs's geometry (cyls, heads, sectors).
428 * On success, store them in @geo struct and return 0.
429 * On failure return -errno.
430 * @bs must not be empty.
432 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
434 BlockDriver
*drv
= bs
->drv
;
436 if (drv
&& drv
->bdrv_probe_geometry
) {
437 return drv
->bdrv_probe_geometry(bs
, geo
);
444 * Create a uniquely-named empty temporary file.
445 * Return 0 upon success, otherwise a negative errno value.
447 int get_tmp_filename(char *filename
, int size
)
450 char temp_dir
[MAX_PATH
];
451 /* GetTempFileName requires that its output buffer (4th param)
452 have length MAX_PATH or greater. */
453 assert(size
>= MAX_PATH
);
454 return (GetTempPath(MAX_PATH
, temp_dir
)
455 && GetTempFileName(temp_dir
, "qem", 0, filename
)
456 ? 0 : -GetLastError());
460 tmpdir
= getenv("TMPDIR");
464 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
467 fd
= mkstemp(filename
);
471 if (close(fd
) != 0) {
480 * Detect host devices. By convention, /dev/cdrom[N] is always
481 * recognized as a host CDROM.
483 static BlockDriver
*find_hdev_driver(const char *filename
)
485 int score_max
= 0, score
;
486 BlockDriver
*drv
= NULL
, *d
;
488 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
489 if (d
->bdrv_probe_device
) {
490 score
= d
->bdrv_probe_device(filename
);
491 if (score
> score_max
) {
501 BlockDriver
*bdrv_find_protocol(const char *filename
,
502 bool allow_protocol_prefix
,
510 /* TODO Drivers without bdrv_file_open must be specified explicitly */
513 * XXX(hch): we really should not let host device detection
514 * override an explicit protocol specification, but moving this
515 * later breaks access to device names with colons in them.
516 * Thanks to the brain-dead persistent naming schemes on udev-
517 * based Linux systems those actually are quite common.
519 drv1
= find_hdev_driver(filename
);
524 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
528 p
= strchr(filename
, ':');
531 if (len
> sizeof(protocol
) - 1)
532 len
= sizeof(protocol
) - 1;
533 memcpy(protocol
, filename
, len
);
534 protocol
[len
] = '\0';
535 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
536 if (drv1
->protocol_name
&&
537 !strcmp(drv1
->protocol_name
, protocol
)) {
542 error_setg(errp
, "Unknown protocol '%s'", protocol
);
547 * Guess image format by probing its contents.
548 * This is not a good idea when your image is raw (CVE-2008-2004), but
549 * we do it anyway for backward compatibility.
551 * @buf contains the image's first @buf_size bytes.
552 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
553 * but can be smaller if the image file is smaller)
554 * @filename is its filename.
556 * For all block drivers, call the bdrv_probe() method to get its
558 * Return the first block driver with the highest probing score.
560 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
561 const char *filename
)
563 int score_max
= 0, score
;
564 BlockDriver
*drv
= NULL
, *d
;
566 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
568 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
569 if (score
> score_max
) {
579 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
580 BlockDriver
**pdrv
, Error
**errp
)
583 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
586 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
587 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
592 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
594 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
600 drv
= bdrv_probe_all(buf
, ret
, filename
);
602 error_setg(errp
, "Could not determine image format: No compatible "
611 * Set the current 'total_sectors' value
612 * Return 0 on success, -errno on error.
614 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
616 BlockDriver
*drv
= bs
->drv
;
618 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
622 /* query actual device if possible, otherwise just trust the hint */
623 if (drv
->bdrv_getlength
) {
624 int64_t length
= drv
->bdrv_getlength(bs
);
628 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
631 bs
->total_sectors
= hint
;
636 * Set open flags for a given discard mode
638 * Return 0 on success, -1 if the discard mode was invalid.
640 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
642 *flags
&= ~BDRV_O_UNMAP
;
644 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
646 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
647 *flags
|= BDRV_O_UNMAP
;
656 * Set open flags for a given cache mode
658 * Return 0 on success, -1 if the cache mode was invalid.
660 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
662 *flags
&= ~BDRV_O_CACHE_MASK
;
664 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
665 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
666 } else if (!strcmp(mode
, "directsync")) {
667 *flags
|= BDRV_O_NOCACHE
;
668 } else if (!strcmp(mode
, "writeback")) {
669 *flags
|= BDRV_O_CACHE_WB
;
670 } else if (!strcmp(mode
, "unsafe")) {
671 *flags
|= BDRV_O_CACHE_WB
;
672 *flags
|= BDRV_O_NO_FLUSH
;
673 } else if (!strcmp(mode
, "writethrough")) {
674 /* this is the default */
683 * Returns the flags that a temporary snapshot should get, based on the
684 * originally requested flags (the originally requested image will have flags
685 * like a backing file)
687 static int bdrv_temp_snapshot_flags(int flags
)
689 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
693 * Returns the flags that bs->file should get if a protocol driver is expected,
694 * based on the given flags for the parent BDS
696 static int bdrv_inherited_flags(int flags
)
698 /* Enable protocol handling, disable format probing for bs->file */
699 flags
|= BDRV_O_PROTOCOL
;
701 /* Our block drivers take care to send flushes and respect unmap policy,
702 * so we can enable both unconditionally on lower layers. */
703 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
705 /* Clear flags that only apply to the top layer */
706 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
711 const BdrvChildRole child_file
= {
712 .inherit_flags
= bdrv_inherited_flags
,
716 * Returns the flags that bs->file should get if the use of formats (and not
717 * only protocols) is permitted for it, based on the given flags for the parent
720 static int bdrv_inherited_fmt_flags(int parent_flags
)
722 int flags
= child_file
.inherit_flags(parent_flags
);
723 return flags
& ~BDRV_O_PROTOCOL
;
726 const BdrvChildRole child_format
= {
727 .inherit_flags
= bdrv_inherited_fmt_flags
,
731 * Returns the flags that bs->backing_hd should get, based on the given flags
734 static int bdrv_backing_flags(int flags
)
736 /* backing files always opened read-only */
737 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
739 /* snapshot=on is handled on the top layer */
740 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
745 static const BdrvChildRole child_backing
= {
746 .inherit_flags
= bdrv_backing_flags
,
749 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
751 int open_flags
= flags
| BDRV_O_CACHE_WB
;
754 * Clear flags that are internal to the block layer before opening the
757 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
760 * Snapshots should be writable.
762 if (flags
& BDRV_O_TEMPORARY
) {
763 open_flags
|= BDRV_O_RDWR
;
769 static void bdrv_assign_node_name(BlockDriverState
*bs
,
770 const char *node_name
,
777 /* Check for empty string or invalid characters */
778 if (!id_wellformed(node_name
)) {
779 error_setg(errp
, "Invalid node name");
783 /* takes care of avoiding namespaces collisions */
784 if (blk_by_name(node_name
)) {
785 error_setg(errp
, "node-name=%s is conflicting with a device id",
790 /* takes care of avoiding duplicates node names */
791 if (bdrv_find_node(node_name
)) {
792 error_setg(errp
, "Duplicate node name");
796 /* copy node name into the bs and insert it into the graph list */
797 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
798 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
801 static QemuOptsList bdrv_runtime_opts
= {
802 .name
= "bdrv_common",
803 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
807 .type
= QEMU_OPT_STRING
,
808 .help
= "Node name of the block device node",
810 { /* end of list */ }
815 * Common part for opening disk images and files
817 * Removes all processed options from *options.
819 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
820 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
823 const char *filename
;
824 const char *node_name
= NULL
;
826 Error
*local_err
= NULL
;
829 assert(bs
->file
== NULL
);
830 assert(options
!= NULL
&& bs
->options
!= options
);
833 filename
= file
->filename
;
835 filename
= qdict_get_try_str(options
, "filename");
838 if (drv
->bdrv_needs_filename
&& !filename
) {
839 error_setg(errp
, "The '%s' block driver requires a file name",
844 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
846 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
847 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
849 error_propagate(errp
, local_err
);
854 node_name
= qemu_opt_get(opts
, "node-name");
855 bdrv_assign_node_name(bs
, node_name
, &local_err
);
857 error_propagate(errp
, local_err
);
862 bs
->guest_block_size
= 512;
863 bs
->request_alignment
= 512;
864 bs
->zero_beyond_eof
= true;
865 open_flags
= bdrv_open_flags(bs
, flags
);
866 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
868 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
870 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
871 ? "Driver '%s' can only be used for read-only devices"
872 : "Driver '%s' is not whitelisted",
878 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
879 if (flags
& BDRV_O_COPY_ON_READ
) {
880 if (!bs
->read_only
) {
881 bdrv_enable_copy_on_read(bs
);
883 error_setg(errp
, "Can't use copy-on-read on read-only device");
889 if (filename
!= NULL
) {
890 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
892 bs
->filename
[0] = '\0';
894 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
897 bs
->opaque
= g_malloc0(drv
->instance_size
);
899 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
901 /* Open the image, either directly or using a protocol */
902 if (drv
->bdrv_file_open
) {
903 assert(file
== NULL
);
904 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
905 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
908 error_setg(errp
, "Can't use '%s' as a block driver for the "
909 "protocol level", drv
->format_name
);
914 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
919 error_propagate(errp
, local_err
);
920 } else if (bs
->filename
[0]) {
921 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
923 error_setg_errno(errp
, -ret
, "Could not open image");
929 error_report("Encrypted images are deprecated");
930 error_printf("Support for them will be removed in a future release.\n"
931 "You can use 'qemu-img convert' to convert your image"
932 " to an unencrypted one.\n");
935 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
937 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
941 bdrv_refresh_limits(bs
, &local_err
);
943 error_propagate(errp
, local_err
);
948 assert(bdrv_opt_mem_align(bs
) != 0);
949 assert(bdrv_min_mem_align(bs
) != 0);
950 assert((bs
->request_alignment
!= 0) || bs
->sg
);
965 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
967 QObject
*options_obj
;
971 ret
= strstart(filename
, "json:", &filename
);
974 options_obj
= qobject_from_json(filename
);
976 error_setg(errp
, "Could not parse the JSON options");
980 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
981 qobject_decref(options_obj
);
982 error_setg(errp
, "Invalid JSON object given");
986 options
= qobject_to_qdict(options_obj
);
987 qdict_flatten(options
);
993 * Fills in default options for opening images and converts the legacy
994 * filename/flags pair to option QDict entries.
995 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
996 * block driver has been specified explicitly.
998 static int bdrv_fill_options(QDict
**options
, const char **pfilename
,
999 int *flags
, BlockDriver
*drv
, Error
**errp
)
1001 const char *filename
= *pfilename
;
1002 const char *drvname
;
1003 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1004 bool parse_filename
= false;
1005 BlockDriver
*tmp_drv
;
1006 Error
*local_err
= NULL
;
1008 /* Parse json: pseudo-protocol */
1009 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1010 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1012 error_propagate(errp
, local_err
);
1016 /* Options given in the filename have lower priority than options
1017 * specified directly */
1018 qdict_join(*options
, json_options
, false);
1019 QDECREF(json_options
);
1020 *pfilename
= filename
= NULL
;
1023 drvname
= qdict_get_try_str(*options
, "driver");
1025 /* If the user has explicitly specified the driver, this choice should
1026 * override the BDRV_O_PROTOCOL flag */
1028 if (!tmp_drv
&& drvname
) {
1029 tmp_drv
= bdrv_find_format(drvname
);
1032 protocol
= tmp_drv
->bdrv_file_open
;
1036 *flags
|= BDRV_O_PROTOCOL
;
1038 *flags
&= ~BDRV_O_PROTOCOL
;
1041 /* Fetch the file name from the options QDict if necessary */
1042 if (protocol
&& filename
) {
1043 if (!qdict_haskey(*options
, "filename")) {
1044 qdict_put(*options
, "filename", qstring_from_str(filename
));
1045 parse_filename
= true;
1047 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1053 /* Find the right block driver */
1054 filename
= qdict_get_try_str(*options
, "filename");
1058 error_setg(errp
, "Driver specified twice");
1061 drvname
= drv
->format_name
;
1062 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1064 if (!drvname
&& protocol
) {
1066 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1071 drvname
= drv
->format_name
;
1072 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1074 error_setg(errp
, "Must specify either driver or file");
1077 } else if (drvname
) {
1078 drv
= bdrv_find_format(drvname
);
1080 error_setg(errp
, "Unknown driver '%s'", drvname
);
1086 assert(drv
|| !protocol
);
1088 /* Driver-specific filename parsing */
1089 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1090 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1092 error_propagate(errp
, local_err
);
1096 if (!drv
->bdrv_needs_filename
) {
1097 qdict_del(*options
, "filename");
1104 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1107 if (bs
->backing_hd
) {
1108 assert(bs
->backing_blocker
);
1109 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1110 } else if (backing_hd
) {
1111 error_setg(&bs
->backing_blocker
,
1112 "node is used as backing hd of '%s'",
1113 bdrv_get_device_or_node_name(bs
));
1116 bs
->backing_hd
= backing_hd
;
1118 error_free(bs
->backing_blocker
);
1119 bs
->backing_blocker
= NULL
;
1122 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1123 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1124 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1125 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1127 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1128 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1129 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1130 bs
->backing_blocker
);
1132 bdrv_refresh_limits(bs
, NULL
);
1136 * Opens the backing file for a BlockDriverState if not yet open
1138 * options is a QDict of options to pass to the block drivers, or NULL for an
1139 * empty set of options. The reference to the QDict is transferred to this
1140 * function (even on failure), so if the caller intends to reuse the dictionary,
1141 * it needs to use QINCREF() before calling bdrv_file_open.
1143 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1145 char *backing_filename
= g_malloc0(PATH_MAX
);
1147 BlockDriverState
*backing_hd
;
1148 Error
*local_err
= NULL
;
1150 if (bs
->backing_hd
!= NULL
) {
1155 /* NULL means an empty set of options */
1156 if (options
== NULL
) {
1157 options
= qdict_new();
1160 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1161 if (qdict_haskey(options
, "file.filename")) {
1162 backing_filename
[0] = '\0';
1163 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1167 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1171 error_propagate(errp
, local_err
);
1177 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1179 error_setg(errp
, "Driver doesn't support backing files");
1184 backing_hd
= bdrv_new();
1186 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1187 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1190 assert(bs
->backing_hd
== NULL
);
1191 ret
= bdrv_open_inherit(&backing_hd
,
1192 *backing_filename
? backing_filename
: NULL
,
1193 NULL
, options
, 0, bs
, &child_backing
,
1196 bdrv_unref(backing_hd
);
1198 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1199 error_setg(errp
, "Could not open backing file: %s",
1200 error_get_pretty(local_err
));
1201 error_free(local_err
);
1204 bdrv_set_backing_hd(bs
, backing_hd
);
1207 g_free(backing_filename
);
1212 * Opens a disk image whose options are given as BlockdevRef in another block
1215 * If allow_none is true, no image will be opened if filename is false and no
1216 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1218 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1219 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1220 * itself, all options starting with "${bdref_key}." are considered part of the
1223 * The BlockdevRef will be removed from the options QDict.
1225 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1227 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1228 QDict
*options
, const char *bdref_key
,
1229 BlockDriverState
* parent
, const BdrvChildRole
*child_role
,
1230 bool allow_none
, Error
**errp
)
1232 QDict
*image_options
;
1234 char *bdref_key_dot
;
1235 const char *reference
;
1238 assert(*pbs
== NULL
);
1240 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1241 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1242 g_free(bdref_key_dot
);
1244 reference
= qdict_get_try_str(options
, bdref_key
);
1245 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1249 error_setg(errp
, "A block device must be specified for \"%s\"",
1253 QDECREF(image_options
);
1257 ret
= bdrv_open_inherit(pbs
, filename
, reference
, image_options
, 0,
1258 parent
, child_role
, NULL
, errp
);
1261 qdict_del(options
, bdref_key
);
1265 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1267 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1268 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1270 QemuOpts
*opts
= NULL
;
1271 QDict
*snapshot_options
;
1272 BlockDriverState
*bs_snapshot
;
1276 /* if snapshot, we create a temporary backing file and open it
1277 instead of opening 'filename' directly */
1279 /* Get the required size from the image */
1280 total_size
= bdrv_getlength(bs
);
1281 if (total_size
< 0) {
1283 error_setg_errno(errp
, -total_size
, "Could not get image size");
1287 /* Create the temporary image */
1288 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1290 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1294 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1296 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1297 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1298 qemu_opts_del(opts
);
1300 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1301 "'%s': %s", tmp_filename
,
1302 error_get_pretty(local_err
));
1303 error_free(local_err
);
1307 /* Prepare a new options QDict for the temporary file */
1308 snapshot_options
= qdict_new();
1309 qdict_put(snapshot_options
, "file.driver",
1310 qstring_from_str("file"));
1311 qdict_put(snapshot_options
, "file.filename",
1312 qstring_from_str(tmp_filename
));
1314 bs_snapshot
= bdrv_new();
1316 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1317 flags
, &bdrv_qcow2
, &local_err
);
1319 error_propagate(errp
, local_err
);
1323 bdrv_append(bs_snapshot
, bs
);
1326 g_free(tmp_filename
);
1330 static void bdrv_attach_child(BlockDriverState
*parent_bs
,
1331 BlockDriverState
*child_bs
,
1332 const BdrvChildRole
*child_role
)
1334 BdrvChild
*child
= g_new(BdrvChild
, 1);
1335 *child
= (BdrvChild
) {
1340 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1344 * Opens a disk image (raw, qcow2, vmdk, ...)
1346 * options is a QDict of options to pass to the block drivers, or NULL for an
1347 * empty set of options. The reference to the QDict belongs to the block layer
1348 * after the call (even on failure), so if the caller intends to reuse the
1349 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1351 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1352 * If it is not NULL, the referenced BDS will be reused.
1354 * The reference parameter may be used to specify an existing block device which
1355 * should be opened. If specified, neither options nor a filename may be given,
1356 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1358 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1359 const char *reference
, QDict
*options
, int flags
,
1360 BlockDriverState
*parent
,
1361 const BdrvChildRole
*child_role
,
1362 BlockDriver
*drv
, Error
**errp
)
1365 BlockDriverState
*file
= NULL
, *bs
;
1366 const char *drvname
;
1367 Error
*local_err
= NULL
;
1368 int snapshot_flags
= 0;
1371 assert(!child_role
|| !flags
);
1372 assert(!child_role
== !parent
);
1375 bool options_non_empty
= options
? qdict_size(options
) : false;
1379 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1380 "another block device");
1384 if (filename
|| options_non_empty
) {
1385 error_setg(errp
, "Cannot reference an existing block device with "
1386 "additional options or a new filename");
1390 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1396 bdrv_attach_child(parent
, bs
, child_role
);
1408 /* NULL means an empty set of options */
1409 if (options
== NULL
) {
1410 options
= qdict_new();
1414 bs
->inherits_from
= parent
;
1415 flags
= child_role
->inherit_flags(parent
->open_flags
);
1418 ret
= bdrv_fill_options(&options
, &filename
, &flags
, drv
, &local_err
);
1423 /* Find the right image format driver */
1425 drvname
= qdict_get_try_str(options
, "driver");
1427 drv
= bdrv_find_format(drvname
);
1428 qdict_del(options
, "driver");
1430 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1436 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1438 bs
->open_flags
= flags
;
1439 bs
->options
= options
;
1440 options
= qdict_clone_shallow(options
);
1442 /* Open image file without format layer */
1443 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1444 if (flags
& BDRV_O_RDWR
) {
1445 flags
|= BDRV_O_ALLOW_RDWR
;
1447 if (flags
& BDRV_O_SNAPSHOT
) {
1448 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1449 flags
= bdrv_backing_flags(flags
);
1452 assert(file
== NULL
);
1453 bs
->open_flags
= flags
;
1454 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1455 bs
, &child_file
, true, &local_err
);
1461 /* Image format probing */
1464 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1469 error_setg(errp
, "Must specify either driver or file");
1474 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1475 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1476 /* file must be NULL if a protocol BDS is about to be created
1477 * (the inverse results in an error message from bdrv_open_common()) */
1478 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1480 /* Open the image */
1481 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1486 if (file
&& (bs
->file
!= file
)) {
1491 /* If there is a backing file, use it */
1492 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1493 QDict
*backing_options
;
1495 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1496 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1498 goto close_and_fail
;
1502 bdrv_refresh_filename(bs
);
1504 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1505 * temporary snapshot afterwards. */
1506 if (snapshot_flags
) {
1507 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1509 goto close_and_fail
;
1513 /* Check if any unknown options were used */
1514 if (options
&& (qdict_size(options
) != 0)) {
1515 const QDictEntry
*entry
= qdict_first(options
);
1516 if (flags
& BDRV_O_PROTOCOL
) {
1517 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1518 "'%s'", drv
->format_name
, entry
->key
);
1520 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1521 "support the option '%s'", drv
->format_name
,
1522 bdrv_get_device_name(bs
), entry
->key
);
1526 goto close_and_fail
;
1529 if (!bdrv_key_required(bs
)) {
1531 blk_dev_change_media_cb(bs
->blk
, true);
1533 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1534 && !runstate_check(RUN_STATE_INMIGRATE
)
1535 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1537 "Guest must be stopped for opening of encrypted image");
1539 goto close_and_fail
;
1543 bdrv_attach_child(parent
, bs
, child_role
);
1554 QDECREF(bs
->options
);
1558 /* If *pbs is NULL, a new BDS has been created in this function and
1559 needs to be freed now. Otherwise, it does not need to be closed,
1560 since it has not really been opened yet. */
1564 error_propagate(errp
, local_err
);
1569 /* See fail path, but now the BDS has to be always closed */
1577 error_propagate(errp
, local_err
);
1582 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1583 const char *reference
, QDict
*options
, int flags
,
1584 BlockDriver
*drv
, Error
**errp
)
1586 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1590 typedef struct BlockReopenQueueEntry
{
1592 BDRVReopenState state
;
1593 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1594 } BlockReopenQueueEntry
;
1597 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1598 * reopen of multiple devices.
1600 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1601 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1602 * be created and initialized. This newly created BlockReopenQueue should be
1603 * passed back in for subsequent calls that are intended to be of the same
1606 * bs is the BlockDriverState to add to the reopen queue.
1608 * flags contains the open flags for the associated bs
1610 * returns a pointer to bs_queue, which is either the newly allocated
1611 * bs_queue, or the existing bs_queue being used.
1614 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1615 BlockDriverState
*bs
, int flags
)
1619 BlockReopenQueueEntry
*bs_entry
;
1622 if (bs_queue
== NULL
) {
1623 bs_queue
= g_new0(BlockReopenQueue
, 1);
1624 QSIMPLEQ_INIT(bs_queue
);
1627 /* bdrv_open() masks this flag out */
1628 flags
&= ~BDRV_O_PROTOCOL
;
1630 QLIST_FOREACH(child
, &bs
->children
, next
) {
1633 if (child
->bs
->inherits_from
!= bs
) {
1637 child_flags
= child
->role
->inherit_flags(flags
);
1638 bdrv_reopen_queue(bs_queue
, child
->bs
, child_flags
);
1641 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1642 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1644 bs_entry
->state
.bs
= bs
;
1645 bs_entry
->state
.flags
= flags
;
1651 * Reopen multiple BlockDriverStates atomically & transactionally.
1653 * The queue passed in (bs_queue) must have been built up previous
1654 * via bdrv_reopen_queue().
1656 * Reopens all BDS specified in the queue, with the appropriate
1657 * flags. All devices are prepared for reopen, and failure of any
1658 * device will cause all device changes to be abandonded, and intermediate
1661 * If all devices prepare successfully, then the changes are committed
1665 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1668 BlockReopenQueueEntry
*bs_entry
, *next
;
1669 Error
*local_err
= NULL
;
1671 assert(bs_queue
!= NULL
);
1675 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1676 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1677 error_propagate(errp
, local_err
);
1680 bs_entry
->prepared
= true;
1683 /* If we reach this point, we have success and just need to apply the
1686 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1687 bdrv_reopen_commit(&bs_entry
->state
);
1693 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1694 if (ret
&& bs_entry
->prepared
) {
1695 bdrv_reopen_abort(&bs_entry
->state
);
1704 /* Reopen a single BlockDriverState with the specified flags. */
1705 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1708 Error
*local_err
= NULL
;
1709 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1711 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1712 if (local_err
!= NULL
) {
1713 error_propagate(errp
, local_err
);
1720 * Prepares a BlockDriverState for reopen. All changes are staged in the
1721 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1722 * the block driver layer .bdrv_reopen_prepare()
1724 * bs is the BlockDriverState to reopen
1725 * flags are the new open flags
1726 * queue is the reopen queue
1728 * Returns 0 on success, non-zero on error. On error errp will be set
1731 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1732 * It is the responsibility of the caller to then call the abort() or
1733 * commit() for any other BDS that have been left in a prepare() state
1736 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1740 Error
*local_err
= NULL
;
1743 assert(reopen_state
!= NULL
);
1744 assert(reopen_state
->bs
->drv
!= NULL
);
1745 drv
= reopen_state
->bs
->drv
;
1747 /* if we are to stay read-only, do not allow permission change
1749 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1750 reopen_state
->flags
& BDRV_O_RDWR
) {
1751 error_setg(errp
, "Node '%s' is read only",
1752 bdrv_get_device_or_node_name(reopen_state
->bs
));
1757 ret
= bdrv_flush(reopen_state
->bs
);
1759 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1764 if (drv
->bdrv_reopen_prepare
) {
1765 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1767 if (local_err
!= NULL
) {
1768 error_propagate(errp
, local_err
);
1770 error_setg(errp
, "failed while preparing to reopen image '%s'",
1771 reopen_state
->bs
->filename
);
1776 /* It is currently mandatory to have a bdrv_reopen_prepare()
1777 * handler for each supported drv. */
1778 error_setg(errp
, "Block format '%s' used by node '%s' "
1779 "does not support reopening files", drv
->format_name
,
1780 bdrv_get_device_or_node_name(reopen_state
->bs
));
1792 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1793 * makes them final by swapping the staging BlockDriverState contents into
1794 * the active BlockDriverState contents.
1796 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1800 assert(reopen_state
!= NULL
);
1801 drv
= reopen_state
->bs
->drv
;
1802 assert(drv
!= NULL
);
1804 /* If there are any driver level actions to take */
1805 if (drv
->bdrv_reopen_commit
) {
1806 drv
->bdrv_reopen_commit(reopen_state
);
1809 /* set BDS specific flags now */
1810 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1811 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1813 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1815 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1819 * Abort the reopen, and delete and free the staged changes in
1822 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1826 assert(reopen_state
!= NULL
);
1827 drv
= reopen_state
->bs
->drv
;
1828 assert(drv
!= NULL
);
1830 if (drv
->bdrv_reopen_abort
) {
1831 drv
->bdrv_reopen_abort(reopen_state
);
1836 void bdrv_close(BlockDriverState
*bs
)
1838 BdrvAioNotifier
*ban
, *ban_next
;
1841 block_job_cancel_sync(bs
->job
);
1843 bdrv_drain_all(); /* complete I/O */
1845 bdrv_drain_all(); /* in case flush left pending I/O */
1846 notifier_list_notify(&bs
->close_notifiers
, bs
);
1849 BdrvChild
*child
, *next
;
1851 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
1852 if (child
->bs
->inherits_from
== bs
) {
1853 child
->bs
->inherits_from
= NULL
;
1855 QLIST_REMOVE(child
, next
);
1859 if (bs
->backing_hd
) {
1860 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1861 bdrv_set_backing_hd(bs
, NULL
);
1862 bdrv_unref(backing_hd
);
1864 bs
->drv
->bdrv_close(bs
);
1868 bs
->copy_on_read
= 0;
1869 bs
->backing_file
[0] = '\0';
1870 bs
->backing_format
[0] = '\0';
1871 bs
->total_sectors
= 0;
1875 bs
->zero_beyond_eof
= false;
1876 QDECREF(bs
->options
);
1878 QDECREF(bs
->full_open_options
);
1879 bs
->full_open_options
= NULL
;
1881 if (bs
->file
!= NULL
) {
1882 bdrv_unref(bs
->file
);
1888 blk_dev_change_media_cb(bs
->blk
, false);
1891 /*throttling disk I/O limits*/
1892 if (bs
->io_limits_enabled
) {
1893 bdrv_io_limits_disable(bs
);
1896 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1899 QLIST_INIT(&bs
->aio_notifiers
);
1902 void bdrv_close_all(void)
1904 BlockDriverState
*bs
;
1906 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1907 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1909 aio_context_acquire(aio_context
);
1911 aio_context_release(aio_context
);
1915 /* make a BlockDriverState anonymous by removing from bdrv_state and
1916 * graph_bdrv_state list.
1917 Also, NULL terminate the device_name to prevent double remove */
1918 void bdrv_make_anon(BlockDriverState
*bs
)
1921 * Take care to remove bs from bdrv_states only when it's actually
1922 * in it. Note that bs->device_list.tqe_prev is initially null,
1923 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1924 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1925 * resetting it to null on remove.
1927 if (bs
->device_list
.tqe_prev
) {
1928 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1929 bs
->device_list
.tqe_prev
= NULL
;
1931 if (bs
->node_name
[0] != '\0') {
1932 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1934 bs
->node_name
[0] = '\0';
1937 static void bdrv_rebind(BlockDriverState
*bs
)
1939 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1940 bs
->drv
->bdrv_rebind(bs
);
1944 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1945 BlockDriverState
*bs_src
)
1947 /* move some fields that need to stay attached to the device */
1950 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1951 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1953 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1955 /* i/o throttled req */
1956 bs_dest
->throttle_state
= bs_src
->throttle_state
,
1957 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1958 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
1959 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
1960 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1961 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1962 memcpy(&bs_dest
->round_robin
,
1963 &bs_src
->round_robin
,
1964 sizeof(bs_dest
->round_robin
));
1965 memcpy(&bs_dest
->throttle_timers
,
1966 &bs_src
->throttle_timers
,
1967 sizeof(ThrottleTimers
));
1970 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1971 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1974 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1975 bs_dest
->iostatus
= bs_src
->iostatus
;
1978 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1980 /* reference count */
1981 bs_dest
->refcnt
= bs_src
->refcnt
;
1984 bs_dest
->job
= bs_src
->job
;
1986 /* keep the same entry in bdrv_states */
1987 bs_dest
->device_list
= bs_src
->device_list
;
1988 bs_dest
->blk
= bs_src
->blk
;
1990 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1991 sizeof(bs_dest
->op_blockers
));
1995 * Swap bs contents for two image chains while they are live,
1996 * while keeping required fields on the BlockDriverState that is
1997 * actually attached to a device.
1999 * This will modify the BlockDriverState fields, and swap contents
2000 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2002 * bs_new must not be attached to a BlockBackend.
2004 * This function does not create any image files.
2006 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2008 BlockDriverState tmp
;
2014 /* The code needs to swap the node_name but simply swapping node_list won't
2015 * work so first remove the nodes from the graph list, do the swap then
2016 * insert them back if needed.
2018 if (bs_new
->node_name
[0] != '\0') {
2019 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2021 if (bs_old
->node_name
[0] != '\0') {
2022 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2025 /* If the BlockDriverState is part of a throttling group acquire
2026 * its lock since we're going to mess with the protected fields.
2027 * Otherwise there's no need to worry since no one else can touch
2029 if (bs_old
->throttle_state
) {
2030 throttle_group_lock(bs_old
);
2033 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2034 assert(!bs_new
->blk
);
2035 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2036 assert(bs_new
->job
== NULL
);
2037 assert(bs_new
->io_limits_enabled
== false);
2038 assert(bs_new
->throttle_state
== NULL
);
2039 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2045 /* there are some fields that should not be swapped, move them back */
2046 bdrv_move_feature_fields(&tmp
, bs_old
);
2047 bdrv_move_feature_fields(bs_old
, bs_new
);
2048 bdrv_move_feature_fields(bs_new
, &tmp
);
2050 /* bs_new must remain unattached */
2051 assert(!bs_new
->blk
);
2053 /* Check a few fields that should remain attached to the device */
2054 assert(bs_new
->job
== NULL
);
2055 assert(bs_new
->io_limits_enabled
== false);
2056 assert(bs_new
->throttle_state
== NULL
);
2057 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
2059 /* Release the ThrottleGroup lock */
2060 if (bs_old
->throttle_state
) {
2061 throttle_group_unlock(bs_old
);
2064 /* insert the nodes back into the graph node list if needed */
2065 if (bs_new
->node_name
[0] != '\0') {
2066 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2068 if (bs_old
->node_name
[0] != '\0') {
2069 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2073 * Update lh_first.le_prev for non-empty lists.
2075 * The head of the op blocker list doesn't change because it is moved back
2076 * in bdrv_move_feature_fields().
2078 assert(QLIST_EMPTY(&bs_old
->tracked_requests
));
2079 assert(QLIST_EMPTY(&bs_new
->tracked_requests
));
2081 QLIST_FIX_HEAD_PTR(&bs_new
->children
, next
);
2082 QLIST_FIX_HEAD_PTR(&bs_old
->children
, next
);
2084 /* Update references in bs->opaque and children */
2085 QLIST_FOREACH(child
, &bs_old
->children
, next
) {
2086 if (child
->bs
->inherits_from
== bs_new
) {
2087 child
->bs
->inherits_from
= bs_old
;
2090 QLIST_FOREACH(child
, &bs_new
->children
, next
) {
2091 if (child
->bs
->inherits_from
== bs_old
) {
2092 child
->bs
->inherits_from
= bs_new
;
2096 bdrv_rebind(bs_new
);
2097 bdrv_rebind(bs_old
);
2101 * Add new bs contents at the top of an image chain while the chain is
2102 * live, while keeping required fields on the top layer.
2104 * This will modify the BlockDriverState fields, and swap contents
2105 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2107 * bs_new must not be attached to a BlockBackend.
2109 * This function does not create any image files.
2111 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2113 bdrv_swap(bs_new
, bs_top
);
2115 /* The contents of 'tmp' will become bs_top, as we are
2116 * swapping bs_new and bs_top contents. */
2117 bdrv_set_backing_hd(bs_top
, bs_new
);
2118 bdrv_attach_child(bs_top
, bs_new
, &child_backing
);
2121 static void bdrv_delete(BlockDriverState
*bs
)
2124 assert(bdrv_op_blocker_is_empty(bs
));
2125 assert(!bs
->refcnt
);
2126 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2130 /* remove from list, if necessary */
2137 * Run consistency checks on an image
2139 * Returns 0 if the check could be completed (it doesn't mean that the image is
2140 * free of errors) or -errno when an internal error occurred. The results of the
2141 * check are stored in res.
2143 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2145 if (bs
->drv
== NULL
) {
2148 if (bs
->drv
->bdrv_check
== NULL
) {
2152 memset(res
, 0, sizeof(*res
));
2153 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2156 #define COMMIT_BUF_SECTORS 2048
2158 /* commit COW file into the raw image */
2159 int bdrv_commit(BlockDriverState
*bs
)
2161 BlockDriver
*drv
= bs
->drv
;
2162 int64_t sector
, total_sectors
, length
, backing_length
;
2163 int n
, ro
, open_flags
;
2165 uint8_t *buf
= NULL
;
2170 if (!bs
->backing_hd
) {
2174 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2175 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2179 ro
= bs
->backing_hd
->read_only
;
2180 open_flags
= bs
->backing_hd
->open_flags
;
2183 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2188 length
= bdrv_getlength(bs
);
2194 backing_length
= bdrv_getlength(bs
->backing_hd
);
2195 if (backing_length
< 0) {
2196 ret
= backing_length
;
2200 /* If our top snapshot is larger than the backing file image,
2201 * grow the backing file image if possible. If not possible,
2202 * we must return an error */
2203 if (length
> backing_length
) {
2204 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2210 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2212 /* qemu_try_blockalign() for bs will choose an alignment that works for
2213 * bs->backing_hd as well, so no need to compare the alignment manually. */
2214 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2220 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2221 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2226 ret
= bdrv_read(bs
, sector
, buf
, n
);
2231 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2238 if (drv
->bdrv_make_empty
) {
2239 ret
= drv
->bdrv_make_empty(bs
);
2247 * Make sure all data we wrote to the backing device is actually
2250 if (bs
->backing_hd
) {
2251 bdrv_flush(bs
->backing_hd
);
2259 /* ignoring error return here */
2260 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2266 int bdrv_commit_all(void)
2268 BlockDriverState
*bs
;
2270 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2271 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2273 aio_context_acquire(aio_context
);
2274 if (bs
->drv
&& bs
->backing_hd
) {
2275 int ret
= bdrv_commit(bs
);
2277 aio_context_release(aio_context
);
2281 aio_context_release(aio_context
);
2289 * -EINVAL - backing format specified, but no file
2290 * -ENOSPC - can't update the backing file because no space is left in the
2292 * -ENOTSUP - format driver doesn't support changing the backing file
2294 int bdrv_change_backing_file(BlockDriverState
*bs
,
2295 const char *backing_file
, const char *backing_fmt
)
2297 BlockDriver
*drv
= bs
->drv
;
2300 /* Backing file format doesn't make sense without a backing file */
2301 if (backing_fmt
&& !backing_file
) {
2305 if (drv
->bdrv_change_backing_file
!= NULL
) {
2306 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2312 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2313 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2319 * Finds the image layer in the chain that has 'bs' as its backing file.
2321 * active is the current topmost image.
2323 * Returns NULL if bs is not found in active's image chain,
2324 * or if active == bs.
2326 * Returns the bottommost base image if bs == NULL.
2328 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2329 BlockDriverState
*bs
)
2331 while (active
&& bs
!= active
->backing_hd
) {
2332 active
= active
->backing_hd
;
2338 /* Given a BDS, searches for the base layer. */
2339 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2341 return bdrv_find_overlay(bs
, NULL
);
2344 typedef struct BlkIntermediateStates
{
2345 BlockDriverState
*bs
;
2346 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2347 } BlkIntermediateStates
;
2351 * Drops images above 'base' up to and including 'top', and sets the image
2352 * above 'top' to have base as its backing file.
2354 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2355 * information in 'bs' can be properly updated.
2357 * E.g., this will convert the following chain:
2358 * bottom <- base <- intermediate <- top <- active
2362 * bottom <- base <- active
2364 * It is allowed for bottom==base, in which case it converts:
2366 * base <- intermediate <- top <- active
2372 * If backing_file_str is non-NULL, it will be used when modifying top's
2373 * overlay image metadata.
2376 * if active == top, that is considered an error
2379 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2380 BlockDriverState
*base
, const char *backing_file_str
)
2382 BlockDriverState
*intermediate
;
2383 BlockDriverState
*base_bs
= NULL
;
2384 BlockDriverState
*new_top_bs
= NULL
;
2385 BlkIntermediateStates
*intermediate_state
, *next
;
2388 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2389 QSIMPLEQ_INIT(&states_to_delete
);
2391 if (!top
->drv
|| !base
->drv
) {
2395 new_top_bs
= bdrv_find_overlay(active
, top
);
2397 if (new_top_bs
== NULL
) {
2398 /* we could not find the image above 'top', this is an error */
2402 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2403 * to do, no intermediate images */
2404 if (new_top_bs
->backing_hd
== base
) {
2411 /* now we will go down through the list, and add each BDS we find
2412 * into our deletion queue, until we hit the 'base'
2414 while (intermediate
) {
2415 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2416 intermediate_state
->bs
= intermediate
;
2417 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2419 if (intermediate
->backing_hd
== base
) {
2420 base_bs
= intermediate
->backing_hd
;
2423 intermediate
= intermediate
->backing_hd
;
2425 if (base_bs
== NULL
) {
2426 /* something went wrong, we did not end at the base. safely
2427 * unravel everything, and exit with error */
2431 /* success - we can delete the intermediate states, and link top->base */
2432 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2433 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2434 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2438 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2440 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2441 /* so that bdrv_close() does not recursively close the chain */
2442 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2443 bdrv_unref(intermediate_state
->bs
);
2448 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2449 g_free(intermediate_state
);
2455 * Truncate file to 'offset' bytes (needed only for file protocols)
2457 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2459 BlockDriver
*drv
= bs
->drv
;
2463 if (!drv
->bdrv_truncate
)
2468 ret
= drv
->bdrv_truncate(bs
, offset
);
2470 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2471 bdrv_dirty_bitmap_truncate(bs
);
2473 blk_dev_resize_cb(bs
->blk
);
2480 * Length of a allocated file in bytes. Sparse files are counted by actual
2481 * allocated space. Return < 0 if error or unknown.
2483 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2485 BlockDriver
*drv
= bs
->drv
;
2489 if (drv
->bdrv_get_allocated_file_size
) {
2490 return drv
->bdrv_get_allocated_file_size(bs
);
2493 return bdrv_get_allocated_file_size(bs
->file
);
2499 * Return number of sectors on success, -errno on error.
2501 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2503 BlockDriver
*drv
= bs
->drv
;
2508 if (drv
->has_variable_length
) {
2509 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2514 return bs
->total_sectors
;
2518 * Return length in bytes on success, -errno on error.
2519 * The length is always a multiple of BDRV_SECTOR_SIZE.
2521 int64_t bdrv_getlength(BlockDriverState
*bs
)
2523 int64_t ret
= bdrv_nb_sectors(bs
);
2525 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2526 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2529 /* return 0 as number of sectors if no device present or error */
2530 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2532 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2534 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2537 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2538 BlockdevOnError on_write_error
)
2540 bs
->on_read_error
= on_read_error
;
2541 bs
->on_write_error
= on_write_error
;
2544 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2546 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2549 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2551 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2554 case BLOCKDEV_ON_ERROR_ENOSPC
:
2555 return (error
== ENOSPC
) ?
2556 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2557 case BLOCKDEV_ON_ERROR_STOP
:
2558 return BLOCK_ERROR_ACTION_STOP
;
2559 case BLOCKDEV_ON_ERROR_REPORT
:
2560 return BLOCK_ERROR_ACTION_REPORT
;
2561 case BLOCKDEV_ON_ERROR_IGNORE
:
2562 return BLOCK_ERROR_ACTION_IGNORE
;
2568 static void send_qmp_error_event(BlockDriverState
*bs
,
2569 BlockErrorAction action
,
2570 bool is_read
, int error
)
2572 IoOperationType optype
;
2574 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2575 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2576 bdrv_iostatus_is_enabled(bs
),
2577 error
== ENOSPC
, strerror(error
),
2581 /* This is done by device models because, while the block layer knows
2582 * about the error, it does not know whether an operation comes from
2583 * the device or the block layer (from a job, for example).
2585 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2586 bool is_read
, int error
)
2590 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2591 /* First set the iostatus, so that "info block" returns an iostatus
2592 * that matches the events raised so far (an additional error iostatus
2593 * is fine, but not a lost one).
2595 bdrv_iostatus_set_err(bs
, error
);
2597 /* Then raise the request to stop the VM and the event.
2598 * qemu_system_vmstop_request_prepare has two effects. First,
2599 * it ensures that the STOP event always comes after the
2600 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2601 * can observe the STOP event and do a "cont" before the STOP
2602 * event is issued, the VM will not stop. In this case, vm_start()
2603 * also ensures that the STOP/RESUME pair of events is emitted.
2605 qemu_system_vmstop_request_prepare();
2606 send_qmp_error_event(bs
, action
, is_read
, error
);
2607 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2609 send_qmp_error_event(bs
, action
, is_read
, error
);
2613 int bdrv_is_read_only(BlockDriverState
*bs
)
2615 return bs
->read_only
;
2618 int bdrv_is_sg(BlockDriverState
*bs
)
2623 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2625 return bs
->enable_write_cache
;
2628 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2630 bs
->enable_write_cache
= wce
;
2632 /* so a reopen() will preserve wce */
2634 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2636 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2640 int bdrv_is_encrypted(BlockDriverState
*bs
)
2642 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2644 return bs
->encrypted
;
2647 int bdrv_key_required(BlockDriverState
*bs
)
2649 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2651 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2653 return (bs
->encrypted
&& !bs
->valid_key
);
2656 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2659 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2660 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2666 if (!bs
->encrypted
) {
2668 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2671 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2674 } else if (!bs
->valid_key
) {
2677 /* call the change callback now, we skipped it on open */
2678 blk_dev_change_media_cb(bs
->blk
, true);
2685 * Provide an encryption key for @bs.
2686 * If @key is non-null:
2687 * If @bs is not encrypted, fail.
2688 * Else if the key is invalid, fail.
2689 * Else set @bs's key to @key, replacing the existing key, if any.
2691 * If @bs is encrypted and still lacks a key, fail.
2693 * On failure, store an error object through @errp if non-null.
2695 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2698 if (!bdrv_is_encrypted(bs
)) {
2699 error_setg(errp
, "Node '%s' is not encrypted",
2700 bdrv_get_device_or_node_name(bs
));
2701 } else if (bdrv_set_key(bs
, key
) < 0) {
2702 error_setg(errp
, QERR_INVALID_PASSWORD
);
2705 if (bdrv_key_required(bs
)) {
2706 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2707 "'%s' (%s) is encrypted",
2708 bdrv_get_device_or_node_name(bs
),
2709 bdrv_get_encrypted_filename(bs
));
2714 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2716 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2719 static int qsort_strcmp(const void *a
, const void *b
)
2721 return strcmp(a
, b
);
2724 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2730 const char **formats
= NULL
;
2732 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2733 if (drv
->format_name
) {
2736 while (formats
&& i
&& !found
) {
2737 found
= !strcmp(formats
[--i
], drv
->format_name
);
2741 formats
= g_renew(const char *, formats
, count
+ 1);
2742 formats
[count
++] = drv
->format_name
;
2747 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2749 for (i
= 0; i
< count
; i
++) {
2750 it(opaque
, formats
[i
]);
2756 /* This function is to find a node in the bs graph */
2757 BlockDriverState
*bdrv_find_node(const char *node_name
)
2759 BlockDriverState
*bs
;
2763 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2764 if (!strcmp(node_name
, bs
->node_name
)) {
2771 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2772 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2774 BlockDeviceInfoList
*list
, *entry
;
2775 BlockDriverState
*bs
;
2778 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2779 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2781 qapi_free_BlockDeviceInfoList(list
);
2784 entry
= g_malloc0(sizeof(*entry
));
2785 entry
->value
= info
;
2793 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2794 const char *node_name
,
2798 BlockDriverState
*bs
;
2801 blk
= blk_by_name(device
);
2809 bs
= bdrv_find_node(node_name
);
2816 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2817 device
? device
: "",
2818 node_name
? node_name
: "");
2822 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2823 * return false. If either argument is NULL, return false. */
2824 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2826 while (top
&& top
!= base
) {
2827 top
= top
->backing_hd
;
2833 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2836 return QTAILQ_FIRST(&graph_bdrv_states
);
2838 return QTAILQ_NEXT(bs
, node_list
);
2841 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2844 return QTAILQ_FIRST(&bdrv_states
);
2846 return QTAILQ_NEXT(bs
, device_list
);
2849 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2851 return bs
->node_name
;
2854 /* TODO check what callers really want: bs->node_name or blk_name() */
2855 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2857 return bs
->blk
? blk_name(bs
->blk
) : "";
2860 /* This can be used to identify nodes that might not have a device
2861 * name associated. Since node and device names live in the same
2862 * namespace, the result is unambiguous. The exception is if both are
2863 * absent, then this returns an empty (non-null) string. */
2864 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2866 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2869 int bdrv_get_flags(BlockDriverState
*bs
)
2871 return bs
->open_flags
;
2874 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2879 int bdrv_has_zero_init(BlockDriverState
*bs
)
2883 /* If BS is a copy on write image, it is initialized to
2884 the contents of the base image, which may not be zeroes. */
2885 if (bs
->backing_hd
) {
2888 if (bs
->drv
->bdrv_has_zero_init
) {
2889 return bs
->drv
->bdrv_has_zero_init(bs
);
2896 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2898 BlockDriverInfo bdi
;
2900 if (bs
->backing_hd
) {
2904 if (bdrv_get_info(bs
, &bdi
) == 0) {
2905 return bdi
.unallocated_blocks_are_zero
;
2911 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2913 BlockDriverInfo bdi
;
2915 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2919 if (bdrv_get_info(bs
, &bdi
) == 0) {
2920 return bdi
.can_write_zeroes_with_unmap
;
2926 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2928 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2929 return bs
->backing_file
;
2930 else if (bs
->encrypted
)
2931 return bs
->filename
;
2936 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2937 char *filename
, int filename_size
)
2939 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2942 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2944 BlockDriver
*drv
= bs
->drv
;
2947 if (!drv
->bdrv_get_info
)
2949 memset(bdi
, 0, sizeof(*bdi
));
2950 return drv
->bdrv_get_info(bs
, bdi
);
2953 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2955 BlockDriver
*drv
= bs
->drv
;
2956 if (drv
&& drv
->bdrv_get_specific_info
) {
2957 return drv
->bdrv_get_specific_info(bs
);
2962 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2964 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
2968 bs
->drv
->bdrv_debug_event(bs
, event
);
2971 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
2974 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
2978 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
2979 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
2985 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
2987 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
2991 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
2992 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
2998 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3000 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3004 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3005 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3011 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3013 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3017 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3018 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3024 int bdrv_is_snapshot(BlockDriverState
*bs
)
3026 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3029 /* backing_file can either be relative, or absolute, or a protocol. If it is
3030 * relative, it must be relative to the chain. So, passing in bs->filename
3031 * from a BDS as backing_file should not be done, as that may be relative to
3032 * the CWD rather than the chain. */
3033 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3034 const char *backing_file
)
3036 char *filename_full
= NULL
;
3037 char *backing_file_full
= NULL
;
3038 char *filename_tmp
= NULL
;
3039 int is_protocol
= 0;
3040 BlockDriverState
*curr_bs
= NULL
;
3041 BlockDriverState
*retval
= NULL
;
3043 if (!bs
|| !bs
->drv
|| !backing_file
) {
3047 filename_full
= g_malloc(PATH_MAX
);
3048 backing_file_full
= g_malloc(PATH_MAX
);
3049 filename_tmp
= g_malloc(PATH_MAX
);
3051 is_protocol
= path_has_protocol(backing_file
);
3053 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3055 /* If either of the filename paths is actually a protocol, then
3056 * compare unmodified paths; otherwise make paths relative */
3057 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3058 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3059 retval
= curr_bs
->backing_hd
;
3063 /* If not an absolute filename path, make it relative to the current
3064 * image's filename path */
3065 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3068 /* We are going to compare absolute pathnames */
3069 if (!realpath(filename_tmp
, filename_full
)) {
3073 /* We need to make sure the backing filename we are comparing against
3074 * is relative to the current image filename (or absolute) */
3075 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3076 curr_bs
->backing_file
);
3078 if (!realpath(filename_tmp
, backing_file_full
)) {
3082 if (strcmp(backing_file_full
, filename_full
) == 0) {
3083 retval
= curr_bs
->backing_hd
;
3089 g_free(filename_full
);
3090 g_free(backing_file_full
);
3091 g_free(filename_tmp
);
3095 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3101 if (!bs
->backing_hd
) {
3105 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3108 void bdrv_init(void)
3110 module_call_init(MODULE_INIT_BLOCK
);
3113 void bdrv_init_with_whitelist(void)
3115 use_bdrv_whitelist
= 1;
3119 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3121 Error
*local_err
= NULL
;
3128 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3131 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3133 if (bs
->drv
->bdrv_invalidate_cache
) {
3134 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3135 } else if (bs
->file
) {
3136 bdrv_invalidate_cache(bs
->file
, &local_err
);
3139 error_propagate(errp
, local_err
);
3143 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3145 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3150 void bdrv_invalidate_cache_all(Error
**errp
)
3152 BlockDriverState
*bs
;
3153 Error
*local_err
= NULL
;
3155 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3156 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3158 aio_context_acquire(aio_context
);
3159 bdrv_invalidate_cache(bs
, &local_err
);
3160 aio_context_release(aio_context
);
3162 error_propagate(errp
, local_err
);
3168 /**************************************************************/
3169 /* removable device support */
3172 * Return TRUE if the media is present
3174 int bdrv_is_inserted(BlockDriverState
*bs
)
3176 BlockDriver
*drv
= bs
->drv
;
3180 if (!drv
->bdrv_is_inserted
)
3182 return drv
->bdrv_is_inserted(bs
);
3186 * Return whether the media changed since the last call to this
3187 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3189 int bdrv_media_changed(BlockDriverState
*bs
)
3191 BlockDriver
*drv
= bs
->drv
;
3193 if (drv
&& drv
->bdrv_media_changed
) {
3194 return drv
->bdrv_media_changed(bs
);
3200 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3202 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3204 BlockDriver
*drv
= bs
->drv
;
3205 const char *device_name
;
3207 if (drv
&& drv
->bdrv_eject
) {
3208 drv
->bdrv_eject(bs
, eject_flag
);
3211 device_name
= bdrv_get_device_name(bs
);
3212 if (device_name
[0] != '\0') {
3213 qapi_event_send_device_tray_moved(device_name
,
3214 eject_flag
, &error_abort
);
3219 * Lock or unlock the media (if it is locked, the user won't be able
3220 * to eject it manually).
3222 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3224 BlockDriver
*drv
= bs
->drv
;
3226 trace_bdrv_lock_medium(bs
, locked
);
3228 if (drv
&& drv
->bdrv_lock_medium
) {
3229 drv
->bdrv_lock_medium(bs
, locked
);
3233 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3235 bs
->guest_block_size
= align
;
3238 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3240 BdrvDirtyBitmap
*bm
;
3243 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3244 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3251 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3253 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3254 g_free(bitmap
->name
);
3255 bitmap
->name
= NULL
;
3258 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3259 uint32_t granularity
,
3263 int64_t bitmap_size
;
3264 BdrvDirtyBitmap
*bitmap
;
3265 uint32_t sector_granularity
;
3267 assert((granularity
& (granularity
- 1)) == 0);
3269 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3270 error_setg(errp
, "Bitmap already exists: %s", name
);
3273 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3274 assert(sector_granularity
);
3275 bitmap_size
= bdrv_nb_sectors(bs
);
3276 if (bitmap_size
< 0) {
3277 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3278 errno
= -bitmap_size
;
3281 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3282 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3283 bitmap
->size
= bitmap_size
;
3284 bitmap
->name
= g_strdup(name
);
3285 bitmap
->disabled
= false;
3286 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3290 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3292 return bitmap
->successor
;
3295 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3297 return !(bitmap
->disabled
|| bitmap
->successor
);
3300 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3302 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3303 return DIRTY_BITMAP_STATUS_FROZEN
;
3304 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3305 return DIRTY_BITMAP_STATUS_DISABLED
;
3307 return DIRTY_BITMAP_STATUS_ACTIVE
;
3312 * Create a successor bitmap destined to replace this bitmap after an operation.
3313 * Requires that the bitmap is not frozen and has no successor.
3315 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3316 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3318 uint64_t granularity
;
3319 BdrvDirtyBitmap
*child
;
3321 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3322 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3323 "currently frozen");
3326 assert(!bitmap
->successor
);
3328 /* Create an anonymous successor */
3329 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3330 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3335 /* Successor will be on or off based on our current state. */
3336 child
->disabled
= bitmap
->disabled
;
3338 /* Install the successor and freeze the parent */
3339 bitmap
->successor
= child
;
3344 * For a bitmap with a successor, yield our name to the successor,
3345 * delete the old bitmap, and return a handle to the new bitmap.
3347 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3348 BdrvDirtyBitmap
*bitmap
,
3352 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3354 if (successor
== NULL
) {
3355 error_setg(errp
, "Cannot relinquish control if "
3356 "there's no successor present");
3360 name
= bitmap
->name
;
3361 bitmap
->name
= NULL
;
3362 successor
->name
= name
;
3363 bitmap
->successor
= NULL
;
3364 bdrv_release_dirty_bitmap(bs
, bitmap
);
3370 * In cases of failure where we can no longer safely delete the parent,
3371 * we may wish to re-join the parent and child/successor.
3372 * The merged parent will be un-frozen, but not explicitly re-enabled.
3374 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3375 BdrvDirtyBitmap
*parent
,
3378 BdrvDirtyBitmap
*successor
= parent
->successor
;
3381 error_setg(errp
, "Cannot reclaim a successor when none is present");
3385 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3386 error_setg(errp
, "Merging of parent and successor bitmap failed");
3389 bdrv_release_dirty_bitmap(bs
, successor
);
3390 parent
->successor
= NULL
;
3396 * Truncates _all_ bitmaps attached to a BDS.
3398 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3400 BdrvDirtyBitmap
*bitmap
;
3401 uint64_t size
= bdrv_nb_sectors(bs
);
3403 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3404 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3405 hbitmap_truncate(bitmap
->bitmap
, size
);
3406 bitmap
->size
= size
;
3410 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3412 BdrvDirtyBitmap
*bm
, *next
;
3413 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3415 assert(!bdrv_dirty_bitmap_frozen(bm
));
3416 QLIST_REMOVE(bitmap
, list
);
3417 hbitmap_free(bitmap
->bitmap
);
3418 g_free(bitmap
->name
);
3425 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3427 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3428 bitmap
->disabled
= true;
3431 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3433 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3434 bitmap
->disabled
= false;
3437 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3439 BdrvDirtyBitmap
*bm
;
3440 BlockDirtyInfoList
*list
= NULL
;
3441 BlockDirtyInfoList
**plist
= &list
;
3443 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3444 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3445 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3446 info
->count
= bdrv_get_dirty_count(bm
);
3447 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3448 info
->has_name
= !!bm
->name
;
3449 info
->name
= g_strdup(bm
->name
);
3450 info
->status
= bdrv_dirty_bitmap_status(bm
);
3451 entry
->value
= info
;
3453 plist
= &entry
->next
;
3459 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3462 return hbitmap_get(bitmap
->bitmap
, sector
);
3469 * Chooses a default granularity based on the existing cluster size,
3470 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3471 * is no cluster size information available.
3473 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3475 BlockDriverInfo bdi
;
3476 uint32_t granularity
;
3478 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3479 granularity
= MAX(4096, bdi
.cluster_size
);
3480 granularity
= MIN(65536, granularity
);
3482 granularity
= 65536;
3488 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3490 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3493 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3495 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3498 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3499 int64_t cur_sector
, int nr_sectors
)
3501 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3502 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3505 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3506 int64_t cur_sector
, int nr_sectors
)
3508 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3509 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3512 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3514 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3515 hbitmap_reset(bitmap
->bitmap
, 0, bitmap
->size
);
3518 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3521 BdrvDirtyBitmap
*bitmap
;
3522 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3523 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3526 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3530 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3533 BdrvDirtyBitmap
*bitmap
;
3534 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3535 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3538 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3543 * Advance an HBitmapIter to an arbitrary offset.
3545 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3548 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3551 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3553 return hbitmap_count(bitmap
->bitmap
);
3556 /* Get a reference to bs */
3557 void bdrv_ref(BlockDriverState
*bs
)
3562 /* Release a previously grabbed reference to bs.
3563 * If after releasing, reference count is zero, the BlockDriverState is
3565 void bdrv_unref(BlockDriverState
*bs
)
3570 assert(bs
->refcnt
> 0);
3571 if (--bs
->refcnt
== 0) {
3576 struct BdrvOpBlocker
{
3578 QLIST_ENTRY(BdrvOpBlocker
) list
;
3581 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3583 BdrvOpBlocker
*blocker
;
3584 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3585 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3586 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3588 error_setg(errp
, "Node '%s' is busy: %s",
3589 bdrv_get_device_or_node_name(bs
),
3590 error_get_pretty(blocker
->reason
));
3597 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3599 BdrvOpBlocker
*blocker
;
3600 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3602 blocker
= g_new0(BdrvOpBlocker
, 1);
3603 blocker
->reason
= reason
;
3604 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3607 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3609 BdrvOpBlocker
*blocker
, *next
;
3610 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3611 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3612 if (blocker
->reason
== reason
) {
3613 QLIST_REMOVE(blocker
, list
);
3619 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3622 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3623 bdrv_op_block(bs
, i
, reason
);
3627 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3630 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3631 bdrv_op_unblock(bs
, i
, reason
);
3635 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3639 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3640 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3647 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3649 bs
->iostatus_enabled
= true;
3650 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3653 /* The I/O status is only enabled if the drive explicitly
3654 * enables it _and_ the VM is configured to stop on errors */
3655 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3657 return (bs
->iostatus_enabled
&&
3658 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3659 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3660 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3663 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3665 bs
->iostatus_enabled
= false;
3668 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3670 if (bdrv_iostatus_is_enabled(bs
)) {
3671 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3673 block_job_iostatus_reset(bs
->job
);
3678 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3680 assert(bdrv_iostatus_is_enabled(bs
));
3681 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3682 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3683 BLOCK_DEVICE_IO_STATUS_FAILED
;
3687 void bdrv_img_create(const char *filename
, const char *fmt
,
3688 const char *base_filename
, const char *base_fmt
,
3689 char *options
, uint64_t img_size
, int flags
,
3690 Error
**errp
, bool quiet
)
3692 QemuOptsList
*create_opts
= NULL
;
3693 QemuOpts
*opts
= NULL
;
3694 const char *backing_fmt
, *backing_file
;
3696 BlockDriver
*drv
, *proto_drv
;
3697 BlockDriver
*backing_drv
= NULL
;
3698 Error
*local_err
= NULL
;
3701 /* Find driver and parse its options */
3702 drv
= bdrv_find_format(fmt
);
3704 error_setg(errp
, "Unknown file format '%s'", fmt
);
3708 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3713 if (!drv
->create_opts
) {
3714 error_setg(errp
, "Format driver '%s' does not support image creation",
3719 if (!proto_drv
->create_opts
) {
3720 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3721 proto_drv
->format_name
);
3725 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3726 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3728 /* Create parameter list with default values */
3729 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3730 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3732 /* Parse -o options */
3734 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3736 error_report_err(local_err
);
3738 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3743 if (base_filename
) {
3744 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3746 error_setg(errp
, "Backing file not supported for file format '%s'",
3753 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3755 error_setg(errp
, "Backing file format not supported for file "
3756 "format '%s'", fmt
);
3761 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3763 if (!strcmp(filename
, backing_file
)) {
3764 error_setg(errp
, "Error: Trying to create an image with the "
3765 "same filename as the backing file");
3770 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3772 backing_drv
= bdrv_find_format(backing_fmt
);
3774 error_setg(errp
, "Unknown backing file format '%s'",
3780 // The size for the image must always be specified, with one exception:
3781 // If we are using a backing file, we can obtain the size from there
3782 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3785 BlockDriverState
*bs
;
3786 char *full_backing
= g_new0(char, PATH_MAX
);
3790 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3791 full_backing
, PATH_MAX
,
3794 g_free(full_backing
);
3798 /* backing files always opened read-only */
3800 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3803 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
3804 backing_drv
, &local_err
);
3805 g_free(full_backing
);
3809 size
= bdrv_getlength(bs
);
3811 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3817 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3821 error_setg(errp
, "Image creation needs a size parameter");
3827 printf("Formatting '%s', fmt=%s", filename
, fmt
);
3828 qemu_opts_print(opts
, " ");
3832 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3834 if (ret
== -EFBIG
) {
3835 /* This is generally a better message than whatever the driver would
3836 * deliver (especially because of the cluster_size_hint), since that
3837 * is most probably not much different from "image too large". */
3838 const char *cluster_size_hint
= "";
3839 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3840 cluster_size_hint
= " (try using a larger cluster size)";
3842 error_setg(errp
, "The image size is too large for file format '%s'"
3843 "%s", fmt
, cluster_size_hint
);
3844 error_free(local_err
);
3849 qemu_opts_del(opts
);
3850 qemu_opts_free(create_opts
);
3852 error_propagate(errp
, local_err
);
3856 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3858 return bs
->aio_context
;
3861 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3863 BdrvAioNotifier
*baf
;
3869 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3870 baf
->detach_aio_context(baf
->opaque
);
3873 if (bs
->io_limits_enabled
) {
3874 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3876 if (bs
->drv
->bdrv_detach_aio_context
) {
3877 bs
->drv
->bdrv_detach_aio_context(bs
);
3880 bdrv_detach_aio_context(bs
->file
);
3882 if (bs
->backing_hd
) {
3883 bdrv_detach_aio_context(bs
->backing_hd
);
3886 bs
->aio_context
= NULL
;
3889 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3890 AioContext
*new_context
)
3892 BdrvAioNotifier
*ban
;
3898 bs
->aio_context
= new_context
;
3900 if (bs
->backing_hd
) {
3901 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3904 bdrv_attach_aio_context(bs
->file
, new_context
);
3906 if (bs
->drv
->bdrv_attach_aio_context
) {
3907 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3909 if (bs
->io_limits_enabled
) {
3910 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3913 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3914 ban
->attached_aio_context(new_context
, ban
->opaque
);
3918 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3920 bdrv_drain_all(); /* ensure there are no in-flight requests */
3922 bdrv_detach_aio_context(bs
);
3924 /* This function executes in the old AioContext so acquire the new one in
3925 * case it runs in a different thread.
3927 aio_context_acquire(new_context
);
3928 bdrv_attach_aio_context(bs
, new_context
);
3929 aio_context_release(new_context
);
3932 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3933 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3934 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3936 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3937 *ban
= (BdrvAioNotifier
){
3938 .attached_aio_context
= attached_aio_context
,
3939 .detach_aio_context
= detach_aio_context
,
3943 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3946 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3947 void (*attached_aio_context
)(AioContext
*,
3949 void (*detach_aio_context
)(void *),
3952 BdrvAioNotifier
*ban
, *ban_next
;
3954 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3955 if (ban
->attached_aio_context
== attached_aio_context
&&
3956 ban
->detach_aio_context
== detach_aio_context
&&
3957 ban
->opaque
== opaque
)
3959 QLIST_REMOVE(ban
, list
);
3969 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3970 BlockDriverAmendStatusCB
*status_cb
)
3972 if (!bs
->drv
->bdrv_amend_options
) {
3975 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3978 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3979 * of block filter and by bdrv_is_first_non_filter.
3980 * It is used to test if the given bs is the candidate or recurse more in the
3983 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3984 BlockDriverState
*candidate
)
3986 /* return false if basic checks fails */
3987 if (!bs
|| !bs
->drv
) {
3991 /* the code reached a non block filter driver -> check if the bs is
3992 * the same as the candidate. It's the recursion termination condition.
3994 if (!bs
->drv
->is_filter
) {
3995 return bs
== candidate
;
3997 /* Down this path the driver is a block filter driver */
3999 /* If the block filter recursion method is defined use it to recurse down
4002 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
4003 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
4006 /* the driver is a block filter but don't allow to recurse -> return false
4011 /* This function checks if the candidate is the first non filter bs down it's
4012 * bs chain. Since we don't have pointers to parents it explore all bs chains
4013 * from the top. Some filters can choose not to pass down the recursion.
4015 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
4017 BlockDriverState
*bs
;
4019 /* walk down the bs forest recursively */
4020 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4023 /* try to recurse in this top level bs */
4024 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
4026 /* candidate is the first non filter */
4035 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
4037 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
4038 AioContext
*aio_context
;
4040 if (!to_replace_bs
) {
4041 error_setg(errp
, "Node name '%s' not found", node_name
);
4045 aio_context
= bdrv_get_aio_context(to_replace_bs
);
4046 aio_context_acquire(aio_context
);
4048 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
4049 to_replace_bs
= NULL
;
4053 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4054 * most non filter in order to prevent data corruption.
4055 * Another benefit is that this tests exclude backing files which are
4056 * blocked by the backing blockers.
4058 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
4059 error_setg(errp
, "Only top most non filter can be replaced");
4060 to_replace_bs
= NULL
;
4065 aio_context_release(aio_context
);
4066 return to_replace_bs
;
4069 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
4071 const QDictEntry
*entry
;
4072 bool found_any
= false;
4074 for (entry
= qdict_first(bs
->options
); entry
;
4075 entry
= qdict_next(bs
->options
, entry
))
4077 /* Only take options for this level and exclude all non-driver-specific
4079 if (!strchr(qdict_entry_key(entry
), '.') &&
4080 strcmp(qdict_entry_key(entry
), "node-name"))
4082 qobject_incref(qdict_entry_value(entry
));
4083 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
4091 /* Updates the following BDS fields:
4092 * - exact_filename: A filename which may be used for opening a block device
4093 * which (mostly) equals the given BDS (even without any
4094 * other options; so reading and writing must return the same
4095 * results, but caching etc. may be different)
4096 * - full_open_options: Options which, when given when opening a block device
4097 * (without a filename), result in a BDS (mostly)
4098 * equalling the given one
4099 * - filename: If exact_filename is set, it is copied here. Otherwise,
4100 * full_open_options is converted to a JSON object, prefixed with
4101 * "json:" (for use through the JSON pseudo protocol) and put here.
4103 void bdrv_refresh_filename(BlockDriverState
*bs
)
4105 BlockDriver
*drv
= bs
->drv
;
4112 /* This BDS's file name will most probably depend on its file's name, so
4113 * refresh that first */
4115 bdrv_refresh_filename(bs
->file
);
4118 if (drv
->bdrv_refresh_filename
) {
4119 /* Obsolete information is of no use here, so drop the old file name
4120 * information before refreshing it */
4121 bs
->exact_filename
[0] = '\0';
4122 if (bs
->full_open_options
) {
4123 QDECREF(bs
->full_open_options
);
4124 bs
->full_open_options
= NULL
;
4127 drv
->bdrv_refresh_filename(bs
);
4128 } else if (bs
->file
) {
4129 /* Try to reconstruct valid information from the underlying file */
4130 bool has_open_options
;
4132 bs
->exact_filename
[0] = '\0';
4133 if (bs
->full_open_options
) {
4134 QDECREF(bs
->full_open_options
);
4135 bs
->full_open_options
= NULL
;
4139 has_open_options
= append_open_options(opts
, bs
);
4141 /* If no specific options have been given for this BDS, the filename of
4142 * the underlying file should suffice for this one as well */
4143 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
4144 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
4146 /* Reconstructing the full options QDict is simple for most format block
4147 * drivers, as long as the full options are known for the underlying
4148 * file BDS. The full options QDict of that file BDS should somehow
4149 * contain a representation of the filename, therefore the following
4150 * suffices without querying the (exact_)filename of this BDS. */
4151 if (bs
->file
->full_open_options
) {
4152 qdict_put_obj(opts
, "driver",
4153 QOBJECT(qstring_from_str(drv
->format_name
)));
4154 QINCREF(bs
->file
->full_open_options
);
4155 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
4157 bs
->full_open_options
= opts
;
4161 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4162 /* There is no underlying file BDS (at least referenced by BDS.file),
4163 * so the full options QDict should be equal to the options given
4164 * specifically for this block device when it was opened (plus the
4165 * driver specification).
4166 * Because those options don't change, there is no need to update
4167 * full_open_options when it's already set. */
4170 append_open_options(opts
, bs
);
4171 qdict_put_obj(opts
, "driver",
4172 QOBJECT(qstring_from_str(drv
->format_name
)));
4174 if (bs
->exact_filename
[0]) {
4175 /* This may not work for all block protocol drivers (some may
4176 * require this filename to be parsed), but we have to find some
4177 * default solution here, so just include it. If some block driver
4178 * does not support pure options without any filename at all or
4179 * needs some special format of the options QDict, it needs to
4180 * implement the driver-specific bdrv_refresh_filename() function.
4182 qdict_put_obj(opts
, "filename",
4183 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4186 bs
->full_open_options
= opts
;
4189 if (bs
->exact_filename
[0]) {
4190 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4191 } else if (bs
->full_open_options
) {
4192 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4193 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4194 qstring_get_str(json
));
4199 /* This accessor function purpose is to allow the device models to access the
4200 * BlockAcctStats structure embedded inside a BlockDriverState without being
4201 * aware of the BlockDriverState structure layout.
4202 * It will go away when the BlockAcctStats structure will be moved inside
4203 * the device models.
4205 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)