2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
44 #include <sys/types.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
65 struct BdrvDirtyBitmap
{
66 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
68 char *name
; /* Optional non-empty unique ID */
69 int64_t size
; /* Size of the bitmap (Number of sectors) */
70 bool disabled
; /* Bitmap is read-only */
71 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
76 struct BdrvStates bdrv_states
= QTAILQ_HEAD_INITIALIZER(bdrv_states
);
78 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
79 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
81 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
82 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
84 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
85 const char *reference
, QDict
*options
, int flags
,
86 BlockDriverState
*parent
,
87 const BdrvChildRole
*child_role
, Error
**errp
);
89 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
90 /* If non-zero, use only whitelisted block drivers */
91 static int use_bdrv_whitelist
;
94 static int is_windows_drive_prefix(const char *filename
)
96 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
97 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
101 int is_windows_drive(const char *filename
)
103 if (is_windows_drive_prefix(filename
) &&
106 if (strstart(filename
, "\\\\.\\", NULL
) ||
107 strstart(filename
, "//./", NULL
))
113 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
115 if (!bs
|| !bs
->drv
) {
116 /* page size or 4k (hdd sector size) should be on the safe side */
117 return MAX(4096, getpagesize());
120 return bs
->bl
.opt_mem_alignment
;
123 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
125 if (!bs
|| !bs
->drv
) {
126 /* page size or 4k (hdd sector size) should be on the safe side */
127 return MAX(4096, getpagesize());
130 return bs
->bl
.min_mem_alignment
;
133 /* check if the path starts with "<protocol>:" */
134 int path_has_protocol(const char *path
)
139 if (is_windows_drive(path
) ||
140 is_windows_drive_prefix(path
)) {
143 p
= path
+ strcspn(path
, ":/\\");
145 p
= path
+ strcspn(path
, ":/");
151 int path_is_absolute(const char *path
)
154 /* specific case for names like: "\\.\d:" */
155 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
158 return (*path
== '/' || *path
== '\\');
160 return (*path
== '/');
164 /* if filename is absolute, just copy it to dest. Otherwise, build a
165 path to it by considering it is relative to base_path. URL are
167 void path_combine(char *dest
, int dest_size
,
168 const char *base_path
,
169 const char *filename
)
176 if (path_is_absolute(filename
)) {
177 pstrcpy(dest
, dest_size
, filename
);
179 p
= strchr(base_path
, ':');
184 p1
= strrchr(base_path
, '/');
188 p2
= strrchr(base_path
, '\\');
200 if (len
> dest_size
- 1)
202 memcpy(dest
, base_path
, len
);
204 pstrcat(dest
, dest_size
, filename
);
208 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
210 char *dest
, size_t sz
,
213 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
214 path_is_absolute(backing
))
216 pstrcpy(dest
, sz
, backing
);
217 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
218 error_setg(errp
, "Cannot use relative backing file names for '%s'",
221 path_combine(dest
, sz
, backed
, backing
);
225 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
228 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
230 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
234 void bdrv_register(BlockDriver
*bdrv
)
236 bdrv_setup_io_funcs(bdrv
);
238 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
241 BlockDriverState
*bdrv_new_root(void)
243 BlockDriverState
*bs
= bdrv_new();
245 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
249 BlockDriverState
*bdrv_new(void)
251 BlockDriverState
*bs
;
254 bs
= g_new0(BlockDriverState
, 1);
255 QLIST_INIT(&bs
->dirty_bitmaps
);
256 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
257 QLIST_INIT(&bs
->op_blockers
[i
]);
259 notifier_list_init(&bs
->close_notifiers
);
260 notifier_with_return_list_init(&bs
->before_write_notifiers
);
261 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
262 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
264 bs
->aio_context
= qemu_get_aio_context();
269 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
271 notifier_list_add(&bs
->close_notifiers
, notify
);
274 BlockDriver
*bdrv_find_format(const char *format_name
)
277 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
278 if (!strcmp(drv1
->format_name
, format_name
)) {
285 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
287 static const char *whitelist_rw
[] = {
288 CONFIG_BDRV_RW_WHITELIST
290 static const char *whitelist_ro
[] = {
291 CONFIG_BDRV_RO_WHITELIST
295 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
296 return 1; /* no whitelist, anything goes */
299 for (p
= whitelist_rw
; *p
; p
++) {
300 if (!strcmp(drv
->format_name
, *p
)) {
305 for (p
= whitelist_ro
; *p
; p
++) {
306 if (!strcmp(drv
->format_name
, *p
)) {
314 typedef struct CreateCo
{
322 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
324 Error
*local_err
= NULL
;
327 CreateCo
*cco
= opaque
;
330 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
332 error_propagate(&cco
->err
, local_err
);
337 int bdrv_create(BlockDriver
*drv
, const char* filename
,
338 QemuOpts
*opts
, Error
**errp
)
345 .filename
= g_strdup(filename
),
351 if (!drv
->bdrv_create
) {
352 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
357 if (qemu_in_coroutine()) {
358 /* Fast-path if already in coroutine context */
359 bdrv_create_co_entry(&cco
);
361 co
= qemu_coroutine_create(bdrv_create_co_entry
);
362 qemu_coroutine_enter(co
, &cco
);
363 while (cco
.ret
== NOT_DONE
) {
364 aio_poll(qemu_get_aio_context(), true);
371 error_propagate(errp
, cco
.err
);
373 error_setg_errno(errp
, -ret
, "Could not create image");
378 g_free(cco
.filename
);
382 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
385 Error
*local_err
= NULL
;
388 drv
= bdrv_find_protocol(filename
, true, errp
);
393 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
395 error_propagate(errp
, local_err
);
401 * Try to get @bs's logical and physical block size.
402 * On success, store them in @bsz struct and return 0.
403 * On failure return -errno.
404 * @bs must not be empty.
406 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
408 BlockDriver
*drv
= bs
->drv
;
410 if (drv
&& drv
->bdrv_probe_blocksizes
) {
411 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
418 * Try to get @bs's geometry (cyls, heads, sectors).
419 * On success, store them in @geo struct and return 0.
420 * On failure return -errno.
421 * @bs must not be empty.
423 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
425 BlockDriver
*drv
= bs
->drv
;
427 if (drv
&& drv
->bdrv_probe_geometry
) {
428 return drv
->bdrv_probe_geometry(bs
, geo
);
435 * Create a uniquely-named empty temporary file.
436 * Return 0 upon success, otherwise a negative errno value.
438 int get_tmp_filename(char *filename
, int size
)
441 char temp_dir
[MAX_PATH
];
442 /* GetTempFileName requires that its output buffer (4th param)
443 have length MAX_PATH or greater. */
444 assert(size
>= MAX_PATH
);
445 return (GetTempPath(MAX_PATH
, temp_dir
)
446 && GetTempFileName(temp_dir
, "qem", 0, filename
)
447 ? 0 : -GetLastError());
451 tmpdir
= getenv("TMPDIR");
455 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
458 fd
= mkstemp(filename
);
462 if (close(fd
) != 0) {
471 * Detect host devices. By convention, /dev/cdrom[N] is always
472 * recognized as a host CDROM.
474 static BlockDriver
*find_hdev_driver(const char *filename
)
476 int score_max
= 0, score
;
477 BlockDriver
*drv
= NULL
, *d
;
479 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
480 if (d
->bdrv_probe_device
) {
481 score
= d
->bdrv_probe_device(filename
);
482 if (score
> score_max
) {
492 BlockDriver
*bdrv_find_protocol(const char *filename
,
493 bool allow_protocol_prefix
,
501 /* TODO Drivers without bdrv_file_open must be specified explicitly */
504 * XXX(hch): we really should not let host device detection
505 * override an explicit protocol specification, but moving this
506 * later breaks access to device names with colons in them.
507 * Thanks to the brain-dead persistent naming schemes on udev-
508 * based Linux systems those actually are quite common.
510 drv1
= find_hdev_driver(filename
);
515 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
519 p
= strchr(filename
, ':');
522 if (len
> sizeof(protocol
) - 1)
523 len
= sizeof(protocol
) - 1;
524 memcpy(protocol
, filename
, len
);
525 protocol
[len
] = '\0';
526 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
527 if (drv1
->protocol_name
&&
528 !strcmp(drv1
->protocol_name
, protocol
)) {
533 error_setg(errp
, "Unknown protocol '%s'", protocol
);
538 * Guess image format by probing its contents.
539 * This is not a good idea when your image is raw (CVE-2008-2004), but
540 * we do it anyway for backward compatibility.
542 * @buf contains the image's first @buf_size bytes.
543 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
544 * but can be smaller if the image file is smaller)
545 * @filename is its filename.
547 * For all block drivers, call the bdrv_probe() method to get its
549 * Return the first block driver with the highest probing score.
551 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
552 const char *filename
)
554 int score_max
= 0, score
;
555 BlockDriver
*drv
= NULL
, *d
;
557 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
559 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
560 if (score
> score_max
) {
570 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
571 BlockDriver
**pdrv
, Error
**errp
)
574 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
577 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
578 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
583 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
585 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
591 drv
= bdrv_probe_all(buf
, ret
, filename
);
593 error_setg(errp
, "Could not determine image format: No compatible "
602 * Set the current 'total_sectors' value
603 * Return 0 on success, -errno on error.
605 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
607 BlockDriver
*drv
= bs
->drv
;
609 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
613 /* query actual device if possible, otherwise just trust the hint */
614 if (drv
->bdrv_getlength
) {
615 int64_t length
= drv
->bdrv_getlength(bs
);
619 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
622 bs
->total_sectors
= hint
;
627 * Set open flags for a given discard mode
629 * Return 0 on success, -1 if the discard mode was invalid.
631 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
633 *flags
&= ~BDRV_O_UNMAP
;
635 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
637 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
638 *flags
|= BDRV_O_UNMAP
;
647 * Set open flags for a given cache mode
649 * Return 0 on success, -1 if the cache mode was invalid.
651 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
653 *flags
&= ~BDRV_O_CACHE_MASK
;
655 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
656 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
657 } else if (!strcmp(mode
, "directsync")) {
658 *flags
|= BDRV_O_NOCACHE
;
659 } else if (!strcmp(mode
, "writeback")) {
660 *flags
|= BDRV_O_CACHE_WB
;
661 } else if (!strcmp(mode
, "unsafe")) {
662 *flags
|= BDRV_O_CACHE_WB
;
663 *flags
|= BDRV_O_NO_FLUSH
;
664 } else if (!strcmp(mode
, "writethrough")) {
665 /* this is the default */
674 * Returns the flags that a temporary snapshot should get, based on the
675 * originally requested flags (the originally requested image will have flags
676 * like a backing file)
678 static int bdrv_temp_snapshot_flags(int flags
)
680 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
684 * Returns the flags that bs->file should get if a protocol driver is expected,
685 * based on the given flags for the parent BDS
687 static int bdrv_inherited_flags(int flags
)
689 /* Enable protocol handling, disable format probing for bs->file */
690 flags
|= BDRV_O_PROTOCOL
;
692 /* Our block drivers take care to send flushes and respect unmap policy,
693 * so we can enable both unconditionally on lower layers. */
694 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
696 /* Clear flags that only apply to the top layer */
697 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
702 const BdrvChildRole child_file
= {
703 .inherit_flags
= bdrv_inherited_flags
,
707 * Returns the flags that bs->file should get if the use of formats (and not
708 * only protocols) is permitted for it, based on the given flags for the parent
711 static int bdrv_inherited_fmt_flags(int parent_flags
)
713 int flags
= child_file
.inherit_flags(parent_flags
);
714 return flags
& ~BDRV_O_PROTOCOL
;
717 const BdrvChildRole child_format
= {
718 .inherit_flags
= bdrv_inherited_fmt_flags
,
722 * Returns the flags that bs->backing should get, based on the given flags
725 static int bdrv_backing_flags(int flags
)
727 /* backing files always opened read-only */
728 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
730 /* snapshot=on is handled on the top layer */
731 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
736 static const BdrvChildRole child_backing
= {
737 .inherit_flags
= bdrv_backing_flags
,
740 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
742 int open_flags
= flags
| BDRV_O_CACHE_WB
;
745 * Clear flags that are internal to the block layer before opening the
748 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
751 * Snapshots should be writable.
753 if (flags
& BDRV_O_TEMPORARY
) {
754 open_flags
|= BDRV_O_RDWR
;
760 static void bdrv_assign_node_name(BlockDriverState
*bs
,
761 const char *node_name
,
764 char *gen_node_name
= NULL
;
767 node_name
= gen_node_name
= id_generate(ID_BLOCK
);
768 } else if (!id_wellformed(node_name
)) {
770 * Check for empty string or invalid characters, but not if it is
771 * generated (generated names use characters not available to the user)
773 error_setg(errp
, "Invalid node name");
777 /* takes care of avoiding namespaces collisions */
778 if (blk_by_name(node_name
)) {
779 error_setg(errp
, "node-name=%s is conflicting with a device id",
784 /* takes care of avoiding duplicates node names */
785 if (bdrv_find_node(node_name
)) {
786 error_setg(errp
, "Duplicate node name");
790 /* copy node name into the bs and insert it into the graph list */
791 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
792 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
794 g_free(gen_node_name
);
797 static QemuOptsList bdrv_runtime_opts
= {
798 .name
= "bdrv_common",
799 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
803 .type
= QEMU_OPT_STRING
,
804 .help
= "Node name of the block device node",
806 { /* end of list */ }
811 * Common part for opening disk images and files
813 * Removes all processed options from *options.
815 static int bdrv_open_common(BlockDriverState
*bs
, BdrvChild
*file
,
816 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
819 const char *filename
;
820 const char *node_name
= NULL
;
822 Error
*local_err
= NULL
;
825 assert(bs
->file
== NULL
);
826 assert(options
!= NULL
&& bs
->options
!= options
);
829 filename
= file
->bs
->filename
;
831 filename
= qdict_get_try_str(options
, "filename");
834 if (drv
->bdrv_needs_filename
&& !filename
) {
835 error_setg(errp
, "The '%s' block driver requires a file name",
840 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
842 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
843 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
845 error_propagate(errp
, local_err
);
850 node_name
= qemu_opt_get(opts
, "node-name");
851 bdrv_assign_node_name(bs
, node_name
, &local_err
);
853 error_propagate(errp
, local_err
);
858 bs
->request_alignment
= 512;
859 bs
->zero_beyond_eof
= true;
860 open_flags
= bdrv_open_flags(bs
, flags
);
861 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
863 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
865 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
866 ? "Driver '%s' can only be used for read-only devices"
867 : "Driver '%s' is not whitelisted",
873 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
874 if (flags
& BDRV_O_COPY_ON_READ
) {
875 if (!bs
->read_only
) {
876 bdrv_enable_copy_on_read(bs
);
878 error_setg(errp
, "Can't use copy-on-read on read-only device");
884 if (filename
!= NULL
) {
885 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
887 bs
->filename
[0] = '\0';
889 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
892 bs
->opaque
= g_malloc0(drv
->instance_size
);
894 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
896 /* Open the image, either directly or using a protocol */
897 if (drv
->bdrv_file_open
) {
898 assert(file
== NULL
);
899 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
900 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
903 error_setg(errp
, "Can't use '%s' as a block driver for the "
904 "protocol level", drv
->format_name
);
909 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
914 error_propagate(errp
, local_err
);
915 } else if (bs
->filename
[0]) {
916 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
918 error_setg_errno(errp
, -ret
, "Could not open image");
924 error_report("Encrypted images are deprecated");
925 error_printf("Support for them will be removed in a future release.\n"
926 "You can use 'qemu-img convert' to convert your image"
927 " to an unencrypted one.\n");
930 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
932 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
936 bdrv_refresh_limits(bs
, &local_err
);
938 error_propagate(errp
, local_err
);
943 assert(bdrv_opt_mem_align(bs
) != 0);
944 assert(bdrv_min_mem_align(bs
) != 0);
945 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
960 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
962 QObject
*options_obj
;
966 ret
= strstart(filename
, "json:", &filename
);
969 options_obj
= qobject_from_json(filename
);
971 error_setg(errp
, "Could not parse the JSON options");
975 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
976 qobject_decref(options_obj
);
977 error_setg(errp
, "Invalid JSON object given");
981 options
= qobject_to_qdict(options_obj
);
982 qdict_flatten(options
);
988 * Fills in default options for opening images and converts the legacy
989 * filename/flags pair to option QDict entries.
990 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
991 * block driver has been specified explicitly.
993 static int bdrv_fill_options(QDict
**options
, const char **pfilename
,
994 int *flags
, Error
**errp
)
996 const char *filename
= *pfilename
;
998 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
999 bool parse_filename
= false;
1000 BlockDriver
*drv
= NULL
;
1001 Error
*local_err
= NULL
;
1003 /* Parse json: pseudo-protocol */
1004 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1005 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1007 error_propagate(errp
, local_err
);
1011 /* Options given in the filename have lower priority than options
1012 * specified directly */
1013 qdict_join(*options
, json_options
, false);
1014 QDECREF(json_options
);
1015 *pfilename
= filename
= NULL
;
1018 drvname
= qdict_get_try_str(*options
, "driver");
1020 drv
= bdrv_find_format(drvname
);
1022 error_setg(errp
, "Unknown driver '%s'", drvname
);
1025 /* If the user has explicitly specified the driver, this choice should
1026 * override the BDRV_O_PROTOCOL flag */
1027 protocol
= drv
->bdrv_file_open
;
1031 *flags
|= BDRV_O_PROTOCOL
;
1033 *flags
&= ~BDRV_O_PROTOCOL
;
1036 /* Fetch the file name from the options QDict if necessary */
1037 if (protocol
&& filename
) {
1038 if (!qdict_haskey(*options
, "filename")) {
1039 qdict_put(*options
, "filename", qstring_from_str(filename
));
1040 parse_filename
= true;
1042 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1048 /* Find the right block driver */
1049 filename
= qdict_get_try_str(*options
, "filename");
1051 if (!drvname
&& protocol
) {
1053 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1058 drvname
= drv
->format_name
;
1059 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1061 error_setg(errp
, "Must specify either driver or file");
1066 assert(drv
|| !protocol
);
1068 /* Driver-specific filename parsing */
1069 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1070 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1072 error_propagate(errp
, local_err
);
1076 if (!drv
->bdrv_needs_filename
) {
1077 qdict_del(*options
, "filename");
1081 if (runstate_check(RUN_STATE_INMIGRATE
)) {
1082 *flags
|= BDRV_O_INCOMING
;
1088 static BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1089 BlockDriverState
*child_bs
,
1090 const BdrvChildRole
*child_role
)
1092 BdrvChild
*child
= g_new(BdrvChild
, 1);
1093 *child
= (BdrvChild
) {
1098 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1099 QLIST_INSERT_HEAD(&child_bs
->parents
, child
, next_parent
);
1104 static void bdrv_detach_child(BdrvChild
*child
)
1106 QLIST_REMOVE(child
, next
);
1107 QLIST_REMOVE(child
, next_parent
);
1111 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1113 BlockDriverState
*child_bs
;
1115 if (child
== NULL
) {
1119 if (child
->bs
->inherits_from
== parent
) {
1120 child
->bs
->inherits_from
= NULL
;
1123 child_bs
= child
->bs
;
1124 bdrv_detach_child(child
);
1125 bdrv_unref(child_bs
);
1129 * Sets the backing file link of a BDS. A new reference is created; callers
1130 * which don't need their own reference any more must call bdrv_unref().
1132 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1135 bdrv_ref(backing_hd
);
1139 assert(bs
->backing_blocker
);
1140 bdrv_op_unblock_all(bs
->backing
->bs
, bs
->backing_blocker
);
1141 bdrv_unref_child(bs
, bs
->backing
);
1142 } else if (backing_hd
) {
1143 error_setg(&bs
->backing_blocker
,
1144 "node is used as backing hd of '%s'",
1145 bdrv_get_device_or_node_name(bs
));
1149 error_free(bs
->backing_blocker
);
1150 bs
->backing_blocker
= NULL
;
1154 bs
->backing
= bdrv_attach_child(bs
, backing_hd
, &child_backing
);
1155 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1156 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1157 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1158 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1160 bdrv_op_block_all(backing_hd
, bs
->backing_blocker
);
1161 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1162 bdrv_op_unblock(backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1163 bs
->backing_blocker
);
1165 bdrv_refresh_limits(bs
, NULL
);
1169 * Opens the backing file for a BlockDriverState if not yet open
1171 * options is a QDict of options to pass to the block drivers, or NULL for an
1172 * empty set of options. The reference to the QDict is transferred to this
1173 * function (even on failure), so if the caller intends to reuse the dictionary,
1174 * it needs to use QINCREF() before calling bdrv_file_open.
1176 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1178 char *backing_filename
= g_malloc0(PATH_MAX
);
1180 BlockDriverState
*backing_hd
;
1181 Error
*local_err
= NULL
;
1183 if (bs
->backing
!= NULL
) {
1188 /* NULL means an empty set of options */
1189 if (options
== NULL
) {
1190 options
= qdict_new();
1193 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1194 if (qdict_haskey(options
, "file.filename")) {
1195 backing_filename
[0] = '\0';
1196 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1200 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1204 error_propagate(errp
, local_err
);
1210 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1212 error_setg(errp
, "Driver doesn't support backing files");
1217 backing_hd
= bdrv_new();
1219 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1220 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1223 assert(bs
->backing
== NULL
);
1224 ret
= bdrv_open_inherit(&backing_hd
,
1225 *backing_filename
? backing_filename
: NULL
,
1226 NULL
, options
, 0, bs
, &child_backing
, &local_err
);
1228 bdrv_unref(backing_hd
);
1230 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1231 error_setg(errp
, "Could not open backing file: %s",
1232 error_get_pretty(local_err
));
1233 error_free(local_err
);
1237 /* Hook up the backing file link; drop our reference, bs owns the
1238 * backing_hd reference now */
1239 bdrv_set_backing_hd(bs
, backing_hd
);
1240 bdrv_unref(backing_hd
);
1243 g_free(backing_filename
);
1248 * Opens a disk image whose options are given as BlockdevRef in another block
1251 * If allow_none is true, no image will be opened if filename is false and no
1252 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1254 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1255 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1256 * itself, all options starting with "${bdref_key}." are considered part of the
1259 * The BlockdevRef will be removed from the options QDict.
1261 BdrvChild
*bdrv_open_child(const char *filename
,
1262 QDict
*options
, const char *bdref_key
,
1263 BlockDriverState
* parent
,
1264 const BdrvChildRole
*child_role
,
1265 bool allow_none
, Error
**errp
)
1267 BdrvChild
*c
= NULL
;
1268 BlockDriverState
*bs
;
1269 QDict
*image_options
;
1271 char *bdref_key_dot
;
1272 const char *reference
;
1274 assert(child_role
!= NULL
);
1276 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1277 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1278 g_free(bdref_key_dot
);
1280 reference
= qdict_get_try_str(options
, bdref_key
);
1281 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1283 error_setg(errp
, "A block device must be specified for \"%s\"",
1286 QDECREF(image_options
);
1291 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1292 parent
, child_role
, errp
);
1297 c
= bdrv_attach_child(parent
, bs
, child_role
);
1300 qdict_del(options
, bdref_key
);
1304 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1306 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1307 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1309 QemuOpts
*opts
= NULL
;
1310 QDict
*snapshot_options
;
1311 BlockDriverState
*bs_snapshot
;
1312 Error
*local_err
= NULL
;
1315 /* if snapshot, we create a temporary backing file and open it
1316 instead of opening 'filename' directly */
1318 /* Get the required size from the image */
1319 total_size
= bdrv_getlength(bs
);
1320 if (total_size
< 0) {
1322 error_setg_errno(errp
, -total_size
, "Could not get image size");
1326 /* Create the temporary image */
1327 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1329 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1333 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1335 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1336 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1337 qemu_opts_del(opts
);
1339 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1340 "'%s': %s", tmp_filename
,
1341 error_get_pretty(local_err
));
1342 error_free(local_err
);
1346 /* Prepare a new options QDict for the temporary file */
1347 snapshot_options
= qdict_new();
1348 qdict_put(snapshot_options
, "file.driver",
1349 qstring_from_str("file"));
1350 qdict_put(snapshot_options
, "file.filename",
1351 qstring_from_str(tmp_filename
));
1352 qdict_put(snapshot_options
, "driver",
1353 qstring_from_str("qcow2"));
1355 bs_snapshot
= bdrv_new();
1357 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1360 error_propagate(errp
, local_err
);
1364 bdrv_append(bs_snapshot
, bs
);
1367 g_free(tmp_filename
);
1372 * Opens a disk image (raw, qcow2, vmdk, ...)
1374 * options is a QDict of options to pass to the block drivers, or NULL for an
1375 * empty set of options. The reference to the QDict belongs to the block layer
1376 * after the call (even on failure), so if the caller intends to reuse the
1377 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1379 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1380 * If it is not NULL, the referenced BDS will be reused.
1382 * The reference parameter may be used to specify an existing block device which
1383 * should be opened. If specified, neither options nor a filename may be given,
1384 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1386 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1387 const char *reference
, QDict
*options
, int flags
,
1388 BlockDriverState
*parent
,
1389 const BdrvChildRole
*child_role
, Error
**errp
)
1392 BdrvChild
*file
= NULL
;
1393 BlockDriverState
*bs
;
1394 BlockDriver
*drv
= NULL
;
1395 const char *drvname
;
1396 Error
*local_err
= NULL
;
1397 int snapshot_flags
= 0;
1400 assert(!child_role
|| !flags
);
1401 assert(!child_role
== !parent
);
1404 bool options_non_empty
= options
? qdict_size(options
) : false;
1408 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1409 "another block device");
1413 if (filename
|| options_non_empty
) {
1414 error_setg(errp
, "Cannot reference an existing block device with "
1415 "additional options or a new filename");
1419 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1434 /* NULL means an empty set of options */
1435 if (options
== NULL
) {
1436 options
= qdict_new();
1440 bs
->inherits_from
= parent
;
1441 flags
= child_role
->inherit_flags(parent
->open_flags
);
1444 ret
= bdrv_fill_options(&options
, &filename
, &flags
, &local_err
);
1449 /* Find the right image format driver */
1450 drvname
= qdict_get_try_str(options
, "driver");
1452 drv
= bdrv_find_format(drvname
);
1453 qdict_del(options
, "driver");
1455 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1461 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1463 bs
->open_flags
= flags
;
1464 bs
->options
= options
;
1465 options
= qdict_clone_shallow(options
);
1467 /* Open image file without format layer */
1468 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1469 if (flags
& BDRV_O_RDWR
) {
1470 flags
|= BDRV_O_ALLOW_RDWR
;
1472 if (flags
& BDRV_O_SNAPSHOT
) {
1473 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1474 flags
= bdrv_backing_flags(flags
);
1477 bs
->open_flags
= flags
;
1479 file
= bdrv_open_child(filename
, options
, "file", bs
,
1480 &child_file
, true, &local_err
);
1487 /* Image format probing */
1490 ret
= find_image_format(file
->bs
, filename
, &drv
, &local_err
);
1495 error_setg(errp
, "Must specify either driver or file");
1500 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1501 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1502 /* file must be NULL if a protocol BDS is about to be created
1503 * (the inverse results in an error message from bdrv_open_common()) */
1504 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1506 /* Open the image */
1507 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1512 if (file
&& (bs
->file
!= file
)) {
1513 bdrv_unref_child(bs
, file
);
1517 /* If there is a backing file, use it */
1518 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1519 QDict
*backing_options
;
1521 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1522 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1524 goto close_and_fail
;
1528 bdrv_refresh_filename(bs
);
1530 /* Check if any unknown options were used */
1531 if (options
&& (qdict_size(options
) != 0)) {
1532 const QDictEntry
*entry
= qdict_first(options
);
1533 if (flags
& BDRV_O_PROTOCOL
) {
1534 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1535 "'%s'", drv
->format_name
, entry
->key
);
1537 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1538 "support the option '%s'", drv
->format_name
,
1539 bdrv_get_device_name(bs
), entry
->key
);
1543 goto close_and_fail
;
1546 if (!bdrv_key_required(bs
)) {
1548 blk_dev_change_media_cb(bs
->blk
, true);
1550 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1551 && !runstate_check(RUN_STATE_INMIGRATE
)
1552 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1554 "Guest must be stopped for opening of encrypted image");
1556 goto close_and_fail
;
1562 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1563 * temporary snapshot afterwards. */
1564 if (snapshot_flags
) {
1565 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1567 goto close_and_fail
;
1575 bdrv_unref_child(bs
, file
);
1577 QDECREF(bs
->options
);
1581 /* If *pbs is NULL, a new BDS has been created in this function and
1582 needs to be freed now. Otherwise, it does not need to be closed,
1583 since it has not really been opened yet. */
1587 error_propagate(errp
, local_err
);
1592 /* See fail path, but now the BDS has to be always closed */
1600 error_propagate(errp
, local_err
);
1605 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1606 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1608 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1612 typedef struct BlockReopenQueueEntry
{
1614 BDRVReopenState state
;
1615 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1616 } BlockReopenQueueEntry
;
1619 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1620 * reopen of multiple devices.
1622 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1623 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1624 * be created and initialized. This newly created BlockReopenQueue should be
1625 * passed back in for subsequent calls that are intended to be of the same
1628 * bs is the BlockDriverState to add to the reopen queue.
1630 * options contains the changed options for the associated bs
1631 * (the BlockReopenQueue takes ownership)
1633 * flags contains the open flags for the associated bs
1635 * returns a pointer to bs_queue, which is either the newly allocated
1636 * bs_queue, or the existing bs_queue being used.
1639 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1640 BlockDriverState
*bs
,
1641 QDict
*options
, int flags
)
1645 BlockReopenQueueEntry
*bs_entry
;
1649 if (bs_queue
== NULL
) {
1650 bs_queue
= g_new0(BlockReopenQueue
, 1);
1651 QSIMPLEQ_INIT(bs_queue
);
1655 options
= qdict_new();
1658 old_options
= qdict_clone_shallow(bs
->options
);
1659 qdict_join(options
, old_options
, false);
1660 QDECREF(old_options
);
1662 /* bdrv_open() masks this flag out */
1663 flags
&= ~BDRV_O_PROTOCOL
;
1665 QLIST_FOREACH(child
, &bs
->children
, next
) {
1668 if (child
->bs
->inherits_from
!= bs
) {
1672 child_flags
= child
->role
->inherit_flags(flags
);
1673 /* TODO Pass down child flags (backing.*, extents.*, ...) */
1674 bdrv_reopen_queue(bs_queue
, child
->bs
, NULL
, child_flags
);
1677 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1678 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1680 bs_entry
->state
.bs
= bs
;
1681 bs_entry
->state
.options
= options
;
1682 bs_entry
->state
.flags
= flags
;
1688 * Reopen multiple BlockDriverStates atomically & transactionally.
1690 * The queue passed in (bs_queue) must have been built up previous
1691 * via bdrv_reopen_queue().
1693 * Reopens all BDS specified in the queue, with the appropriate
1694 * flags. All devices are prepared for reopen, and failure of any
1695 * device will cause all device changes to be abandonded, and intermediate
1698 * If all devices prepare successfully, then the changes are committed
1702 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1705 BlockReopenQueueEntry
*bs_entry
, *next
;
1706 Error
*local_err
= NULL
;
1708 assert(bs_queue
!= NULL
);
1712 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1713 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1714 error_propagate(errp
, local_err
);
1717 bs_entry
->prepared
= true;
1720 /* If we reach this point, we have success and just need to apply the
1723 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1724 bdrv_reopen_commit(&bs_entry
->state
);
1730 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1731 if (ret
&& bs_entry
->prepared
) {
1732 bdrv_reopen_abort(&bs_entry
->state
);
1734 QDECREF(bs_entry
->state
.options
);
1742 /* Reopen a single BlockDriverState with the specified flags. */
1743 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1746 Error
*local_err
= NULL
;
1747 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, NULL
, bdrv_flags
);
1749 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1750 if (local_err
!= NULL
) {
1751 error_propagate(errp
, local_err
);
1758 * Prepares a BlockDriverState for reopen. All changes are staged in the
1759 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1760 * the block driver layer .bdrv_reopen_prepare()
1762 * bs is the BlockDriverState to reopen
1763 * flags are the new open flags
1764 * queue is the reopen queue
1766 * Returns 0 on success, non-zero on error. On error errp will be set
1769 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1770 * It is the responsibility of the caller to then call the abort() or
1771 * commit() for any other BDS that have been left in a prepare() state
1774 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1778 Error
*local_err
= NULL
;
1781 assert(reopen_state
!= NULL
);
1782 assert(reopen_state
->bs
->drv
!= NULL
);
1783 drv
= reopen_state
->bs
->drv
;
1785 /* if we are to stay read-only, do not allow permission change
1787 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1788 reopen_state
->flags
& BDRV_O_RDWR
) {
1789 error_setg(errp
, "Node '%s' is read only",
1790 bdrv_get_device_or_node_name(reopen_state
->bs
));
1795 ret
= bdrv_flush(reopen_state
->bs
);
1797 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1802 if (drv
->bdrv_reopen_prepare
) {
1803 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1805 if (local_err
!= NULL
) {
1806 error_propagate(errp
, local_err
);
1808 error_setg(errp
, "failed while preparing to reopen image '%s'",
1809 reopen_state
->bs
->filename
);
1814 /* It is currently mandatory to have a bdrv_reopen_prepare()
1815 * handler for each supported drv. */
1816 error_setg(errp
, "Block format '%s' used by node '%s' "
1817 "does not support reopening files", drv
->format_name
,
1818 bdrv_get_device_or_node_name(reopen_state
->bs
));
1823 /* Options that are not handled are only okay if they are unchanged
1824 * compared to the old state. It is expected that some options are only
1825 * used for the initial open, but not reopen (e.g. filename) */
1826 if (qdict_size(reopen_state
->options
)) {
1827 const QDictEntry
*entry
= qdict_first(reopen_state
->options
);
1830 QString
*new_obj
= qobject_to_qstring(entry
->value
);
1831 const char *new = qstring_get_str(new_obj
);
1832 const char *old
= qdict_get_try_str(reopen_state
->bs
->options
,
1835 if (!old
|| strcmp(new, old
)) {
1836 error_setg(errp
, "Cannot change the option '%s'", entry
->key
);
1840 } while ((entry
= qdict_next(reopen_state
->options
, entry
)));
1850 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1851 * makes them final by swapping the staging BlockDriverState contents into
1852 * the active BlockDriverState contents.
1854 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1858 assert(reopen_state
!= NULL
);
1859 drv
= reopen_state
->bs
->drv
;
1860 assert(drv
!= NULL
);
1862 /* If there are any driver level actions to take */
1863 if (drv
->bdrv_reopen_commit
) {
1864 drv
->bdrv_reopen_commit(reopen_state
);
1867 /* set BDS specific flags now */
1868 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1869 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1871 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1873 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1877 * Abort the reopen, and delete and free the staged changes in
1880 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1884 assert(reopen_state
!= NULL
);
1885 drv
= reopen_state
->bs
->drv
;
1886 assert(drv
!= NULL
);
1888 if (drv
->bdrv_reopen_abort
) {
1889 drv
->bdrv_reopen_abort(reopen_state
);
1894 void bdrv_close(BlockDriverState
*bs
)
1896 BdrvAioNotifier
*ban
, *ban_next
;
1899 block_job_cancel_sync(bs
->job
);
1902 /* Disable I/O limits and drain all pending throttled requests */
1903 if (bs
->io_limits_enabled
) {
1904 bdrv_io_limits_disable(bs
);
1907 bdrv_drain(bs
); /* complete I/O */
1909 bdrv_drain(bs
); /* in case flush left pending I/O */
1910 notifier_list_notify(&bs
->close_notifiers
, bs
);
1913 blk_dev_change_media_cb(bs
->blk
, false);
1917 BdrvChild
*child
, *next
;
1919 bs
->drv
->bdrv_close(bs
);
1922 bdrv_set_backing_hd(bs
, NULL
);
1924 if (bs
->file
!= NULL
) {
1925 bdrv_unref_child(bs
, bs
->file
);
1929 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
1930 /* TODO Remove bdrv_unref() from drivers' close function and use
1931 * bdrv_unref_child() here */
1932 if (child
->bs
->inherits_from
== bs
) {
1933 child
->bs
->inherits_from
= NULL
;
1935 bdrv_detach_child(child
);
1940 bs
->copy_on_read
= 0;
1941 bs
->backing_file
[0] = '\0';
1942 bs
->backing_format
[0] = '\0';
1943 bs
->total_sectors
= 0;
1947 bs
->zero_beyond_eof
= false;
1948 QDECREF(bs
->options
);
1950 QDECREF(bs
->full_open_options
);
1951 bs
->full_open_options
= NULL
;
1954 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1957 QLIST_INIT(&bs
->aio_notifiers
);
1960 void bdrv_close_all(void)
1962 BlockDriverState
*bs
;
1964 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1965 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1967 aio_context_acquire(aio_context
);
1969 aio_context_release(aio_context
);
1973 /* make a BlockDriverState anonymous by removing from bdrv_state and
1974 * graph_bdrv_state list.
1975 Also, NULL terminate the device_name to prevent double remove */
1976 void bdrv_make_anon(BlockDriverState
*bs
)
1979 * Take care to remove bs from bdrv_states only when it's actually
1980 * in it. Note that bs->device_list.tqe_prev is initially null,
1981 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1982 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1983 * resetting it to null on remove.
1985 if (bs
->device_list
.tqe_prev
) {
1986 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1987 bs
->device_list
.tqe_prev
= NULL
;
1989 if (bs
->node_name
[0] != '\0') {
1990 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1992 bs
->node_name
[0] = '\0';
1995 /* Fields that need to stay with the top-level BDS */
1996 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1997 BlockDriverState
*bs_src
)
1999 /* move some fields that need to stay attached to the device */
2002 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2004 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2007 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2010 static void change_parent_backing_link(BlockDriverState
*from
,
2011 BlockDriverState
*to
)
2013 BdrvChild
*c
, *next
;
2015 QLIST_FOREACH_SAFE(c
, &from
->parents
, next_parent
, next
) {
2016 assert(c
->role
!= &child_backing
);
2018 QLIST_REMOVE(c
, next_parent
);
2019 QLIST_INSERT_HEAD(&to
->parents
, c
, next_parent
);
2024 blk_set_bs(from
->blk
, to
);
2025 if (!to
->device_list
.tqe_prev
) {
2026 QTAILQ_INSERT_BEFORE(from
, to
, device_list
);
2028 QTAILQ_REMOVE(&bdrv_states
, from
, device_list
);
2032 static void swap_feature_fields(BlockDriverState
*bs_top
,
2033 BlockDriverState
*bs_new
)
2035 BlockDriverState tmp
;
2037 bdrv_move_feature_fields(&tmp
, bs_top
);
2038 bdrv_move_feature_fields(bs_top
, bs_new
);
2039 bdrv_move_feature_fields(bs_new
, &tmp
);
2041 assert(!bs_new
->throttle_state
);
2042 if (bs_top
->throttle_state
) {
2043 assert(bs_top
->io_limits_enabled
);
2044 bdrv_io_limits_enable(bs_new
, throttle_group_get_name(bs_top
));
2045 bdrv_io_limits_disable(bs_top
);
2050 * Add new bs contents at the top of an image chain while the chain is
2051 * live, while keeping required fields on the top layer.
2053 * This will modify the BlockDriverState fields, and swap contents
2054 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2056 * bs_new must not be attached to a BlockBackend.
2058 * This function does not create any image files.
2060 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2061 * that's what the callers commonly need. bs_new will be referenced by the old
2062 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2063 * reference of its own, it must call bdrv_ref().
2065 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2067 assert(!bdrv_requests_pending(bs_top
));
2068 assert(!bdrv_requests_pending(bs_new
));
2071 change_parent_backing_link(bs_top
, bs_new
);
2073 /* Some fields always stay on top of the backing file chain */
2074 swap_feature_fields(bs_top
, bs_new
);
2076 bdrv_set_backing_hd(bs_new
, bs_top
);
2079 /* bs_new is now referenced by its new parents, we don't need the
2080 * additional reference any more. */
2084 void bdrv_replace_in_backing_chain(BlockDriverState
*old
, BlockDriverState
*new)
2086 assert(!bdrv_requests_pending(old
));
2087 assert(!bdrv_requests_pending(new));
2092 /* As long as these fields aren't in BlockBackend, but in the top-level
2093 * BlockDriverState, it's not possible for a BDS to have two BBs.
2095 * We really want to copy the fields from old to new, but we go for a
2096 * swap instead so that pointers aren't duplicated and cause trouble.
2097 * (Also, bdrv_swap() used to do the same.) */
2099 swap_feature_fields(old
, new);
2101 change_parent_backing_link(old
, new);
2103 /* Change backing files if a previously independent node is added to the
2104 * chain. For active commit, we replace top by its own (indirect) backing
2105 * file and don't do anything here so we don't build a loop. */
2106 if (new->backing
== NULL
&& !bdrv_chain_contains(backing_bs(old
), new)) {
2107 bdrv_set_backing_hd(new, backing_bs(old
));
2108 bdrv_set_backing_hd(old
, NULL
);
2114 static void bdrv_delete(BlockDriverState
*bs
)
2117 assert(bdrv_op_blocker_is_empty(bs
));
2118 assert(!bs
->refcnt
);
2119 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2123 /* remove from list, if necessary */
2130 * Run consistency checks on an image
2132 * Returns 0 if the check could be completed (it doesn't mean that the image is
2133 * free of errors) or -errno when an internal error occurred. The results of the
2134 * check are stored in res.
2136 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2138 if (bs
->drv
== NULL
) {
2141 if (bs
->drv
->bdrv_check
== NULL
) {
2145 memset(res
, 0, sizeof(*res
));
2146 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2149 #define COMMIT_BUF_SECTORS 2048
2151 /* commit COW file into the raw image */
2152 int bdrv_commit(BlockDriverState
*bs
)
2154 BlockDriver
*drv
= bs
->drv
;
2155 int64_t sector
, total_sectors
, length
, backing_length
;
2156 int n
, ro
, open_flags
;
2158 uint8_t *buf
= NULL
;
2167 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2168 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2172 ro
= bs
->backing
->bs
->read_only
;
2173 open_flags
= bs
->backing
->bs
->open_flags
;
2176 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2181 length
= bdrv_getlength(bs
);
2187 backing_length
= bdrv_getlength(bs
->backing
->bs
);
2188 if (backing_length
< 0) {
2189 ret
= backing_length
;
2193 /* If our top snapshot is larger than the backing file image,
2194 * grow the backing file image if possible. If not possible,
2195 * we must return an error */
2196 if (length
> backing_length
) {
2197 ret
= bdrv_truncate(bs
->backing
->bs
, length
);
2203 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2205 /* qemu_try_blockalign() for bs will choose an alignment that works for
2206 * bs->backing->bs as well, so no need to compare the alignment manually. */
2207 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2213 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2214 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2219 ret
= bdrv_read(bs
, sector
, buf
, n
);
2224 ret
= bdrv_write(bs
->backing
->bs
, sector
, buf
, n
);
2231 if (drv
->bdrv_make_empty
) {
2232 ret
= drv
->bdrv_make_empty(bs
);
2240 * Make sure all data we wrote to the backing device is actually
2244 bdrv_flush(bs
->backing
->bs
);
2252 /* ignoring error return here */
2253 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2259 int bdrv_commit_all(void)
2261 BlockDriverState
*bs
;
2263 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2264 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2266 aio_context_acquire(aio_context
);
2267 if (bs
->drv
&& bs
->backing
) {
2268 int ret
= bdrv_commit(bs
);
2270 aio_context_release(aio_context
);
2274 aio_context_release(aio_context
);
2282 * -EINVAL - backing format specified, but no file
2283 * -ENOSPC - can't update the backing file because no space is left in the
2285 * -ENOTSUP - format driver doesn't support changing the backing file
2287 int bdrv_change_backing_file(BlockDriverState
*bs
,
2288 const char *backing_file
, const char *backing_fmt
)
2290 BlockDriver
*drv
= bs
->drv
;
2293 /* Backing file format doesn't make sense without a backing file */
2294 if (backing_fmt
&& !backing_file
) {
2298 if (drv
->bdrv_change_backing_file
!= NULL
) {
2299 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2305 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2306 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2312 * Finds the image layer in the chain that has 'bs' as its backing file.
2314 * active is the current topmost image.
2316 * Returns NULL if bs is not found in active's image chain,
2317 * or if active == bs.
2319 * Returns the bottommost base image if bs == NULL.
2321 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2322 BlockDriverState
*bs
)
2324 while (active
&& bs
!= backing_bs(active
)) {
2325 active
= backing_bs(active
);
2331 /* Given a BDS, searches for the base layer. */
2332 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2334 return bdrv_find_overlay(bs
, NULL
);
2338 * Drops images above 'base' up to and including 'top', and sets the image
2339 * above 'top' to have base as its backing file.
2341 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2342 * information in 'bs' can be properly updated.
2344 * E.g., this will convert the following chain:
2345 * bottom <- base <- intermediate <- top <- active
2349 * bottom <- base <- active
2351 * It is allowed for bottom==base, in which case it converts:
2353 * base <- intermediate <- top <- active
2359 * If backing_file_str is non-NULL, it will be used when modifying top's
2360 * overlay image metadata.
2363 * if active == top, that is considered an error
2366 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2367 BlockDriverState
*base
, const char *backing_file_str
)
2369 BlockDriverState
*new_top_bs
= NULL
;
2372 if (!top
->drv
|| !base
->drv
) {
2376 new_top_bs
= bdrv_find_overlay(active
, top
);
2378 if (new_top_bs
== NULL
) {
2379 /* we could not find the image above 'top', this is an error */
2383 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2384 * to do, no intermediate images */
2385 if (backing_bs(new_top_bs
) == base
) {
2390 /* Make sure that base is in the backing chain of top */
2391 if (!bdrv_chain_contains(top
, base
)) {
2395 /* success - we can delete the intermediate states, and link top->base */
2396 backing_file_str
= backing_file_str
? backing_file_str
: base
->filename
;
2397 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2398 base
->drv
? base
->drv
->format_name
: "");
2402 bdrv_set_backing_hd(new_top_bs
, base
);
2410 * Truncate file to 'offset' bytes (needed only for file protocols)
2412 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2414 BlockDriver
*drv
= bs
->drv
;
2418 if (!drv
->bdrv_truncate
)
2423 ret
= drv
->bdrv_truncate(bs
, offset
);
2425 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2426 bdrv_dirty_bitmap_truncate(bs
);
2428 blk_dev_resize_cb(bs
->blk
);
2435 * Length of a allocated file in bytes. Sparse files are counted by actual
2436 * allocated space. Return < 0 if error or unknown.
2438 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2440 BlockDriver
*drv
= bs
->drv
;
2444 if (drv
->bdrv_get_allocated_file_size
) {
2445 return drv
->bdrv_get_allocated_file_size(bs
);
2448 return bdrv_get_allocated_file_size(bs
->file
->bs
);
2454 * Return number of sectors on success, -errno on error.
2456 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2458 BlockDriver
*drv
= bs
->drv
;
2463 if (drv
->has_variable_length
) {
2464 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2469 return bs
->total_sectors
;
2473 * Return length in bytes on success, -errno on error.
2474 * The length is always a multiple of BDRV_SECTOR_SIZE.
2476 int64_t bdrv_getlength(BlockDriverState
*bs
)
2478 int64_t ret
= bdrv_nb_sectors(bs
);
2480 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2481 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2484 /* return 0 as number of sectors if no device present or error */
2485 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2487 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2489 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2492 int bdrv_is_read_only(BlockDriverState
*bs
)
2494 return bs
->read_only
;
2497 int bdrv_is_sg(BlockDriverState
*bs
)
2502 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2504 return bs
->enable_write_cache
;
2507 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2509 bs
->enable_write_cache
= wce
;
2511 /* so a reopen() will preserve wce */
2513 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2515 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2519 int bdrv_is_encrypted(BlockDriverState
*bs
)
2521 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2524 return bs
->encrypted
;
2527 int bdrv_key_required(BlockDriverState
*bs
)
2529 BdrvChild
*backing
= bs
->backing
;
2531 if (backing
&& backing
->bs
->encrypted
&& !backing
->bs
->valid_key
) {
2534 return (bs
->encrypted
&& !bs
->valid_key
);
2537 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2540 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2541 ret
= bdrv_set_key(bs
->backing
->bs
, key
);
2547 if (!bs
->encrypted
) {
2549 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2552 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2555 } else if (!bs
->valid_key
) {
2558 /* call the change callback now, we skipped it on open */
2559 blk_dev_change_media_cb(bs
->blk
, true);
2566 * Provide an encryption key for @bs.
2567 * If @key is non-null:
2568 * If @bs is not encrypted, fail.
2569 * Else if the key is invalid, fail.
2570 * Else set @bs's key to @key, replacing the existing key, if any.
2572 * If @bs is encrypted and still lacks a key, fail.
2574 * On failure, store an error object through @errp if non-null.
2576 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2579 if (!bdrv_is_encrypted(bs
)) {
2580 error_setg(errp
, "Node '%s' is not encrypted",
2581 bdrv_get_device_or_node_name(bs
));
2582 } else if (bdrv_set_key(bs
, key
) < 0) {
2583 error_setg(errp
, QERR_INVALID_PASSWORD
);
2586 if (bdrv_key_required(bs
)) {
2587 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2588 "'%s' (%s) is encrypted",
2589 bdrv_get_device_or_node_name(bs
),
2590 bdrv_get_encrypted_filename(bs
));
2595 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2597 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2600 static int qsort_strcmp(const void *a
, const void *b
)
2602 return strcmp(a
, b
);
2605 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2611 const char **formats
= NULL
;
2613 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2614 if (drv
->format_name
) {
2617 while (formats
&& i
&& !found
) {
2618 found
= !strcmp(formats
[--i
], drv
->format_name
);
2622 formats
= g_renew(const char *, formats
, count
+ 1);
2623 formats
[count
++] = drv
->format_name
;
2628 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2630 for (i
= 0; i
< count
; i
++) {
2631 it(opaque
, formats
[i
]);
2637 /* This function is to find a node in the bs graph */
2638 BlockDriverState
*bdrv_find_node(const char *node_name
)
2640 BlockDriverState
*bs
;
2644 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2645 if (!strcmp(node_name
, bs
->node_name
)) {
2652 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2653 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2655 BlockDeviceInfoList
*list
, *entry
;
2656 BlockDriverState
*bs
;
2659 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2660 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2662 qapi_free_BlockDeviceInfoList(list
);
2665 entry
= g_malloc0(sizeof(*entry
));
2666 entry
->value
= info
;
2674 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2675 const char *node_name
,
2679 BlockDriverState
*bs
;
2682 blk
= blk_by_name(device
);
2687 error_setg(errp
, "Device '%s' has no medium", device
);
2695 bs
= bdrv_find_node(node_name
);
2702 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2703 device
? device
: "",
2704 node_name
? node_name
: "");
2708 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2709 * return false. If either argument is NULL, return false. */
2710 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2712 while (top
&& top
!= base
) {
2713 top
= backing_bs(top
);
2719 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2722 return QTAILQ_FIRST(&graph_bdrv_states
);
2724 return QTAILQ_NEXT(bs
, node_list
);
2727 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2730 return QTAILQ_FIRST(&bdrv_states
);
2732 return QTAILQ_NEXT(bs
, device_list
);
2735 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2737 return bs
->node_name
;
2740 /* TODO check what callers really want: bs->node_name or blk_name() */
2741 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2743 return bs
->blk
? blk_name(bs
->blk
) : "";
2746 /* This can be used to identify nodes that might not have a device
2747 * name associated. Since node and device names live in the same
2748 * namespace, the result is unambiguous. The exception is if both are
2749 * absent, then this returns an empty (non-null) string. */
2750 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2752 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2755 int bdrv_get_flags(BlockDriverState
*bs
)
2757 return bs
->open_flags
;
2760 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2765 int bdrv_has_zero_init(BlockDriverState
*bs
)
2769 /* If BS is a copy on write image, it is initialized to
2770 the contents of the base image, which may not be zeroes. */
2774 if (bs
->drv
->bdrv_has_zero_init
) {
2775 return bs
->drv
->bdrv_has_zero_init(bs
);
2782 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2784 BlockDriverInfo bdi
;
2790 if (bdrv_get_info(bs
, &bdi
) == 0) {
2791 return bdi
.unallocated_blocks_are_zero
;
2797 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2799 BlockDriverInfo bdi
;
2801 if (bs
->backing
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2805 if (bdrv_get_info(bs
, &bdi
) == 0) {
2806 return bdi
.can_write_zeroes_with_unmap
;
2812 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2814 if (bs
->backing
&& bs
->backing
->bs
->encrypted
)
2815 return bs
->backing_file
;
2816 else if (bs
->encrypted
)
2817 return bs
->filename
;
2822 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2823 char *filename
, int filename_size
)
2825 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2828 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2830 BlockDriver
*drv
= bs
->drv
;
2833 if (!drv
->bdrv_get_info
)
2835 memset(bdi
, 0, sizeof(*bdi
));
2836 return drv
->bdrv_get_info(bs
, bdi
);
2839 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2841 BlockDriver
*drv
= bs
->drv
;
2842 if (drv
&& drv
->bdrv_get_specific_info
) {
2843 return drv
->bdrv_get_specific_info(bs
);
2848 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2850 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
2854 bs
->drv
->bdrv_debug_event(bs
, event
);
2857 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
2860 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
2861 bs
= bs
->file
? bs
->file
->bs
: NULL
;
2864 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
2865 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
2871 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
2873 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
2874 bs
= bs
->file
? bs
->file
->bs
: NULL
;
2877 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
2878 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
2884 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
2886 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
2887 bs
= bs
->file
? bs
->file
->bs
: NULL
;
2890 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
2891 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
2897 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
2899 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
2900 bs
= bs
->file
? bs
->file
->bs
: NULL
;
2903 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
2904 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
2910 int bdrv_is_snapshot(BlockDriverState
*bs
)
2912 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2915 /* backing_file can either be relative, or absolute, or a protocol. If it is
2916 * relative, it must be relative to the chain. So, passing in bs->filename
2917 * from a BDS as backing_file should not be done, as that may be relative to
2918 * the CWD rather than the chain. */
2919 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2920 const char *backing_file
)
2922 char *filename_full
= NULL
;
2923 char *backing_file_full
= NULL
;
2924 char *filename_tmp
= NULL
;
2925 int is_protocol
= 0;
2926 BlockDriverState
*curr_bs
= NULL
;
2927 BlockDriverState
*retval
= NULL
;
2929 if (!bs
|| !bs
->drv
|| !backing_file
) {
2933 filename_full
= g_malloc(PATH_MAX
);
2934 backing_file_full
= g_malloc(PATH_MAX
);
2935 filename_tmp
= g_malloc(PATH_MAX
);
2937 is_protocol
= path_has_protocol(backing_file
);
2939 for (curr_bs
= bs
; curr_bs
->backing
; curr_bs
= curr_bs
->backing
->bs
) {
2941 /* If either of the filename paths is actually a protocol, then
2942 * compare unmodified paths; otherwise make paths relative */
2943 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
2944 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
2945 retval
= curr_bs
->backing
->bs
;
2949 /* If not an absolute filename path, make it relative to the current
2950 * image's filename path */
2951 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2954 /* We are going to compare absolute pathnames */
2955 if (!realpath(filename_tmp
, filename_full
)) {
2959 /* We need to make sure the backing filename we are comparing against
2960 * is relative to the current image filename (or absolute) */
2961 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2962 curr_bs
->backing_file
);
2964 if (!realpath(filename_tmp
, backing_file_full
)) {
2968 if (strcmp(backing_file_full
, filename_full
) == 0) {
2969 retval
= curr_bs
->backing
->bs
;
2975 g_free(filename_full
);
2976 g_free(backing_file_full
);
2977 g_free(filename_tmp
);
2981 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
2991 return 1 + bdrv_get_backing_file_depth(bs
->backing
->bs
);
2994 void bdrv_init(void)
2996 module_call_init(MODULE_INIT_BLOCK
);
2999 void bdrv_init_with_whitelist(void)
3001 use_bdrv_whitelist
= 1;
3005 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3007 Error
*local_err
= NULL
;
3014 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
3017 bs
->open_flags
&= ~BDRV_O_INCOMING
;
3019 if (bs
->drv
->bdrv_invalidate_cache
) {
3020 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3021 } else if (bs
->file
) {
3022 bdrv_invalidate_cache(bs
->file
->bs
, &local_err
);
3025 error_propagate(errp
, local_err
);
3029 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3031 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3036 void bdrv_invalidate_cache_all(Error
**errp
)
3038 BlockDriverState
*bs
;
3039 Error
*local_err
= NULL
;
3041 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3042 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3044 aio_context_acquire(aio_context
);
3045 bdrv_invalidate_cache(bs
, &local_err
);
3046 aio_context_release(aio_context
);
3048 error_propagate(errp
, local_err
);
3054 /**************************************************************/
3055 /* removable device support */
3058 * Return TRUE if the media is present
3060 bool bdrv_is_inserted(BlockDriverState
*bs
)
3062 BlockDriver
*drv
= bs
->drv
;
3068 if (drv
->bdrv_is_inserted
) {
3069 return drv
->bdrv_is_inserted(bs
);
3071 QLIST_FOREACH(child
, &bs
->children
, next
) {
3072 if (!bdrv_is_inserted(child
->bs
)) {
3080 * Return whether the media changed since the last call to this
3081 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3083 int bdrv_media_changed(BlockDriverState
*bs
)
3085 BlockDriver
*drv
= bs
->drv
;
3087 if (drv
&& drv
->bdrv_media_changed
) {
3088 return drv
->bdrv_media_changed(bs
);
3094 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3096 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3098 BlockDriver
*drv
= bs
->drv
;
3099 const char *device_name
;
3101 if (drv
&& drv
->bdrv_eject
) {
3102 drv
->bdrv_eject(bs
, eject_flag
);
3105 device_name
= bdrv_get_device_name(bs
);
3106 if (device_name
[0] != '\0') {
3107 qapi_event_send_device_tray_moved(device_name
,
3108 eject_flag
, &error_abort
);
3113 * Lock or unlock the media (if it is locked, the user won't be able
3114 * to eject it manually).
3116 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3118 BlockDriver
*drv
= bs
->drv
;
3120 trace_bdrv_lock_medium(bs
, locked
);
3122 if (drv
&& drv
->bdrv_lock_medium
) {
3123 drv
->bdrv_lock_medium(bs
, locked
);
3127 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3129 BdrvDirtyBitmap
*bm
;
3132 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3133 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3140 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3142 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3143 g_free(bitmap
->name
);
3144 bitmap
->name
= NULL
;
3147 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3148 uint32_t granularity
,
3152 int64_t bitmap_size
;
3153 BdrvDirtyBitmap
*bitmap
;
3154 uint32_t sector_granularity
;
3156 assert((granularity
& (granularity
- 1)) == 0);
3158 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3159 error_setg(errp
, "Bitmap already exists: %s", name
);
3162 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3163 assert(sector_granularity
);
3164 bitmap_size
= bdrv_nb_sectors(bs
);
3165 if (bitmap_size
< 0) {
3166 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3167 errno
= -bitmap_size
;
3170 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3171 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3172 bitmap
->size
= bitmap_size
;
3173 bitmap
->name
= g_strdup(name
);
3174 bitmap
->disabled
= false;
3175 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3179 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3181 return bitmap
->successor
;
3184 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3186 return !(bitmap
->disabled
|| bitmap
->successor
);
3189 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3191 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3192 return DIRTY_BITMAP_STATUS_FROZEN
;
3193 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3194 return DIRTY_BITMAP_STATUS_DISABLED
;
3196 return DIRTY_BITMAP_STATUS_ACTIVE
;
3201 * Create a successor bitmap destined to replace this bitmap after an operation.
3202 * Requires that the bitmap is not frozen and has no successor.
3204 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3205 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3207 uint64_t granularity
;
3208 BdrvDirtyBitmap
*child
;
3210 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3211 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3212 "currently frozen");
3215 assert(!bitmap
->successor
);
3217 /* Create an anonymous successor */
3218 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3219 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3224 /* Successor will be on or off based on our current state. */
3225 child
->disabled
= bitmap
->disabled
;
3227 /* Install the successor and freeze the parent */
3228 bitmap
->successor
= child
;
3233 * For a bitmap with a successor, yield our name to the successor,
3234 * delete the old bitmap, and return a handle to the new bitmap.
3236 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3237 BdrvDirtyBitmap
*bitmap
,
3241 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3243 if (successor
== NULL
) {
3244 error_setg(errp
, "Cannot relinquish control if "
3245 "there's no successor present");
3249 name
= bitmap
->name
;
3250 bitmap
->name
= NULL
;
3251 successor
->name
= name
;
3252 bitmap
->successor
= NULL
;
3253 bdrv_release_dirty_bitmap(bs
, bitmap
);
3259 * In cases of failure where we can no longer safely delete the parent,
3260 * we may wish to re-join the parent and child/successor.
3261 * The merged parent will be un-frozen, but not explicitly re-enabled.
3263 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3264 BdrvDirtyBitmap
*parent
,
3267 BdrvDirtyBitmap
*successor
= parent
->successor
;
3270 error_setg(errp
, "Cannot reclaim a successor when none is present");
3274 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3275 error_setg(errp
, "Merging of parent and successor bitmap failed");
3278 bdrv_release_dirty_bitmap(bs
, successor
);
3279 parent
->successor
= NULL
;
3285 * Truncates _all_ bitmaps attached to a BDS.
3287 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3289 BdrvDirtyBitmap
*bitmap
;
3290 uint64_t size
= bdrv_nb_sectors(bs
);
3292 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3293 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3294 hbitmap_truncate(bitmap
->bitmap
, size
);
3295 bitmap
->size
= size
;
3299 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3301 BdrvDirtyBitmap
*bm
, *next
;
3302 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3304 assert(!bdrv_dirty_bitmap_frozen(bm
));
3305 QLIST_REMOVE(bitmap
, list
);
3306 hbitmap_free(bitmap
->bitmap
);
3307 g_free(bitmap
->name
);
3314 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3316 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3317 bitmap
->disabled
= true;
3320 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3322 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3323 bitmap
->disabled
= false;
3326 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3328 BdrvDirtyBitmap
*bm
;
3329 BlockDirtyInfoList
*list
= NULL
;
3330 BlockDirtyInfoList
**plist
= &list
;
3332 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3333 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3334 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3335 info
->count
= bdrv_get_dirty_count(bm
);
3336 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3337 info
->has_name
= !!bm
->name
;
3338 info
->name
= g_strdup(bm
->name
);
3339 info
->status
= bdrv_dirty_bitmap_status(bm
);
3340 entry
->value
= info
;
3342 plist
= &entry
->next
;
3348 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3351 return hbitmap_get(bitmap
->bitmap
, sector
);
3358 * Chooses a default granularity based on the existing cluster size,
3359 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3360 * is no cluster size information available.
3362 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3364 BlockDriverInfo bdi
;
3365 uint32_t granularity
;
3367 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3368 granularity
= MAX(4096, bdi
.cluster_size
);
3369 granularity
= MIN(65536, granularity
);
3371 granularity
= 65536;
3377 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3379 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3382 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3384 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3387 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3388 int64_t cur_sector
, int nr_sectors
)
3390 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3391 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3394 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3395 int64_t cur_sector
, int nr_sectors
)
3397 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3398 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3401 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3403 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3404 hbitmap_reset_all(bitmap
->bitmap
);
3407 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3410 BdrvDirtyBitmap
*bitmap
;
3411 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3412 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3415 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3420 * Advance an HBitmapIter to an arbitrary offset.
3422 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3425 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3428 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3430 return hbitmap_count(bitmap
->bitmap
);
3433 /* Get a reference to bs */
3434 void bdrv_ref(BlockDriverState
*bs
)
3439 /* Release a previously grabbed reference to bs.
3440 * If after releasing, reference count is zero, the BlockDriverState is
3442 void bdrv_unref(BlockDriverState
*bs
)
3447 assert(bs
->refcnt
> 0);
3448 if (--bs
->refcnt
== 0) {
3453 struct BdrvOpBlocker
{
3455 QLIST_ENTRY(BdrvOpBlocker
) list
;
3458 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3460 BdrvOpBlocker
*blocker
;
3461 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3462 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3463 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3465 error_setg(errp
, "Node '%s' is busy: %s",
3466 bdrv_get_device_or_node_name(bs
),
3467 error_get_pretty(blocker
->reason
));
3474 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3476 BdrvOpBlocker
*blocker
;
3477 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3479 blocker
= g_new0(BdrvOpBlocker
, 1);
3480 blocker
->reason
= reason
;
3481 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3484 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3486 BdrvOpBlocker
*blocker
, *next
;
3487 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3488 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3489 if (blocker
->reason
== reason
) {
3490 QLIST_REMOVE(blocker
, list
);
3496 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3499 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3500 bdrv_op_block(bs
, i
, reason
);
3504 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3507 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3508 bdrv_op_unblock(bs
, i
, reason
);
3512 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3516 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3517 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3524 void bdrv_img_create(const char *filename
, const char *fmt
,
3525 const char *base_filename
, const char *base_fmt
,
3526 char *options
, uint64_t img_size
, int flags
,
3527 Error
**errp
, bool quiet
)
3529 QemuOptsList
*create_opts
= NULL
;
3530 QemuOpts
*opts
= NULL
;
3531 const char *backing_fmt
, *backing_file
;
3533 BlockDriver
*drv
, *proto_drv
;
3534 Error
*local_err
= NULL
;
3537 /* Find driver and parse its options */
3538 drv
= bdrv_find_format(fmt
);
3540 error_setg(errp
, "Unknown file format '%s'", fmt
);
3544 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3549 if (!drv
->create_opts
) {
3550 error_setg(errp
, "Format driver '%s' does not support image creation",
3555 if (!proto_drv
->create_opts
) {
3556 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3557 proto_drv
->format_name
);
3561 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3562 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3564 /* Create parameter list with default values */
3565 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3566 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3568 /* Parse -o options */
3570 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3572 error_report_err(local_err
);
3574 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3579 if (base_filename
) {
3580 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3582 error_setg(errp
, "Backing file not supported for file format '%s'",
3589 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3591 error_setg(errp
, "Backing file format not supported for file "
3592 "format '%s'", fmt
);
3597 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3599 if (!strcmp(filename
, backing_file
)) {
3600 error_setg(errp
, "Error: Trying to create an image with the "
3601 "same filename as the backing file");
3606 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3608 // The size for the image must always be specified, with one exception:
3609 // If we are using a backing file, we can obtain the size from there
3610 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3613 BlockDriverState
*bs
;
3614 char *full_backing
= g_new0(char, PATH_MAX
);
3617 QDict
*backing_options
= NULL
;
3619 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3620 full_backing
, PATH_MAX
,
3623 g_free(full_backing
);
3627 /* backing files always opened read-only */
3629 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3632 backing_options
= qdict_new();
3633 qdict_put(backing_options
, "driver",
3634 qstring_from_str(backing_fmt
));
3638 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3639 back_flags
, &local_err
);
3640 g_free(full_backing
);
3644 size
= bdrv_getlength(bs
);
3646 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3652 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3656 error_setg(errp
, "Image creation needs a size parameter");
3662 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3663 qemu_opts_print(opts
, " ");
3667 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3669 if (ret
== -EFBIG
) {
3670 /* This is generally a better message than whatever the driver would
3671 * deliver (especially because of the cluster_size_hint), since that
3672 * is most probably not much different from "image too large". */
3673 const char *cluster_size_hint
= "";
3674 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3675 cluster_size_hint
= " (try using a larger cluster size)";
3677 error_setg(errp
, "The image size is too large for file format '%s'"
3678 "%s", fmt
, cluster_size_hint
);
3679 error_free(local_err
);
3684 qemu_opts_del(opts
);
3685 qemu_opts_free(create_opts
);
3687 error_propagate(errp
, local_err
);
3691 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3693 return bs
->aio_context
;
3696 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3698 BdrvAioNotifier
*baf
;
3704 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3705 baf
->detach_aio_context(baf
->opaque
);
3708 if (bs
->io_limits_enabled
) {
3709 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3711 if (bs
->drv
->bdrv_detach_aio_context
) {
3712 bs
->drv
->bdrv_detach_aio_context(bs
);
3715 bdrv_detach_aio_context(bs
->file
->bs
);
3718 bdrv_detach_aio_context(bs
->backing
->bs
);
3721 bs
->aio_context
= NULL
;
3724 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3725 AioContext
*new_context
)
3727 BdrvAioNotifier
*ban
;
3733 bs
->aio_context
= new_context
;
3736 bdrv_attach_aio_context(bs
->backing
->bs
, new_context
);
3739 bdrv_attach_aio_context(bs
->file
->bs
, new_context
);
3741 if (bs
->drv
->bdrv_attach_aio_context
) {
3742 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3744 if (bs
->io_limits_enabled
) {
3745 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3748 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3749 ban
->attached_aio_context(new_context
, ban
->opaque
);
3753 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3755 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3757 bdrv_detach_aio_context(bs
);
3759 /* This function executes in the old AioContext so acquire the new one in
3760 * case it runs in a different thread.
3762 aio_context_acquire(new_context
);
3763 bdrv_attach_aio_context(bs
, new_context
);
3764 aio_context_release(new_context
);
3767 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3768 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3769 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3771 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3772 *ban
= (BdrvAioNotifier
){
3773 .attached_aio_context
= attached_aio_context
,
3774 .detach_aio_context
= detach_aio_context
,
3778 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3781 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3782 void (*attached_aio_context
)(AioContext
*,
3784 void (*detach_aio_context
)(void *),
3787 BdrvAioNotifier
*ban
, *ban_next
;
3789 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3790 if (ban
->attached_aio_context
== attached_aio_context
&&
3791 ban
->detach_aio_context
== detach_aio_context
&&
3792 ban
->opaque
== opaque
)
3794 QLIST_REMOVE(ban
, list
);
3804 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3805 BlockDriverAmendStatusCB
*status_cb
)
3807 if (!bs
->drv
->bdrv_amend_options
) {
3810 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3813 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3814 * of block filter and by bdrv_is_first_non_filter.
3815 * It is used to test if the given bs is the candidate or recurse more in the
3818 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3819 BlockDriverState
*candidate
)
3821 /* return false if basic checks fails */
3822 if (!bs
|| !bs
->drv
) {
3826 /* the code reached a non block filter driver -> check if the bs is
3827 * the same as the candidate. It's the recursion termination condition.
3829 if (!bs
->drv
->is_filter
) {
3830 return bs
== candidate
;
3832 /* Down this path the driver is a block filter driver */
3834 /* If the block filter recursion method is defined use it to recurse down
3837 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
3838 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
3841 /* the driver is a block filter but don't allow to recurse -> return false
3846 /* This function checks if the candidate is the first non filter bs down it's
3847 * bs chain. Since we don't have pointers to parents it explore all bs chains
3848 * from the top. Some filters can choose not to pass down the recursion.
3850 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
3852 BlockDriverState
*bs
;
3854 /* walk down the bs forest recursively */
3855 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3858 /* try to recurse in this top level bs */
3859 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
3861 /* candidate is the first non filter */
3870 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
3871 const char *node_name
, Error
**errp
)
3873 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
3874 AioContext
*aio_context
;
3876 if (!to_replace_bs
) {
3877 error_setg(errp
, "Node name '%s' not found", node_name
);
3881 aio_context
= bdrv_get_aio_context(to_replace_bs
);
3882 aio_context_acquire(aio_context
);
3884 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
3885 to_replace_bs
= NULL
;
3889 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3890 * most non filter in order to prevent data corruption.
3891 * Another benefit is that this tests exclude backing files which are
3892 * blocked by the backing blockers.
3894 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
3895 error_setg(errp
, "Only top most non filter can be replaced");
3896 to_replace_bs
= NULL
;
3901 aio_context_release(aio_context
);
3902 return to_replace_bs
;
3905 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
3907 const QDictEntry
*entry
;
3908 bool found_any
= false;
3910 for (entry
= qdict_first(bs
->options
); entry
;
3911 entry
= qdict_next(bs
->options
, entry
))
3913 /* Only take options for this level and exclude all non-driver-specific
3915 if (!strchr(qdict_entry_key(entry
), '.') &&
3916 strcmp(qdict_entry_key(entry
), "node-name"))
3918 qobject_incref(qdict_entry_value(entry
));
3919 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
3927 /* Updates the following BDS fields:
3928 * - exact_filename: A filename which may be used for opening a block device
3929 * which (mostly) equals the given BDS (even without any
3930 * other options; so reading and writing must return the same
3931 * results, but caching etc. may be different)
3932 * - full_open_options: Options which, when given when opening a block device
3933 * (without a filename), result in a BDS (mostly)
3934 * equalling the given one
3935 * - filename: If exact_filename is set, it is copied here. Otherwise,
3936 * full_open_options is converted to a JSON object, prefixed with
3937 * "json:" (for use through the JSON pseudo protocol) and put here.
3939 void bdrv_refresh_filename(BlockDriverState
*bs
)
3941 BlockDriver
*drv
= bs
->drv
;
3948 /* This BDS's file name will most probably depend on its file's name, so
3949 * refresh that first */
3951 bdrv_refresh_filename(bs
->file
->bs
);
3954 if (drv
->bdrv_refresh_filename
) {
3955 /* Obsolete information is of no use here, so drop the old file name
3956 * information before refreshing it */
3957 bs
->exact_filename
[0] = '\0';
3958 if (bs
->full_open_options
) {
3959 QDECREF(bs
->full_open_options
);
3960 bs
->full_open_options
= NULL
;
3963 drv
->bdrv_refresh_filename(bs
);
3964 } else if (bs
->file
) {
3965 /* Try to reconstruct valid information from the underlying file */
3966 bool has_open_options
;
3968 bs
->exact_filename
[0] = '\0';
3969 if (bs
->full_open_options
) {
3970 QDECREF(bs
->full_open_options
);
3971 bs
->full_open_options
= NULL
;
3975 has_open_options
= append_open_options(opts
, bs
);
3977 /* If no specific options have been given for this BDS, the filename of
3978 * the underlying file should suffice for this one as well */
3979 if (bs
->file
->bs
->exact_filename
[0] && !has_open_options
) {
3980 strcpy(bs
->exact_filename
, bs
->file
->bs
->exact_filename
);
3982 /* Reconstructing the full options QDict is simple for most format block
3983 * drivers, as long as the full options are known for the underlying
3984 * file BDS. The full options QDict of that file BDS should somehow
3985 * contain a representation of the filename, therefore the following
3986 * suffices without querying the (exact_)filename of this BDS. */
3987 if (bs
->file
->bs
->full_open_options
) {
3988 qdict_put_obj(opts
, "driver",
3989 QOBJECT(qstring_from_str(drv
->format_name
)));
3990 QINCREF(bs
->file
->bs
->full_open_options
);
3991 qdict_put_obj(opts
, "file",
3992 QOBJECT(bs
->file
->bs
->full_open_options
));
3994 bs
->full_open_options
= opts
;
3998 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
3999 /* There is no underlying file BDS (at least referenced by BDS.file),
4000 * so the full options QDict should be equal to the options given
4001 * specifically for this block device when it was opened (plus the
4002 * driver specification).
4003 * Because those options don't change, there is no need to update
4004 * full_open_options when it's already set. */
4007 append_open_options(opts
, bs
);
4008 qdict_put_obj(opts
, "driver",
4009 QOBJECT(qstring_from_str(drv
->format_name
)));
4011 if (bs
->exact_filename
[0]) {
4012 /* This may not work for all block protocol drivers (some may
4013 * require this filename to be parsed), but we have to find some
4014 * default solution here, so just include it. If some block driver
4015 * does not support pure options without any filename at all or
4016 * needs some special format of the options QDict, it needs to
4017 * implement the driver-specific bdrv_refresh_filename() function.
4019 qdict_put_obj(opts
, "filename",
4020 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4023 bs
->full_open_options
= opts
;
4026 if (bs
->exact_filename
[0]) {
4027 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4028 } else if (bs
->full_open_options
) {
4029 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4030 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4031 qstring_get_str(json
));