2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
39 #include "block/throttle-groups.h"
42 #include <sys/types.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
56 * A BdrvDirtyBitmap can be in three possible states:
57 * (1) successor is NULL and disabled is false: full r/w mode
58 * (2) successor is NULL and disabled is true: read only mode ("disabled")
59 * (3) successor is set: frozen mode.
60 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
61 * or enabled. A frozen bitmap can only abdicate() or reclaim().
63 struct BdrvDirtyBitmap
{
64 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
65 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
66 char *name
; /* Optional non-empty unique ID */
67 int64_t size
; /* Size of the bitmap (Number of sectors) */
68 bool disabled
; /* Bitmap is read-only */
69 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
72 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
74 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
75 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
77 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
78 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
80 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
81 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
83 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
84 /* If non-zero, use only whitelisted block drivers */
85 static int use_bdrv_whitelist
;
88 static int is_windows_drive_prefix(const char *filename
)
90 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
91 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
95 int is_windows_drive(const char *filename
)
97 if (is_windows_drive_prefix(filename
) &&
100 if (strstart(filename
, "\\\\.\\", NULL
) ||
101 strstart(filename
, "//./", NULL
))
107 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
109 if (!bs
|| !bs
->drv
) {
110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
114 return bs
->bl
.opt_mem_alignment
;
117 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
119 if (!bs
|| !bs
->drv
) {
120 /* page size or 4k (hdd sector size) should be on the safe side */
121 return MAX(4096, getpagesize());
124 return bs
->bl
.min_mem_alignment
;
127 /* check if the path starts with "<protocol>:" */
128 int path_has_protocol(const char *path
)
133 if (is_windows_drive(path
) ||
134 is_windows_drive_prefix(path
)) {
137 p
= path
+ strcspn(path
, ":/\\");
139 p
= path
+ strcspn(path
, ":/");
145 int path_is_absolute(const char *path
)
148 /* specific case for names like: "\\.\d:" */
149 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
152 return (*path
== '/' || *path
== '\\');
154 return (*path
== '/');
158 /* if filename is absolute, just copy it to dest. Otherwise, build a
159 path to it by considering it is relative to base_path. URL are
161 void path_combine(char *dest
, int dest_size
,
162 const char *base_path
,
163 const char *filename
)
170 if (path_is_absolute(filename
)) {
171 pstrcpy(dest
, dest_size
, filename
);
173 p
= strchr(base_path
, ':');
178 p1
= strrchr(base_path
, '/');
182 p2
= strrchr(base_path
, '\\');
194 if (len
> dest_size
- 1)
196 memcpy(dest
, base_path
, len
);
198 pstrcat(dest
, dest_size
, filename
);
202 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
204 char *dest
, size_t sz
,
207 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
208 path_is_absolute(backing
))
210 pstrcpy(dest
, sz
, backing
);
211 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
212 error_setg(errp
, "Cannot use relative backing file names for '%s'",
215 path_combine(dest
, sz
, backed
, backing
);
219 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
222 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
224 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
228 void bdrv_register(BlockDriver
*bdrv
)
230 bdrv_setup_io_funcs(bdrv
);
232 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
235 BlockDriverState
*bdrv_new_root(void)
237 BlockDriverState
*bs
= bdrv_new();
239 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
243 BlockDriverState
*bdrv_new(void)
245 BlockDriverState
*bs
;
248 bs
= g_new0(BlockDriverState
, 1);
249 QLIST_INIT(&bs
->dirty_bitmaps
);
250 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
251 QLIST_INIT(&bs
->op_blockers
[i
]);
253 bdrv_iostatus_disable(bs
);
254 notifier_list_init(&bs
->close_notifiers
);
255 notifier_with_return_list_init(&bs
->before_write_notifiers
);
256 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
257 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
259 bs
->aio_context
= qemu_get_aio_context();
264 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
266 notifier_list_add(&bs
->close_notifiers
, notify
);
269 BlockDriver
*bdrv_find_format(const char *format_name
)
272 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
273 if (!strcmp(drv1
->format_name
, format_name
)) {
280 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
282 static const char *whitelist_rw
[] = {
283 CONFIG_BDRV_RW_WHITELIST
285 static const char *whitelist_ro
[] = {
286 CONFIG_BDRV_RO_WHITELIST
290 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
291 return 1; /* no whitelist, anything goes */
294 for (p
= whitelist_rw
; *p
; p
++) {
295 if (!strcmp(drv
->format_name
, *p
)) {
300 for (p
= whitelist_ro
; *p
; p
++) {
301 if (!strcmp(drv
->format_name
, *p
)) {
309 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
312 BlockDriver
*drv
= bdrv_find_format(format_name
);
313 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
316 typedef struct CreateCo
{
324 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
326 Error
*local_err
= NULL
;
329 CreateCo
*cco
= opaque
;
332 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
334 error_propagate(&cco
->err
, local_err
);
339 int bdrv_create(BlockDriver
*drv
, const char* filename
,
340 QemuOpts
*opts
, Error
**errp
)
347 .filename
= g_strdup(filename
),
353 if (!drv
->bdrv_create
) {
354 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
359 if (qemu_in_coroutine()) {
360 /* Fast-path if already in coroutine context */
361 bdrv_create_co_entry(&cco
);
363 co
= qemu_coroutine_create(bdrv_create_co_entry
);
364 qemu_coroutine_enter(co
, &cco
);
365 while (cco
.ret
== NOT_DONE
) {
366 aio_poll(qemu_get_aio_context(), true);
373 error_propagate(errp
, cco
.err
);
375 error_setg_errno(errp
, -ret
, "Could not create image");
380 g_free(cco
.filename
);
384 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
387 Error
*local_err
= NULL
;
390 drv
= bdrv_find_protocol(filename
, true, errp
);
395 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
397 error_propagate(errp
, local_err
);
403 * Try to get @bs's logical and physical block size.
404 * On success, store them in @bsz struct and return 0.
405 * On failure return -errno.
406 * @bs must not be empty.
408 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
410 BlockDriver
*drv
= bs
->drv
;
412 if (drv
&& drv
->bdrv_probe_blocksizes
) {
413 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
420 * Try to get @bs's geometry (cyls, heads, sectors).
421 * On success, store them in @geo struct and return 0.
422 * On failure return -errno.
423 * @bs must not be empty.
425 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
427 BlockDriver
*drv
= bs
->drv
;
429 if (drv
&& drv
->bdrv_probe_geometry
) {
430 return drv
->bdrv_probe_geometry(bs
, geo
);
437 * Create a uniquely-named empty temporary file.
438 * Return 0 upon success, otherwise a negative errno value.
440 int get_tmp_filename(char *filename
, int size
)
443 char temp_dir
[MAX_PATH
];
444 /* GetTempFileName requires that its output buffer (4th param)
445 have length MAX_PATH or greater. */
446 assert(size
>= MAX_PATH
);
447 return (GetTempPath(MAX_PATH
, temp_dir
)
448 && GetTempFileName(temp_dir
, "qem", 0, filename
)
449 ? 0 : -GetLastError());
453 tmpdir
= getenv("TMPDIR");
457 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
460 fd
= mkstemp(filename
);
464 if (close(fd
) != 0) {
473 * Detect host devices. By convention, /dev/cdrom[N] is always
474 * recognized as a host CDROM.
476 static BlockDriver
*find_hdev_driver(const char *filename
)
478 int score_max
= 0, score
;
479 BlockDriver
*drv
= NULL
, *d
;
481 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
482 if (d
->bdrv_probe_device
) {
483 score
= d
->bdrv_probe_device(filename
);
484 if (score
> score_max
) {
494 BlockDriver
*bdrv_find_protocol(const char *filename
,
495 bool allow_protocol_prefix
,
503 /* TODO Drivers without bdrv_file_open must be specified explicitly */
506 * XXX(hch): we really should not let host device detection
507 * override an explicit protocol specification, but moving this
508 * later breaks access to device names with colons in them.
509 * Thanks to the brain-dead persistent naming schemes on udev-
510 * based Linux systems those actually are quite common.
512 drv1
= find_hdev_driver(filename
);
517 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
521 p
= strchr(filename
, ':');
524 if (len
> sizeof(protocol
) - 1)
525 len
= sizeof(protocol
) - 1;
526 memcpy(protocol
, filename
, len
);
527 protocol
[len
] = '\0';
528 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
529 if (drv1
->protocol_name
&&
530 !strcmp(drv1
->protocol_name
, protocol
)) {
535 error_setg(errp
, "Unknown protocol '%s'", protocol
);
540 * Guess image format by probing its contents.
541 * This is not a good idea when your image is raw (CVE-2008-2004), but
542 * we do it anyway for backward compatibility.
544 * @buf contains the image's first @buf_size bytes.
545 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
546 * but can be smaller if the image file is smaller)
547 * @filename is its filename.
549 * For all block drivers, call the bdrv_probe() method to get its
551 * Return the first block driver with the highest probing score.
553 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
554 const char *filename
)
556 int score_max
= 0, score
;
557 BlockDriver
*drv
= NULL
, *d
;
559 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
561 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
562 if (score
> score_max
) {
572 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
573 BlockDriver
**pdrv
, Error
**errp
)
576 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
579 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
580 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
585 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
587 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
593 drv
= bdrv_probe_all(buf
, ret
, filename
);
595 error_setg(errp
, "Could not determine image format: No compatible "
604 * Set the current 'total_sectors' value
605 * Return 0 on success, -errno on error.
607 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
609 BlockDriver
*drv
= bs
->drv
;
611 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
615 /* query actual device if possible, otherwise just trust the hint */
616 if (drv
->bdrv_getlength
) {
617 int64_t length
= drv
->bdrv_getlength(bs
);
621 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
624 bs
->total_sectors
= hint
;
629 * Set open flags for a given discard mode
631 * Return 0 on success, -1 if the discard mode was invalid.
633 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
635 *flags
&= ~BDRV_O_UNMAP
;
637 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
639 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
640 *flags
|= BDRV_O_UNMAP
;
649 * Set open flags for a given cache mode
651 * Return 0 on success, -1 if the cache mode was invalid.
653 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
655 *flags
&= ~BDRV_O_CACHE_MASK
;
657 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
658 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
659 } else if (!strcmp(mode
, "directsync")) {
660 *flags
|= BDRV_O_NOCACHE
;
661 } else if (!strcmp(mode
, "writeback")) {
662 *flags
|= BDRV_O_CACHE_WB
;
663 } else if (!strcmp(mode
, "unsafe")) {
664 *flags
|= BDRV_O_CACHE_WB
;
665 *flags
|= BDRV_O_NO_FLUSH
;
666 } else if (!strcmp(mode
, "writethrough")) {
667 /* this is the default */
676 * Returns the flags that a temporary snapshot should get, based on the
677 * originally requested flags (the originally requested image will have flags
678 * like a backing file)
680 static int bdrv_temp_snapshot_flags(int flags
)
682 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
686 * Returns the flags that bs->file should get, based on the given flags for
689 static int bdrv_inherited_flags(int flags
)
691 /* Enable protocol handling, disable format probing for bs->file */
692 flags
|= BDRV_O_PROTOCOL
;
694 /* Our block drivers take care to send flushes and respect unmap policy,
695 * so we can enable both unconditionally on lower layers. */
696 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
698 /* Clear flags that only apply to the top layer */
699 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
705 * Returns the flags that bs->backing_hd should get, based on the given flags
708 static int bdrv_backing_flags(int flags
)
710 /* backing files always opened read-only */
711 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
713 /* snapshot=on is handled on the top layer */
714 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
719 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
721 int open_flags
= flags
| BDRV_O_CACHE_WB
;
724 * Clear flags that are internal to the block layer before opening the
727 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
730 * Snapshots should be writable.
732 if (flags
& BDRV_O_TEMPORARY
) {
733 open_flags
|= BDRV_O_RDWR
;
739 static void bdrv_assign_node_name(BlockDriverState
*bs
,
740 const char *node_name
,
747 /* Check for empty string or invalid characters */
748 if (!id_wellformed(node_name
)) {
749 error_setg(errp
, "Invalid node name");
753 /* takes care of avoiding namespaces collisions */
754 if (blk_by_name(node_name
)) {
755 error_setg(errp
, "node-name=%s is conflicting with a device id",
760 /* takes care of avoiding duplicates node names */
761 if (bdrv_find_node(node_name
)) {
762 error_setg(errp
, "Duplicate node name");
766 /* copy node name into the bs and insert it into the graph list */
767 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
768 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
772 * Common part for opening disk images and files
774 * Removes all processed options from *options.
776 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
777 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
780 const char *filename
;
781 const char *node_name
= NULL
;
782 Error
*local_err
= NULL
;
785 assert(bs
->file
== NULL
);
786 assert(options
!= NULL
&& bs
->options
!= options
);
789 filename
= file
->filename
;
791 filename
= qdict_get_try_str(options
, "filename");
794 if (drv
->bdrv_needs_filename
&& !filename
) {
795 error_setg(errp
, "The '%s' block driver requires a file name",
800 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
802 node_name
= qdict_get_try_str(options
, "node-name");
803 bdrv_assign_node_name(bs
, node_name
, &local_err
);
805 error_propagate(errp
, local_err
);
808 qdict_del(options
, "node-name");
810 /* bdrv_open() with directly using a protocol as drv. This layer is already
811 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
812 * and return immediately. */
813 if (file
!= NULL
&& drv
->bdrv_file_open
) {
818 bs
->open_flags
= flags
;
819 bs
->guest_block_size
= 512;
820 bs
->request_alignment
= 512;
821 bs
->zero_beyond_eof
= true;
822 open_flags
= bdrv_open_flags(bs
, flags
);
823 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
825 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
827 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
828 ? "Driver '%s' can only be used for read-only devices"
829 : "Driver '%s' is not whitelisted",
834 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
835 if (flags
& BDRV_O_COPY_ON_READ
) {
836 if (!bs
->read_only
) {
837 bdrv_enable_copy_on_read(bs
);
839 error_setg(errp
, "Can't use copy-on-read on read-only device");
844 if (filename
!= NULL
) {
845 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
847 bs
->filename
[0] = '\0';
849 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
852 bs
->opaque
= g_malloc0(drv
->instance_size
);
854 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
856 /* Open the image, either directly or using a protocol */
857 if (drv
->bdrv_file_open
) {
858 assert(file
== NULL
);
859 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
860 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
863 error_setg(errp
, "Can't use '%s' as a block driver for the "
864 "protocol level", drv
->format_name
);
869 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
874 error_propagate(errp
, local_err
);
875 } else if (bs
->filename
[0]) {
876 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
878 error_setg_errno(errp
, -ret
, "Could not open image");
884 error_report("Encrypted images are deprecated");
885 error_printf("Support for them will be removed in a future release.\n"
886 "You can use 'qemu-img convert' to convert your image"
887 " to an unencrypted one.\n");
890 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
892 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
896 bdrv_refresh_limits(bs
, &local_err
);
898 error_propagate(errp
, local_err
);
903 assert(bdrv_opt_mem_align(bs
) != 0);
904 assert(bdrv_min_mem_align(bs
) != 0);
905 assert((bs
->request_alignment
!= 0) || bs
->sg
);
916 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
918 QObject
*options_obj
;
922 ret
= strstart(filename
, "json:", &filename
);
925 options_obj
= qobject_from_json(filename
);
927 error_setg(errp
, "Could not parse the JSON options");
931 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
932 qobject_decref(options_obj
);
933 error_setg(errp
, "Invalid JSON object given");
937 options
= qobject_to_qdict(options_obj
);
938 qdict_flatten(options
);
944 * Fills in default options for opening images and converts the legacy
945 * filename/flags pair to option QDict entries.
947 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
948 BlockDriver
*drv
, Error
**errp
)
950 const char *filename
= *pfilename
;
952 bool protocol
= flags
& BDRV_O_PROTOCOL
;
953 bool parse_filename
= false;
954 Error
*local_err
= NULL
;
956 /* Parse json: pseudo-protocol */
957 if (filename
&& g_str_has_prefix(filename
, "json:")) {
958 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
960 error_propagate(errp
, local_err
);
964 /* Options given in the filename have lower priority than options
965 * specified directly */
966 qdict_join(*options
, json_options
, false);
967 QDECREF(json_options
);
968 *pfilename
= filename
= NULL
;
971 /* Fetch the file name from the options QDict if necessary */
972 if (protocol
&& filename
) {
973 if (!qdict_haskey(*options
, "filename")) {
974 qdict_put(*options
, "filename", qstring_from_str(filename
));
975 parse_filename
= true;
977 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
983 /* Find the right block driver */
984 filename
= qdict_get_try_str(*options
, "filename");
985 drvname
= qdict_get_try_str(*options
, "driver");
989 error_setg(errp
, "Driver specified twice");
992 drvname
= drv
->format_name
;
993 qdict_put(*options
, "driver", qstring_from_str(drvname
));
995 if (!drvname
&& protocol
) {
997 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1002 drvname
= drv
->format_name
;
1003 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1005 error_setg(errp
, "Must specify either driver or file");
1008 } else if (drvname
) {
1009 drv
= bdrv_find_format(drvname
);
1011 error_setg(errp
, "Unknown driver '%s'", drvname
);
1017 assert(drv
|| !protocol
);
1019 /* Driver-specific filename parsing */
1020 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1021 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1023 error_propagate(errp
, local_err
);
1027 if (!drv
->bdrv_needs_filename
) {
1028 qdict_del(*options
, "filename");
1035 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1038 if (bs
->backing_hd
) {
1039 assert(bs
->backing_blocker
);
1040 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1041 } else if (backing_hd
) {
1042 error_setg(&bs
->backing_blocker
,
1043 "node is used as backing hd of '%s'",
1044 bdrv_get_device_or_node_name(bs
));
1047 bs
->backing_hd
= backing_hd
;
1049 error_free(bs
->backing_blocker
);
1050 bs
->backing_blocker
= NULL
;
1053 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1054 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1055 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1056 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1058 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1059 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1060 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1061 bs
->backing_blocker
);
1063 bdrv_refresh_limits(bs
, NULL
);
1067 * Opens the backing file for a BlockDriverState if not yet open
1069 * options is a QDict of options to pass to the block drivers, or NULL for an
1070 * empty set of options. The reference to the QDict is transferred to this
1071 * function (even on failure), so if the caller intends to reuse the dictionary,
1072 * it needs to use QINCREF() before calling bdrv_file_open.
1074 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1076 char *backing_filename
= g_malloc0(PATH_MAX
);
1078 BlockDriverState
*backing_hd
;
1079 Error
*local_err
= NULL
;
1081 if (bs
->backing_hd
!= NULL
) {
1086 /* NULL means an empty set of options */
1087 if (options
== NULL
) {
1088 options
= qdict_new();
1091 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1092 if (qdict_haskey(options
, "file.filename")) {
1093 backing_filename
[0] = '\0';
1094 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1098 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1102 error_propagate(errp
, local_err
);
1108 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1110 error_setg(errp
, "Driver doesn't support backing files");
1115 backing_hd
= bdrv_new();
1117 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1118 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1121 assert(bs
->backing_hd
== NULL
);
1122 ret
= bdrv_open(&backing_hd
,
1123 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1124 bdrv_backing_flags(bs
->open_flags
), NULL
, &local_err
);
1126 bdrv_unref(backing_hd
);
1128 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1129 error_setg(errp
, "Could not open backing file: %s",
1130 error_get_pretty(local_err
));
1131 error_free(local_err
);
1134 bdrv_set_backing_hd(bs
, backing_hd
);
1137 g_free(backing_filename
);
1142 * Opens a disk image whose options are given as BlockdevRef in another block
1145 * If allow_none is true, no image will be opened if filename is false and no
1146 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1148 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1149 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1150 * itself, all options starting with "${bdref_key}." are considered part of the
1153 * The BlockdevRef will be removed from the options QDict.
1155 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1157 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1158 QDict
*options
, const char *bdref_key
, int flags
,
1159 bool allow_none
, Error
**errp
)
1161 QDict
*image_options
;
1163 char *bdref_key_dot
;
1164 const char *reference
;
1167 assert(*pbs
== NULL
);
1169 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1170 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1171 g_free(bdref_key_dot
);
1173 reference
= qdict_get_try_str(options
, bdref_key
);
1174 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1178 error_setg(errp
, "A block device must be specified for \"%s\"",
1182 QDECREF(image_options
);
1186 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1189 qdict_del(options
, bdref_key
);
1193 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1195 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1196 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1198 QemuOpts
*opts
= NULL
;
1199 QDict
*snapshot_options
;
1200 BlockDriverState
*bs_snapshot
;
1204 /* if snapshot, we create a temporary backing file and open it
1205 instead of opening 'filename' directly */
1207 /* Get the required size from the image */
1208 total_size
= bdrv_getlength(bs
);
1209 if (total_size
< 0) {
1211 error_setg_errno(errp
, -total_size
, "Could not get image size");
1215 /* Create the temporary image */
1216 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1218 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1222 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1224 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1225 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1226 qemu_opts_del(opts
);
1228 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1229 "'%s': %s", tmp_filename
,
1230 error_get_pretty(local_err
));
1231 error_free(local_err
);
1235 /* Prepare a new options QDict for the temporary file */
1236 snapshot_options
= qdict_new();
1237 qdict_put(snapshot_options
, "file.driver",
1238 qstring_from_str("file"));
1239 qdict_put(snapshot_options
, "file.filename",
1240 qstring_from_str(tmp_filename
));
1242 bs_snapshot
= bdrv_new();
1244 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1245 flags
, &bdrv_qcow2
, &local_err
);
1247 error_propagate(errp
, local_err
);
1251 bdrv_append(bs_snapshot
, bs
);
1254 g_free(tmp_filename
);
1259 * Opens a disk image (raw, qcow2, vmdk, ...)
1261 * options is a QDict of options to pass to the block drivers, or NULL for an
1262 * empty set of options. The reference to the QDict belongs to the block layer
1263 * after the call (even on failure), so if the caller intends to reuse the
1264 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1266 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1267 * If it is not NULL, the referenced BDS will be reused.
1269 * The reference parameter may be used to specify an existing block device which
1270 * should be opened. If specified, neither options nor a filename may be given,
1271 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1273 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1274 const char *reference
, QDict
*options
, int flags
,
1275 BlockDriver
*drv
, Error
**errp
)
1278 BlockDriverState
*file
= NULL
, *bs
;
1279 const char *drvname
;
1280 Error
*local_err
= NULL
;
1281 int snapshot_flags
= 0;
1286 bool options_non_empty
= options
? qdict_size(options
) : false;
1290 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1291 "another block device");
1295 if (filename
|| options_non_empty
) {
1296 error_setg(errp
, "Cannot reference an existing block device with "
1297 "additional options or a new filename");
1301 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1316 /* NULL means an empty set of options */
1317 if (options
== NULL
) {
1318 options
= qdict_new();
1321 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1326 /* Find the right image format driver */
1328 drvname
= qdict_get_try_str(options
, "driver");
1330 drv
= bdrv_find_format(drvname
);
1331 qdict_del(options
, "driver");
1333 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1339 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1340 if (drv
&& !drv
->bdrv_file_open
) {
1341 /* If the user explicitly wants a format driver here, we'll need to add
1342 * another layer for the protocol in bs->file */
1343 flags
&= ~BDRV_O_PROTOCOL
;
1346 bs
->options
= options
;
1347 options
= qdict_clone_shallow(options
);
1349 /* Open image file without format layer */
1350 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1351 if (flags
& BDRV_O_RDWR
) {
1352 flags
|= BDRV_O_ALLOW_RDWR
;
1354 if (flags
& BDRV_O_SNAPSHOT
) {
1355 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1356 flags
= bdrv_backing_flags(flags
);
1359 assert(file
== NULL
);
1360 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1361 bdrv_inherited_flags(flags
),
1368 /* Image format probing */
1371 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1376 error_setg(errp
, "Must specify either driver or file");
1381 /* Open the image */
1382 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1387 if (file
&& (bs
->file
!= file
)) {
1392 /* If there is a backing file, use it */
1393 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1394 QDict
*backing_options
;
1396 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1397 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1399 goto close_and_fail
;
1403 bdrv_refresh_filename(bs
);
1405 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1406 * temporary snapshot afterwards. */
1407 if (snapshot_flags
) {
1408 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1410 goto close_and_fail
;
1414 /* Check if any unknown options were used */
1415 if (options
&& (qdict_size(options
) != 0)) {
1416 const QDictEntry
*entry
= qdict_first(options
);
1417 if (flags
& BDRV_O_PROTOCOL
) {
1418 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1419 "'%s'", drv
->format_name
, entry
->key
);
1421 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1422 "support the option '%s'", drv
->format_name
,
1423 bdrv_get_device_name(bs
), entry
->key
);
1427 goto close_and_fail
;
1430 if (!bdrv_key_required(bs
)) {
1432 blk_dev_change_media_cb(bs
->blk
, true);
1434 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1435 && !runstate_check(RUN_STATE_INMIGRATE
)
1436 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1438 "Guest must be stopped for opening of encrypted image");
1440 goto close_and_fail
;
1451 QDECREF(bs
->options
);
1455 /* If *pbs is NULL, a new BDS has been created in this function and
1456 needs to be freed now. Otherwise, it does not need to be closed,
1457 since it has not really been opened yet. */
1461 error_propagate(errp
, local_err
);
1466 /* See fail path, but now the BDS has to be always closed */
1474 error_propagate(errp
, local_err
);
1479 typedef struct BlockReopenQueueEntry
{
1481 BDRVReopenState state
;
1482 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1483 } BlockReopenQueueEntry
;
1486 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1487 * reopen of multiple devices.
1489 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1490 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1491 * be created and initialized. This newly created BlockReopenQueue should be
1492 * passed back in for subsequent calls that are intended to be of the same
1495 * bs is the BlockDriverState to add to the reopen queue.
1497 * flags contains the open flags for the associated bs
1499 * returns a pointer to bs_queue, which is either the newly allocated
1500 * bs_queue, or the existing bs_queue being used.
1503 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1504 BlockDriverState
*bs
, int flags
)
1508 BlockReopenQueueEntry
*bs_entry
;
1509 if (bs_queue
== NULL
) {
1510 bs_queue
= g_new0(BlockReopenQueue
, 1);
1511 QSIMPLEQ_INIT(bs_queue
);
1514 /* bdrv_open() masks this flag out */
1515 flags
&= ~BDRV_O_PROTOCOL
;
1518 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1521 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1522 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1524 bs_entry
->state
.bs
= bs
;
1525 bs_entry
->state
.flags
= flags
;
1531 * Reopen multiple BlockDriverStates atomically & transactionally.
1533 * The queue passed in (bs_queue) must have been built up previous
1534 * via bdrv_reopen_queue().
1536 * Reopens all BDS specified in the queue, with the appropriate
1537 * flags. All devices are prepared for reopen, and failure of any
1538 * device will cause all device changes to be abandonded, and intermediate
1541 * If all devices prepare successfully, then the changes are committed
1545 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1548 BlockReopenQueueEntry
*bs_entry
, *next
;
1549 Error
*local_err
= NULL
;
1551 assert(bs_queue
!= NULL
);
1555 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1556 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1557 error_propagate(errp
, local_err
);
1560 bs_entry
->prepared
= true;
1563 /* If we reach this point, we have success and just need to apply the
1566 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1567 bdrv_reopen_commit(&bs_entry
->state
);
1573 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1574 if (ret
&& bs_entry
->prepared
) {
1575 bdrv_reopen_abort(&bs_entry
->state
);
1584 /* Reopen a single BlockDriverState with the specified flags. */
1585 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1588 Error
*local_err
= NULL
;
1589 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1591 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1592 if (local_err
!= NULL
) {
1593 error_propagate(errp
, local_err
);
1600 * Prepares a BlockDriverState for reopen. All changes are staged in the
1601 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1602 * the block driver layer .bdrv_reopen_prepare()
1604 * bs is the BlockDriverState to reopen
1605 * flags are the new open flags
1606 * queue is the reopen queue
1608 * Returns 0 on success, non-zero on error. On error errp will be set
1611 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1612 * It is the responsibility of the caller to then call the abort() or
1613 * commit() for any other BDS that have been left in a prepare() state
1616 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1620 Error
*local_err
= NULL
;
1623 assert(reopen_state
!= NULL
);
1624 assert(reopen_state
->bs
->drv
!= NULL
);
1625 drv
= reopen_state
->bs
->drv
;
1627 /* if we are to stay read-only, do not allow permission change
1629 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1630 reopen_state
->flags
& BDRV_O_RDWR
) {
1631 error_setg(errp
, "Node '%s' is read only",
1632 bdrv_get_device_or_node_name(reopen_state
->bs
));
1637 ret
= bdrv_flush(reopen_state
->bs
);
1639 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1644 if (drv
->bdrv_reopen_prepare
) {
1645 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1647 if (local_err
!= NULL
) {
1648 error_propagate(errp
, local_err
);
1650 error_setg(errp
, "failed while preparing to reopen image '%s'",
1651 reopen_state
->bs
->filename
);
1656 /* It is currently mandatory to have a bdrv_reopen_prepare()
1657 * handler for each supported drv. */
1658 error_setg(errp
, "Block format '%s' used by node '%s' "
1659 "does not support reopening files", drv
->format_name
,
1660 bdrv_get_device_or_node_name(reopen_state
->bs
));
1672 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1673 * makes them final by swapping the staging BlockDriverState contents into
1674 * the active BlockDriverState contents.
1676 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1680 assert(reopen_state
!= NULL
);
1681 drv
= reopen_state
->bs
->drv
;
1682 assert(drv
!= NULL
);
1684 /* If there are any driver level actions to take */
1685 if (drv
->bdrv_reopen_commit
) {
1686 drv
->bdrv_reopen_commit(reopen_state
);
1689 /* set BDS specific flags now */
1690 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1691 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1693 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1695 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1699 * Abort the reopen, and delete and free the staged changes in
1702 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1706 assert(reopen_state
!= NULL
);
1707 drv
= reopen_state
->bs
->drv
;
1708 assert(drv
!= NULL
);
1710 if (drv
->bdrv_reopen_abort
) {
1711 drv
->bdrv_reopen_abort(reopen_state
);
1716 void bdrv_close(BlockDriverState
*bs
)
1718 BdrvAioNotifier
*ban
, *ban_next
;
1721 block_job_cancel_sync(bs
->job
);
1723 bdrv_drain_all(); /* complete I/O */
1725 bdrv_drain_all(); /* in case flush left pending I/O */
1726 notifier_list_notify(&bs
->close_notifiers
, bs
);
1729 if (bs
->backing_hd
) {
1730 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1731 bdrv_set_backing_hd(bs
, NULL
);
1732 bdrv_unref(backing_hd
);
1734 bs
->drv
->bdrv_close(bs
);
1738 bs
->copy_on_read
= 0;
1739 bs
->backing_file
[0] = '\0';
1740 bs
->backing_format
[0] = '\0';
1741 bs
->total_sectors
= 0;
1745 bs
->zero_beyond_eof
= false;
1746 QDECREF(bs
->options
);
1748 QDECREF(bs
->full_open_options
);
1749 bs
->full_open_options
= NULL
;
1751 if (bs
->file
!= NULL
) {
1752 bdrv_unref(bs
->file
);
1758 blk_dev_change_media_cb(bs
->blk
, false);
1761 /*throttling disk I/O limits*/
1762 if (bs
->io_limits_enabled
) {
1763 bdrv_io_limits_disable(bs
);
1766 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1769 QLIST_INIT(&bs
->aio_notifiers
);
1772 void bdrv_close_all(void)
1774 BlockDriverState
*bs
;
1776 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1777 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1779 aio_context_acquire(aio_context
);
1781 aio_context_release(aio_context
);
1785 /* make a BlockDriverState anonymous by removing from bdrv_state and
1786 * graph_bdrv_state list.
1787 Also, NULL terminate the device_name to prevent double remove */
1788 void bdrv_make_anon(BlockDriverState
*bs
)
1791 * Take care to remove bs from bdrv_states only when it's actually
1792 * in it. Note that bs->device_list.tqe_prev is initially null,
1793 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1794 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1795 * resetting it to null on remove.
1797 if (bs
->device_list
.tqe_prev
) {
1798 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1799 bs
->device_list
.tqe_prev
= NULL
;
1801 if (bs
->node_name
[0] != '\0') {
1802 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1804 bs
->node_name
[0] = '\0';
1807 static void bdrv_rebind(BlockDriverState
*bs
)
1809 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1810 bs
->drv
->bdrv_rebind(bs
);
1814 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1815 BlockDriverState
*bs_src
)
1817 /* move some fields that need to stay attached to the device */
1820 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1821 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1823 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1825 /* i/o throttled req */
1826 bs_dest
->throttle_state
= bs_src
->throttle_state
,
1827 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1828 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
1829 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
1830 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1831 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1832 memcpy(&bs_dest
->round_robin
,
1833 &bs_src
->round_robin
,
1834 sizeof(bs_dest
->round_robin
));
1835 memcpy(&bs_dest
->throttle_timers
,
1836 &bs_src
->throttle_timers
,
1837 sizeof(ThrottleTimers
));
1840 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1841 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1844 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1845 bs_dest
->iostatus
= bs_src
->iostatus
;
1848 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1850 /* reference count */
1851 bs_dest
->refcnt
= bs_src
->refcnt
;
1854 bs_dest
->job
= bs_src
->job
;
1856 /* keep the same entry in bdrv_states */
1857 bs_dest
->device_list
= bs_src
->device_list
;
1858 bs_dest
->blk
= bs_src
->blk
;
1860 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1861 sizeof(bs_dest
->op_blockers
));
1865 * Swap bs contents for two image chains while they are live,
1866 * while keeping required fields on the BlockDriverState that is
1867 * actually attached to a device.
1869 * This will modify the BlockDriverState fields, and swap contents
1870 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1872 * bs_new must not be attached to a BlockBackend.
1874 * This function does not create any image files.
1876 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1878 BlockDriverState tmp
;
1880 /* The code needs to swap the node_name but simply swapping node_list won't
1881 * work so first remove the nodes from the graph list, do the swap then
1882 * insert them back if needed.
1884 if (bs_new
->node_name
[0] != '\0') {
1885 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
1887 if (bs_old
->node_name
[0] != '\0') {
1888 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
1891 /* If the BlockDriverState is part of a throttling group acquire
1892 * its lock since we're going to mess with the protected fields.
1893 * Otherwise there's no need to worry since no one else can touch
1895 if (bs_old
->throttle_state
) {
1896 throttle_group_lock(bs_old
);
1899 /* bs_new must be unattached and shouldn't have anything fancy enabled */
1900 assert(!bs_new
->blk
);
1901 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
1902 assert(bs_new
->job
== NULL
);
1903 assert(bs_new
->io_limits_enabled
== false);
1904 assert(bs_new
->throttle_state
== NULL
);
1905 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
1911 /* there are some fields that should not be swapped, move them back */
1912 bdrv_move_feature_fields(&tmp
, bs_old
);
1913 bdrv_move_feature_fields(bs_old
, bs_new
);
1914 bdrv_move_feature_fields(bs_new
, &tmp
);
1916 /* bs_new must remain unattached */
1917 assert(!bs_new
->blk
);
1919 /* Check a few fields that should remain attached to the device */
1920 assert(bs_new
->job
== NULL
);
1921 assert(bs_new
->io_limits_enabled
== false);
1922 assert(bs_new
->throttle_state
== NULL
);
1923 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
1925 /* Release the ThrottleGroup lock */
1926 if (bs_old
->throttle_state
) {
1927 throttle_group_unlock(bs_old
);
1930 /* insert the nodes back into the graph node list if needed */
1931 if (bs_new
->node_name
[0] != '\0') {
1932 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
1934 if (bs_old
->node_name
[0] != '\0') {
1935 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
1938 bdrv_rebind(bs_new
);
1939 bdrv_rebind(bs_old
);
1943 * Add new bs contents at the top of an image chain while the chain is
1944 * live, while keeping required fields on the top layer.
1946 * This will modify the BlockDriverState fields, and swap contents
1947 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1949 * bs_new must not be attached to a BlockBackend.
1951 * This function does not create any image files.
1953 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1955 bdrv_swap(bs_new
, bs_top
);
1957 /* The contents of 'tmp' will become bs_top, as we are
1958 * swapping bs_new and bs_top contents. */
1959 bdrv_set_backing_hd(bs_top
, bs_new
);
1962 static void bdrv_delete(BlockDriverState
*bs
)
1965 assert(bdrv_op_blocker_is_empty(bs
));
1966 assert(!bs
->refcnt
);
1967 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
1971 /* remove from list, if necessary */
1978 * Run consistency checks on an image
1980 * Returns 0 if the check could be completed (it doesn't mean that the image is
1981 * free of errors) or -errno when an internal error occurred. The results of the
1982 * check are stored in res.
1984 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1986 if (bs
->drv
== NULL
) {
1989 if (bs
->drv
->bdrv_check
== NULL
) {
1993 memset(res
, 0, sizeof(*res
));
1994 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1997 #define COMMIT_BUF_SECTORS 2048
1999 /* commit COW file into the raw image */
2000 int bdrv_commit(BlockDriverState
*bs
)
2002 BlockDriver
*drv
= bs
->drv
;
2003 int64_t sector
, total_sectors
, length
, backing_length
;
2004 int n
, ro
, open_flags
;
2006 uint8_t *buf
= NULL
;
2011 if (!bs
->backing_hd
) {
2015 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2016 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2020 ro
= bs
->backing_hd
->read_only
;
2021 open_flags
= bs
->backing_hd
->open_flags
;
2024 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2029 length
= bdrv_getlength(bs
);
2035 backing_length
= bdrv_getlength(bs
->backing_hd
);
2036 if (backing_length
< 0) {
2037 ret
= backing_length
;
2041 /* If our top snapshot is larger than the backing file image,
2042 * grow the backing file image if possible. If not possible,
2043 * we must return an error */
2044 if (length
> backing_length
) {
2045 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2051 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2053 /* qemu_try_blockalign() for bs will choose an alignment that works for
2054 * bs->backing_hd as well, so no need to compare the alignment manually. */
2055 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2061 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2062 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2067 ret
= bdrv_read(bs
, sector
, buf
, n
);
2072 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2079 if (drv
->bdrv_make_empty
) {
2080 ret
= drv
->bdrv_make_empty(bs
);
2088 * Make sure all data we wrote to the backing device is actually
2091 if (bs
->backing_hd
) {
2092 bdrv_flush(bs
->backing_hd
);
2100 /* ignoring error return here */
2101 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2107 int bdrv_commit_all(void)
2109 BlockDriverState
*bs
;
2111 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2112 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2114 aio_context_acquire(aio_context
);
2115 if (bs
->drv
&& bs
->backing_hd
) {
2116 int ret
= bdrv_commit(bs
);
2118 aio_context_release(aio_context
);
2122 aio_context_release(aio_context
);
2130 * -EINVAL - backing format specified, but no file
2131 * -ENOSPC - can't update the backing file because no space is left in the
2133 * -ENOTSUP - format driver doesn't support changing the backing file
2135 int bdrv_change_backing_file(BlockDriverState
*bs
,
2136 const char *backing_file
, const char *backing_fmt
)
2138 BlockDriver
*drv
= bs
->drv
;
2141 /* Backing file format doesn't make sense without a backing file */
2142 if (backing_fmt
&& !backing_file
) {
2146 if (drv
->bdrv_change_backing_file
!= NULL
) {
2147 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2153 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2154 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2160 * Finds the image layer in the chain that has 'bs' as its backing file.
2162 * active is the current topmost image.
2164 * Returns NULL if bs is not found in active's image chain,
2165 * or if active == bs.
2167 * Returns the bottommost base image if bs == NULL.
2169 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2170 BlockDriverState
*bs
)
2172 while (active
&& bs
!= active
->backing_hd
) {
2173 active
= active
->backing_hd
;
2179 /* Given a BDS, searches for the base layer. */
2180 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2182 return bdrv_find_overlay(bs
, NULL
);
2185 typedef struct BlkIntermediateStates
{
2186 BlockDriverState
*bs
;
2187 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2188 } BlkIntermediateStates
;
2192 * Drops images above 'base' up to and including 'top', and sets the image
2193 * above 'top' to have base as its backing file.
2195 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2196 * information in 'bs' can be properly updated.
2198 * E.g., this will convert the following chain:
2199 * bottom <- base <- intermediate <- top <- active
2203 * bottom <- base <- active
2205 * It is allowed for bottom==base, in which case it converts:
2207 * base <- intermediate <- top <- active
2213 * If backing_file_str is non-NULL, it will be used when modifying top's
2214 * overlay image metadata.
2217 * if active == top, that is considered an error
2220 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2221 BlockDriverState
*base
, const char *backing_file_str
)
2223 BlockDriverState
*intermediate
;
2224 BlockDriverState
*base_bs
= NULL
;
2225 BlockDriverState
*new_top_bs
= NULL
;
2226 BlkIntermediateStates
*intermediate_state
, *next
;
2229 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2230 QSIMPLEQ_INIT(&states_to_delete
);
2232 if (!top
->drv
|| !base
->drv
) {
2236 new_top_bs
= bdrv_find_overlay(active
, top
);
2238 if (new_top_bs
== NULL
) {
2239 /* we could not find the image above 'top', this is an error */
2243 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2244 * to do, no intermediate images */
2245 if (new_top_bs
->backing_hd
== base
) {
2252 /* now we will go down through the list, and add each BDS we find
2253 * into our deletion queue, until we hit the 'base'
2255 while (intermediate
) {
2256 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2257 intermediate_state
->bs
= intermediate
;
2258 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2260 if (intermediate
->backing_hd
== base
) {
2261 base_bs
= intermediate
->backing_hd
;
2264 intermediate
= intermediate
->backing_hd
;
2266 if (base_bs
== NULL
) {
2267 /* something went wrong, we did not end at the base. safely
2268 * unravel everything, and exit with error */
2272 /* success - we can delete the intermediate states, and link top->base */
2273 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2274 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2275 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2279 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2281 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2282 /* so that bdrv_close() does not recursively close the chain */
2283 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2284 bdrv_unref(intermediate_state
->bs
);
2289 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2290 g_free(intermediate_state
);
2296 * Truncate file to 'offset' bytes (needed only for file protocols)
2298 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2300 BlockDriver
*drv
= bs
->drv
;
2304 if (!drv
->bdrv_truncate
)
2309 ret
= drv
->bdrv_truncate(bs
, offset
);
2311 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2312 bdrv_dirty_bitmap_truncate(bs
);
2314 blk_dev_resize_cb(bs
->blk
);
2321 * Length of a allocated file in bytes. Sparse files are counted by actual
2322 * allocated space. Return < 0 if error or unknown.
2324 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2326 BlockDriver
*drv
= bs
->drv
;
2330 if (drv
->bdrv_get_allocated_file_size
) {
2331 return drv
->bdrv_get_allocated_file_size(bs
);
2334 return bdrv_get_allocated_file_size(bs
->file
);
2340 * Return number of sectors on success, -errno on error.
2342 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2344 BlockDriver
*drv
= bs
->drv
;
2349 if (drv
->has_variable_length
) {
2350 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2355 return bs
->total_sectors
;
2359 * Return length in bytes on success, -errno on error.
2360 * The length is always a multiple of BDRV_SECTOR_SIZE.
2362 int64_t bdrv_getlength(BlockDriverState
*bs
)
2364 int64_t ret
= bdrv_nb_sectors(bs
);
2366 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2367 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2370 /* return 0 as number of sectors if no device present or error */
2371 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2373 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2375 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2378 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2379 BlockdevOnError on_write_error
)
2381 bs
->on_read_error
= on_read_error
;
2382 bs
->on_write_error
= on_write_error
;
2385 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2387 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2390 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2392 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2395 case BLOCKDEV_ON_ERROR_ENOSPC
:
2396 return (error
== ENOSPC
) ?
2397 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2398 case BLOCKDEV_ON_ERROR_STOP
:
2399 return BLOCK_ERROR_ACTION_STOP
;
2400 case BLOCKDEV_ON_ERROR_REPORT
:
2401 return BLOCK_ERROR_ACTION_REPORT
;
2402 case BLOCKDEV_ON_ERROR_IGNORE
:
2403 return BLOCK_ERROR_ACTION_IGNORE
;
2409 static void send_qmp_error_event(BlockDriverState
*bs
,
2410 BlockErrorAction action
,
2411 bool is_read
, int error
)
2413 IoOperationType optype
;
2415 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2416 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2417 bdrv_iostatus_is_enabled(bs
),
2418 error
== ENOSPC
, strerror(error
),
2422 /* This is done by device models because, while the block layer knows
2423 * about the error, it does not know whether an operation comes from
2424 * the device or the block layer (from a job, for example).
2426 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2427 bool is_read
, int error
)
2431 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2432 /* First set the iostatus, so that "info block" returns an iostatus
2433 * that matches the events raised so far (an additional error iostatus
2434 * is fine, but not a lost one).
2436 bdrv_iostatus_set_err(bs
, error
);
2438 /* Then raise the request to stop the VM and the event.
2439 * qemu_system_vmstop_request_prepare has two effects. First,
2440 * it ensures that the STOP event always comes after the
2441 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2442 * can observe the STOP event and do a "cont" before the STOP
2443 * event is issued, the VM will not stop. In this case, vm_start()
2444 * also ensures that the STOP/RESUME pair of events is emitted.
2446 qemu_system_vmstop_request_prepare();
2447 send_qmp_error_event(bs
, action
, is_read
, error
);
2448 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2450 send_qmp_error_event(bs
, action
, is_read
, error
);
2454 int bdrv_is_read_only(BlockDriverState
*bs
)
2456 return bs
->read_only
;
2459 int bdrv_is_sg(BlockDriverState
*bs
)
2464 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2466 return bs
->enable_write_cache
;
2469 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2471 bs
->enable_write_cache
= wce
;
2473 /* so a reopen() will preserve wce */
2475 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2477 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2481 int bdrv_is_encrypted(BlockDriverState
*bs
)
2483 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2485 return bs
->encrypted
;
2488 int bdrv_key_required(BlockDriverState
*bs
)
2490 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2492 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2494 return (bs
->encrypted
&& !bs
->valid_key
);
2497 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2500 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2501 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2507 if (!bs
->encrypted
) {
2509 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2512 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2515 } else if (!bs
->valid_key
) {
2518 /* call the change callback now, we skipped it on open */
2519 blk_dev_change_media_cb(bs
->blk
, true);
2526 * Provide an encryption key for @bs.
2527 * If @key is non-null:
2528 * If @bs is not encrypted, fail.
2529 * Else if the key is invalid, fail.
2530 * Else set @bs's key to @key, replacing the existing key, if any.
2532 * If @bs is encrypted and still lacks a key, fail.
2534 * On failure, store an error object through @errp if non-null.
2536 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2539 if (!bdrv_is_encrypted(bs
)) {
2540 error_setg(errp
, "Node '%s' is not encrypted",
2541 bdrv_get_device_or_node_name(bs
));
2542 } else if (bdrv_set_key(bs
, key
) < 0) {
2543 error_set(errp
, QERR_INVALID_PASSWORD
);
2546 if (bdrv_key_required(bs
)) {
2547 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2548 "'%s' (%s) is encrypted",
2549 bdrv_get_device_or_node_name(bs
),
2550 bdrv_get_encrypted_filename(bs
));
2555 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2557 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2560 static int qsort_strcmp(const void *a
, const void *b
)
2562 return strcmp(a
, b
);
2565 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2571 const char **formats
= NULL
;
2573 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2574 if (drv
->format_name
) {
2577 while (formats
&& i
&& !found
) {
2578 found
= !strcmp(formats
[--i
], drv
->format_name
);
2582 formats
= g_renew(const char *, formats
, count
+ 1);
2583 formats
[count
++] = drv
->format_name
;
2588 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2590 for (i
= 0; i
< count
; i
++) {
2591 it(opaque
, formats
[i
]);
2597 /* This function is to find a node in the bs graph */
2598 BlockDriverState
*bdrv_find_node(const char *node_name
)
2600 BlockDriverState
*bs
;
2604 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2605 if (!strcmp(node_name
, bs
->node_name
)) {
2612 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2613 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2615 BlockDeviceInfoList
*list
, *entry
;
2616 BlockDriverState
*bs
;
2619 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2620 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2622 qapi_free_BlockDeviceInfoList(list
);
2625 entry
= g_malloc0(sizeof(*entry
));
2626 entry
->value
= info
;
2634 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2635 const char *node_name
,
2639 BlockDriverState
*bs
;
2642 blk
= blk_by_name(device
);
2650 bs
= bdrv_find_node(node_name
);
2657 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2658 device
? device
: "",
2659 node_name
? node_name
: "");
2663 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2664 * return false. If either argument is NULL, return false. */
2665 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2667 while (top
&& top
!= base
) {
2668 top
= top
->backing_hd
;
2674 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2677 return QTAILQ_FIRST(&graph_bdrv_states
);
2679 return QTAILQ_NEXT(bs
, node_list
);
2682 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2685 return QTAILQ_FIRST(&bdrv_states
);
2687 return QTAILQ_NEXT(bs
, device_list
);
2690 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2692 return bs
->node_name
;
2695 /* TODO check what callers really want: bs->node_name or blk_name() */
2696 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2698 return bs
->blk
? blk_name(bs
->blk
) : "";
2701 /* This can be used to identify nodes that might not have a device
2702 * name associated. Since node and device names live in the same
2703 * namespace, the result is unambiguous. The exception is if both are
2704 * absent, then this returns an empty (non-null) string. */
2705 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2707 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2710 int bdrv_get_flags(BlockDriverState
*bs
)
2712 return bs
->open_flags
;
2715 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2720 int bdrv_has_zero_init(BlockDriverState
*bs
)
2724 /* If BS is a copy on write image, it is initialized to
2725 the contents of the base image, which may not be zeroes. */
2726 if (bs
->backing_hd
) {
2729 if (bs
->drv
->bdrv_has_zero_init
) {
2730 return bs
->drv
->bdrv_has_zero_init(bs
);
2737 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2739 BlockDriverInfo bdi
;
2741 if (bs
->backing_hd
) {
2745 if (bdrv_get_info(bs
, &bdi
) == 0) {
2746 return bdi
.unallocated_blocks_are_zero
;
2752 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2754 BlockDriverInfo bdi
;
2756 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2760 if (bdrv_get_info(bs
, &bdi
) == 0) {
2761 return bdi
.can_write_zeroes_with_unmap
;
2767 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2769 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2770 return bs
->backing_file
;
2771 else if (bs
->encrypted
)
2772 return bs
->filename
;
2777 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2778 char *filename
, int filename_size
)
2780 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2783 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2785 BlockDriver
*drv
= bs
->drv
;
2788 if (!drv
->bdrv_get_info
)
2790 memset(bdi
, 0, sizeof(*bdi
));
2791 return drv
->bdrv_get_info(bs
, bdi
);
2794 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2796 BlockDriver
*drv
= bs
->drv
;
2797 if (drv
&& drv
->bdrv_get_specific_info
) {
2798 return drv
->bdrv_get_specific_info(bs
);
2803 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2805 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
2809 bs
->drv
->bdrv_debug_event(bs
, event
);
2812 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
2815 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
2819 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
2820 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
2826 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
2828 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
2832 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
2833 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
2839 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
2841 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
2845 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
2846 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
2852 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
2854 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
2858 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
2859 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
2865 int bdrv_is_snapshot(BlockDriverState
*bs
)
2867 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2870 /* backing_file can either be relative, or absolute, or a protocol. If it is
2871 * relative, it must be relative to the chain. So, passing in bs->filename
2872 * from a BDS as backing_file should not be done, as that may be relative to
2873 * the CWD rather than the chain. */
2874 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2875 const char *backing_file
)
2877 char *filename_full
= NULL
;
2878 char *backing_file_full
= NULL
;
2879 char *filename_tmp
= NULL
;
2880 int is_protocol
= 0;
2881 BlockDriverState
*curr_bs
= NULL
;
2882 BlockDriverState
*retval
= NULL
;
2884 if (!bs
|| !bs
->drv
|| !backing_file
) {
2888 filename_full
= g_malloc(PATH_MAX
);
2889 backing_file_full
= g_malloc(PATH_MAX
);
2890 filename_tmp
= g_malloc(PATH_MAX
);
2892 is_protocol
= path_has_protocol(backing_file
);
2894 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
2896 /* If either of the filename paths is actually a protocol, then
2897 * compare unmodified paths; otherwise make paths relative */
2898 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
2899 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
2900 retval
= curr_bs
->backing_hd
;
2904 /* If not an absolute filename path, make it relative to the current
2905 * image's filename path */
2906 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2909 /* We are going to compare absolute pathnames */
2910 if (!realpath(filename_tmp
, filename_full
)) {
2914 /* We need to make sure the backing filename we are comparing against
2915 * is relative to the current image filename (or absolute) */
2916 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2917 curr_bs
->backing_file
);
2919 if (!realpath(filename_tmp
, backing_file_full
)) {
2923 if (strcmp(backing_file_full
, filename_full
) == 0) {
2924 retval
= curr_bs
->backing_hd
;
2930 g_free(filename_full
);
2931 g_free(backing_file_full
);
2932 g_free(filename_tmp
);
2936 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
2942 if (!bs
->backing_hd
) {
2946 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
2949 void bdrv_init(void)
2951 module_call_init(MODULE_INIT_BLOCK
);
2954 void bdrv_init_with_whitelist(void)
2956 use_bdrv_whitelist
= 1;
2960 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
2962 Error
*local_err
= NULL
;
2969 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
2972 bs
->open_flags
&= ~BDRV_O_INCOMING
;
2974 if (bs
->drv
->bdrv_invalidate_cache
) {
2975 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
2976 } else if (bs
->file
) {
2977 bdrv_invalidate_cache(bs
->file
, &local_err
);
2980 error_propagate(errp
, local_err
);
2984 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2986 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
2991 void bdrv_invalidate_cache_all(Error
**errp
)
2993 BlockDriverState
*bs
;
2994 Error
*local_err
= NULL
;
2996 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2997 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2999 aio_context_acquire(aio_context
);
3000 bdrv_invalidate_cache(bs
, &local_err
);
3001 aio_context_release(aio_context
);
3003 error_propagate(errp
, local_err
);
3009 /**************************************************************/
3010 /* removable device support */
3013 * Return TRUE if the media is present
3015 int bdrv_is_inserted(BlockDriverState
*bs
)
3017 BlockDriver
*drv
= bs
->drv
;
3021 if (!drv
->bdrv_is_inserted
)
3023 return drv
->bdrv_is_inserted(bs
);
3027 * Return whether the media changed since the last call to this
3028 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3030 int bdrv_media_changed(BlockDriverState
*bs
)
3032 BlockDriver
*drv
= bs
->drv
;
3034 if (drv
&& drv
->bdrv_media_changed
) {
3035 return drv
->bdrv_media_changed(bs
);
3041 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3043 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3045 BlockDriver
*drv
= bs
->drv
;
3046 const char *device_name
;
3048 if (drv
&& drv
->bdrv_eject
) {
3049 drv
->bdrv_eject(bs
, eject_flag
);
3052 device_name
= bdrv_get_device_name(bs
);
3053 if (device_name
[0] != '\0') {
3054 qapi_event_send_device_tray_moved(device_name
,
3055 eject_flag
, &error_abort
);
3060 * Lock or unlock the media (if it is locked, the user won't be able
3061 * to eject it manually).
3063 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3065 BlockDriver
*drv
= bs
->drv
;
3067 trace_bdrv_lock_medium(bs
, locked
);
3069 if (drv
&& drv
->bdrv_lock_medium
) {
3070 drv
->bdrv_lock_medium(bs
, locked
);
3074 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3076 bs
->guest_block_size
= align
;
3079 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3081 BdrvDirtyBitmap
*bm
;
3084 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3085 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3092 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3094 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3095 g_free(bitmap
->name
);
3096 bitmap
->name
= NULL
;
3099 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3100 uint32_t granularity
,
3104 int64_t bitmap_size
;
3105 BdrvDirtyBitmap
*bitmap
;
3106 uint32_t sector_granularity
;
3108 assert((granularity
& (granularity
- 1)) == 0);
3110 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3111 error_setg(errp
, "Bitmap already exists: %s", name
);
3114 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3115 assert(sector_granularity
);
3116 bitmap_size
= bdrv_nb_sectors(bs
);
3117 if (bitmap_size
< 0) {
3118 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3119 errno
= -bitmap_size
;
3122 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3123 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3124 bitmap
->size
= bitmap_size
;
3125 bitmap
->name
= g_strdup(name
);
3126 bitmap
->disabled
= false;
3127 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3131 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3133 return bitmap
->successor
;
3136 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3138 return !(bitmap
->disabled
|| bitmap
->successor
);
3141 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3143 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3144 return DIRTY_BITMAP_STATUS_FROZEN
;
3145 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3146 return DIRTY_BITMAP_STATUS_DISABLED
;
3148 return DIRTY_BITMAP_STATUS_ACTIVE
;
3153 * Create a successor bitmap destined to replace this bitmap after an operation.
3154 * Requires that the bitmap is not frozen and has no successor.
3156 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3157 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3159 uint64_t granularity
;
3160 BdrvDirtyBitmap
*child
;
3162 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3163 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3164 "currently frozen");
3167 assert(!bitmap
->successor
);
3169 /* Create an anonymous successor */
3170 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3171 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3176 /* Successor will be on or off based on our current state. */
3177 child
->disabled
= bitmap
->disabled
;
3179 /* Install the successor and freeze the parent */
3180 bitmap
->successor
= child
;
3185 * For a bitmap with a successor, yield our name to the successor,
3186 * delete the old bitmap, and return a handle to the new bitmap.
3188 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3189 BdrvDirtyBitmap
*bitmap
,
3193 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3195 if (successor
== NULL
) {
3196 error_setg(errp
, "Cannot relinquish control if "
3197 "there's no successor present");
3201 name
= bitmap
->name
;
3202 bitmap
->name
= NULL
;
3203 successor
->name
= name
;
3204 bitmap
->successor
= NULL
;
3205 bdrv_release_dirty_bitmap(bs
, bitmap
);
3211 * In cases of failure where we can no longer safely delete the parent,
3212 * we may wish to re-join the parent and child/successor.
3213 * The merged parent will be un-frozen, but not explicitly re-enabled.
3215 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3216 BdrvDirtyBitmap
*parent
,
3219 BdrvDirtyBitmap
*successor
= parent
->successor
;
3222 error_setg(errp
, "Cannot reclaim a successor when none is present");
3226 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3227 error_setg(errp
, "Merging of parent and successor bitmap failed");
3230 bdrv_release_dirty_bitmap(bs
, successor
);
3231 parent
->successor
= NULL
;
3237 * Truncates _all_ bitmaps attached to a BDS.
3239 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3241 BdrvDirtyBitmap
*bitmap
;
3242 uint64_t size
= bdrv_nb_sectors(bs
);
3244 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3245 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3248 hbitmap_truncate(bitmap
->bitmap
, size
);
3252 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3254 BdrvDirtyBitmap
*bm
, *next
;
3255 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3257 assert(!bdrv_dirty_bitmap_frozen(bm
));
3258 QLIST_REMOVE(bitmap
, list
);
3259 hbitmap_free(bitmap
->bitmap
);
3260 g_free(bitmap
->name
);
3267 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3269 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3270 bitmap
->disabled
= true;
3273 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3275 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3276 bitmap
->disabled
= false;
3279 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3281 BdrvDirtyBitmap
*bm
;
3282 BlockDirtyInfoList
*list
= NULL
;
3283 BlockDirtyInfoList
**plist
= &list
;
3285 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3286 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3287 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3288 info
->count
= bdrv_get_dirty_count(bm
);
3289 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3290 info
->has_name
= !!bm
->name
;
3291 info
->name
= g_strdup(bm
->name
);
3292 info
->status
= bdrv_dirty_bitmap_status(bm
);
3293 entry
->value
= info
;
3295 plist
= &entry
->next
;
3301 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3304 return hbitmap_get(bitmap
->bitmap
, sector
);
3311 * Chooses a default granularity based on the existing cluster size,
3312 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3313 * is no cluster size information available.
3315 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3317 BlockDriverInfo bdi
;
3318 uint32_t granularity
;
3320 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3321 granularity
= MAX(4096, bdi
.cluster_size
);
3322 granularity
= MIN(65536, granularity
);
3324 granularity
= 65536;
3330 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3332 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3335 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3337 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3340 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3341 int64_t cur_sector
, int nr_sectors
)
3343 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3344 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3347 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3348 int64_t cur_sector
, int nr_sectors
)
3350 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3351 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3354 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3356 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3357 hbitmap_reset(bitmap
->bitmap
, 0, bitmap
->size
);
3360 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3363 BdrvDirtyBitmap
*bitmap
;
3364 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3365 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3368 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3372 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3375 BdrvDirtyBitmap
*bitmap
;
3376 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3377 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3380 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3385 * Advance an HBitmapIter to an arbitrary offset.
3387 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3390 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3393 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3395 return hbitmap_count(bitmap
->bitmap
);
3398 /* Get a reference to bs */
3399 void bdrv_ref(BlockDriverState
*bs
)
3404 /* Release a previously grabbed reference to bs.
3405 * If after releasing, reference count is zero, the BlockDriverState is
3407 void bdrv_unref(BlockDriverState
*bs
)
3412 assert(bs
->refcnt
> 0);
3413 if (--bs
->refcnt
== 0) {
3418 struct BdrvOpBlocker
{
3420 QLIST_ENTRY(BdrvOpBlocker
) list
;
3423 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3425 BdrvOpBlocker
*blocker
;
3426 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3427 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3428 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3430 error_setg(errp
, "Node '%s' is busy: %s",
3431 bdrv_get_device_or_node_name(bs
),
3432 error_get_pretty(blocker
->reason
));
3439 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3441 BdrvOpBlocker
*blocker
;
3442 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3444 blocker
= g_new0(BdrvOpBlocker
, 1);
3445 blocker
->reason
= reason
;
3446 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3449 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3451 BdrvOpBlocker
*blocker
, *next
;
3452 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3453 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3454 if (blocker
->reason
== reason
) {
3455 QLIST_REMOVE(blocker
, list
);
3461 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3464 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3465 bdrv_op_block(bs
, i
, reason
);
3469 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3472 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3473 bdrv_op_unblock(bs
, i
, reason
);
3477 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3481 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3482 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3489 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3491 bs
->iostatus_enabled
= true;
3492 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3495 /* The I/O status is only enabled if the drive explicitly
3496 * enables it _and_ the VM is configured to stop on errors */
3497 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3499 return (bs
->iostatus_enabled
&&
3500 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3501 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3502 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3505 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3507 bs
->iostatus_enabled
= false;
3510 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3512 if (bdrv_iostatus_is_enabled(bs
)) {
3513 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3515 block_job_iostatus_reset(bs
->job
);
3520 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3522 assert(bdrv_iostatus_is_enabled(bs
));
3523 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3524 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3525 BLOCK_DEVICE_IO_STATUS_FAILED
;
3529 void bdrv_img_create(const char *filename
, const char *fmt
,
3530 const char *base_filename
, const char *base_fmt
,
3531 char *options
, uint64_t img_size
, int flags
,
3532 Error
**errp
, bool quiet
)
3534 QemuOptsList
*create_opts
= NULL
;
3535 QemuOpts
*opts
= NULL
;
3536 const char *backing_fmt
, *backing_file
;
3538 BlockDriver
*drv
, *proto_drv
;
3539 BlockDriver
*backing_drv
= NULL
;
3540 Error
*local_err
= NULL
;
3543 /* Find driver and parse its options */
3544 drv
= bdrv_find_format(fmt
);
3546 error_setg(errp
, "Unknown file format '%s'", fmt
);
3550 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3555 if (!drv
->create_opts
) {
3556 error_setg(errp
, "Format driver '%s' does not support image creation",
3561 if (!proto_drv
->create_opts
) {
3562 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3563 proto_drv
->format_name
);
3567 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3568 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3570 /* Create parameter list with default values */
3571 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3572 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3574 /* Parse -o options */
3576 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3578 error_report_err(local_err
);
3580 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3585 if (base_filename
) {
3586 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3588 error_setg(errp
, "Backing file not supported for file format '%s'",
3595 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3597 error_setg(errp
, "Backing file format not supported for file "
3598 "format '%s'", fmt
);
3603 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3605 if (!strcmp(filename
, backing_file
)) {
3606 error_setg(errp
, "Error: Trying to create an image with the "
3607 "same filename as the backing file");
3612 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3614 backing_drv
= bdrv_find_format(backing_fmt
);
3616 error_setg(errp
, "Unknown backing file format '%s'",
3622 // The size for the image must always be specified, with one exception:
3623 // If we are using a backing file, we can obtain the size from there
3624 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3627 BlockDriverState
*bs
;
3628 char *full_backing
= g_new0(char, PATH_MAX
);
3632 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3633 full_backing
, PATH_MAX
,
3636 g_free(full_backing
);
3640 /* backing files always opened read-only */
3642 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3645 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
3646 backing_drv
, &local_err
);
3647 g_free(full_backing
);
3651 size
= bdrv_getlength(bs
);
3653 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3659 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3663 error_setg(errp
, "Image creation needs a size parameter");
3669 printf("Formatting '%s', fmt=%s", filename
, fmt
);
3670 qemu_opts_print(opts
, " ");
3674 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3676 if (ret
== -EFBIG
) {
3677 /* This is generally a better message than whatever the driver would
3678 * deliver (especially because of the cluster_size_hint), since that
3679 * is most probably not much different from "image too large". */
3680 const char *cluster_size_hint
= "";
3681 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3682 cluster_size_hint
= " (try using a larger cluster size)";
3684 error_setg(errp
, "The image size is too large for file format '%s'"
3685 "%s", fmt
, cluster_size_hint
);
3686 error_free(local_err
);
3691 qemu_opts_del(opts
);
3692 qemu_opts_free(create_opts
);
3694 error_propagate(errp
, local_err
);
3698 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3700 return bs
->aio_context
;
3703 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3705 BdrvAioNotifier
*baf
;
3711 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3712 baf
->detach_aio_context(baf
->opaque
);
3715 if (bs
->io_limits_enabled
) {
3716 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3718 if (bs
->drv
->bdrv_detach_aio_context
) {
3719 bs
->drv
->bdrv_detach_aio_context(bs
);
3722 bdrv_detach_aio_context(bs
->file
);
3724 if (bs
->backing_hd
) {
3725 bdrv_detach_aio_context(bs
->backing_hd
);
3728 bs
->aio_context
= NULL
;
3731 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3732 AioContext
*new_context
)
3734 BdrvAioNotifier
*ban
;
3740 bs
->aio_context
= new_context
;
3742 if (bs
->backing_hd
) {
3743 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3746 bdrv_attach_aio_context(bs
->file
, new_context
);
3748 if (bs
->drv
->bdrv_attach_aio_context
) {
3749 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3751 if (bs
->io_limits_enabled
) {
3752 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3755 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3756 ban
->attached_aio_context(new_context
, ban
->opaque
);
3760 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3762 bdrv_drain_all(); /* ensure there are no in-flight requests */
3764 bdrv_detach_aio_context(bs
);
3766 /* This function executes in the old AioContext so acquire the new one in
3767 * case it runs in a different thread.
3769 aio_context_acquire(new_context
);
3770 bdrv_attach_aio_context(bs
, new_context
);
3771 aio_context_release(new_context
);
3774 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3775 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3776 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3778 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3779 *ban
= (BdrvAioNotifier
){
3780 .attached_aio_context
= attached_aio_context
,
3781 .detach_aio_context
= detach_aio_context
,
3785 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3788 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3789 void (*attached_aio_context
)(AioContext
*,
3791 void (*detach_aio_context
)(void *),
3794 BdrvAioNotifier
*ban
, *ban_next
;
3796 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3797 if (ban
->attached_aio_context
== attached_aio_context
&&
3798 ban
->detach_aio_context
== detach_aio_context
&&
3799 ban
->opaque
== opaque
)
3801 QLIST_REMOVE(ban
, list
);
3811 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3812 BlockDriverAmendStatusCB
*status_cb
)
3814 if (!bs
->drv
->bdrv_amend_options
) {
3817 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3820 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3821 * of block filter and by bdrv_is_first_non_filter.
3822 * It is used to test if the given bs is the candidate or recurse more in the
3825 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3826 BlockDriverState
*candidate
)
3828 /* return false if basic checks fails */
3829 if (!bs
|| !bs
->drv
) {
3833 /* the code reached a non block filter driver -> check if the bs is
3834 * the same as the candidate. It's the recursion termination condition.
3836 if (!bs
->drv
->is_filter
) {
3837 return bs
== candidate
;
3839 /* Down this path the driver is a block filter driver */
3841 /* If the block filter recursion method is defined use it to recurse down
3844 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
3845 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
3848 /* the driver is a block filter but don't allow to recurse -> return false
3853 /* This function checks if the candidate is the first non filter bs down it's
3854 * bs chain. Since we don't have pointers to parents it explore all bs chains
3855 * from the top. Some filters can choose not to pass down the recursion.
3857 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
3859 BlockDriverState
*bs
;
3861 /* walk down the bs forest recursively */
3862 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3865 /* try to recurse in this top level bs */
3866 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
3868 /* candidate is the first non filter */
3877 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
3879 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
3880 AioContext
*aio_context
;
3882 if (!to_replace_bs
) {
3883 error_setg(errp
, "Node name '%s' not found", node_name
);
3887 aio_context
= bdrv_get_aio_context(to_replace_bs
);
3888 aio_context_acquire(aio_context
);
3890 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
3891 to_replace_bs
= NULL
;
3895 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3896 * most non filter in order to prevent data corruption.
3897 * Another benefit is that this tests exclude backing files which are
3898 * blocked by the backing blockers.
3900 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
3901 error_setg(errp
, "Only top most non filter can be replaced");
3902 to_replace_bs
= NULL
;
3907 aio_context_release(aio_context
);
3908 return to_replace_bs
;
3911 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
3913 const QDictEntry
*entry
;
3914 bool found_any
= false;
3916 for (entry
= qdict_first(bs
->options
); entry
;
3917 entry
= qdict_next(bs
->options
, entry
))
3919 /* Only take options for this level and exclude all non-driver-specific
3921 if (!strchr(qdict_entry_key(entry
), '.') &&
3922 strcmp(qdict_entry_key(entry
), "node-name"))
3924 qobject_incref(qdict_entry_value(entry
));
3925 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
3933 /* Updates the following BDS fields:
3934 * - exact_filename: A filename which may be used for opening a block device
3935 * which (mostly) equals the given BDS (even without any
3936 * other options; so reading and writing must return the same
3937 * results, but caching etc. may be different)
3938 * - full_open_options: Options which, when given when opening a block device
3939 * (without a filename), result in a BDS (mostly)
3940 * equalling the given one
3941 * - filename: If exact_filename is set, it is copied here. Otherwise,
3942 * full_open_options is converted to a JSON object, prefixed with
3943 * "json:" (for use through the JSON pseudo protocol) and put here.
3945 void bdrv_refresh_filename(BlockDriverState
*bs
)
3947 BlockDriver
*drv
= bs
->drv
;
3954 /* This BDS's file name will most probably depend on its file's name, so
3955 * refresh that first */
3957 bdrv_refresh_filename(bs
->file
);
3960 if (drv
->bdrv_refresh_filename
) {
3961 /* Obsolete information is of no use here, so drop the old file name
3962 * information before refreshing it */
3963 bs
->exact_filename
[0] = '\0';
3964 if (bs
->full_open_options
) {
3965 QDECREF(bs
->full_open_options
);
3966 bs
->full_open_options
= NULL
;
3969 drv
->bdrv_refresh_filename(bs
);
3970 } else if (bs
->file
) {
3971 /* Try to reconstruct valid information from the underlying file */
3972 bool has_open_options
;
3974 bs
->exact_filename
[0] = '\0';
3975 if (bs
->full_open_options
) {
3976 QDECREF(bs
->full_open_options
);
3977 bs
->full_open_options
= NULL
;
3981 has_open_options
= append_open_options(opts
, bs
);
3983 /* If no specific options have been given for this BDS, the filename of
3984 * the underlying file should suffice for this one as well */
3985 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
3986 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
3988 /* Reconstructing the full options QDict is simple for most format block
3989 * drivers, as long as the full options are known for the underlying
3990 * file BDS. The full options QDict of that file BDS should somehow
3991 * contain a representation of the filename, therefore the following
3992 * suffices without querying the (exact_)filename of this BDS. */
3993 if (bs
->file
->full_open_options
) {
3994 qdict_put_obj(opts
, "driver",
3995 QOBJECT(qstring_from_str(drv
->format_name
)));
3996 QINCREF(bs
->file
->full_open_options
);
3997 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
3999 bs
->full_open_options
= opts
;
4003 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
4004 /* There is no underlying file BDS (at least referenced by BDS.file),
4005 * so the full options QDict should be equal to the options given
4006 * specifically for this block device when it was opened (plus the
4007 * driver specification).
4008 * Because those options don't change, there is no need to update
4009 * full_open_options when it's already set. */
4012 append_open_options(opts
, bs
);
4013 qdict_put_obj(opts
, "driver",
4014 QOBJECT(qstring_from_str(drv
->format_name
)));
4016 if (bs
->exact_filename
[0]) {
4017 /* This may not work for all block protocol drivers (some may
4018 * require this filename to be parsed), but we have to find some
4019 * default solution here, so just include it. If some block driver
4020 * does not support pure options without any filename at all or
4021 * needs some special format of the options QDict, it needs to
4022 * implement the driver-specific bdrv_refresh_filename() function.
4024 qdict_put_obj(opts
, "filename",
4025 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4028 bs
->full_open_options
= opts
;
4031 if (bs
->exact_filename
[0]) {
4032 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4033 } else if (bs
->full_open_options
) {
4034 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4035 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4036 qstring_get_str(json
));
4041 /* This accessor function purpose is to allow the device models to access the
4042 * BlockAcctStats structure embedded inside a BlockDriverState without being
4043 * aware of the BlockDriverState structure layout.
4044 * It will go away when the BlockAcctStats structure will be moved inside
4045 * the device models.
4047 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)