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"
41 #include <sys/types.h>
43 #include <sys/ioctl.h>
44 #include <sys/queue.h>
55 * A BdrvDirtyBitmap can be in three possible states:
56 * (1) successor is NULL and disabled is false: full r/w mode
57 * (2) successor is NULL and disabled is true: read only mode ("disabled")
58 * (3) successor is set: frozen mode.
59 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
60 * or enabled. A frozen bitmap can only abdicate() or reclaim().
62 struct BdrvDirtyBitmap
{
63 HBitmap
*bitmap
; /* Dirty sector bitmap implementation */
64 BdrvDirtyBitmap
*successor
; /* Anonymous child; implies frozen status */
65 char *name
; /* Optional non-empty unique ID */
66 int64_t size
; /* Size of the bitmap (Number of sectors) */
67 bool disabled
; /* Bitmap is read-only */
68 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
71 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
73 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
74 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
76 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
77 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
79 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
80 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
82 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
);
83 /* If non-zero, use only whitelisted block drivers */
84 static int use_bdrv_whitelist
;
87 static int is_windows_drive_prefix(const char *filename
)
89 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
90 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
94 int is_windows_drive(const char *filename
)
96 if (is_windows_drive_prefix(filename
) &&
99 if (strstart(filename
, "\\\\.\\", NULL
) ||
100 strstart(filename
, "//./", NULL
))
106 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
108 if (!bs
|| !bs
->drv
) {
109 /* page size or 4k (hdd sector size) should be on the safe side */
110 return MAX(4096, getpagesize());
113 return bs
->bl
.opt_mem_alignment
;
116 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
118 if (!bs
|| !bs
->drv
) {
119 /* page size or 4k (hdd sector size) should be on the safe side */
120 return MAX(4096, getpagesize());
123 return bs
->bl
.min_mem_alignment
;
126 /* check if the path starts with "<protocol>:" */
127 int path_has_protocol(const char *path
)
132 if (is_windows_drive(path
) ||
133 is_windows_drive_prefix(path
)) {
136 p
= path
+ strcspn(path
, ":/\\");
138 p
= path
+ strcspn(path
, ":/");
144 int path_is_absolute(const char *path
)
147 /* specific case for names like: "\\.\d:" */
148 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
151 return (*path
== '/' || *path
== '\\');
153 return (*path
== '/');
157 /* if filename is absolute, just copy it to dest. Otherwise, build a
158 path to it by considering it is relative to base_path. URL are
160 void path_combine(char *dest
, int dest_size
,
161 const char *base_path
,
162 const char *filename
)
169 if (path_is_absolute(filename
)) {
170 pstrcpy(dest
, dest_size
, filename
);
172 p
= strchr(base_path
, ':');
177 p1
= strrchr(base_path
, '/');
181 p2
= strrchr(base_path
, '\\');
193 if (len
> dest_size
- 1)
195 memcpy(dest
, base_path
, len
);
197 pstrcat(dest
, dest_size
, filename
);
201 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
203 char *dest
, size_t sz
,
206 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
207 path_is_absolute(backing
))
209 pstrcpy(dest
, sz
, backing
);
210 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
211 error_setg(errp
, "Cannot use relative backing file names for '%s'",
214 path_combine(dest
, sz
, backed
, backing
);
218 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
221 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
223 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
227 void bdrv_register(BlockDriver
*bdrv
)
229 bdrv_setup_io_funcs(bdrv
);
231 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
234 BlockDriverState
*bdrv_new_root(void)
236 BlockDriverState
*bs
= bdrv_new();
238 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
242 BlockDriverState
*bdrv_new(void)
244 BlockDriverState
*bs
;
247 bs
= g_new0(BlockDriverState
, 1);
248 QLIST_INIT(&bs
->dirty_bitmaps
);
249 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
250 QLIST_INIT(&bs
->op_blockers
[i
]);
252 bdrv_iostatus_disable(bs
);
253 notifier_list_init(&bs
->close_notifiers
);
254 notifier_with_return_list_init(&bs
->before_write_notifiers
);
255 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
256 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
258 bs
->aio_context
= qemu_get_aio_context();
263 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
265 notifier_list_add(&bs
->close_notifiers
, notify
);
268 BlockDriver
*bdrv_find_format(const char *format_name
)
271 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
272 if (!strcmp(drv1
->format_name
, format_name
)) {
279 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
281 static const char *whitelist_rw
[] = {
282 CONFIG_BDRV_RW_WHITELIST
284 static const char *whitelist_ro
[] = {
285 CONFIG_BDRV_RO_WHITELIST
289 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
290 return 1; /* no whitelist, anything goes */
293 for (p
= whitelist_rw
; *p
; p
++) {
294 if (!strcmp(drv
->format_name
, *p
)) {
299 for (p
= whitelist_ro
; *p
; p
++) {
300 if (!strcmp(drv
->format_name
, *p
)) {
308 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
311 BlockDriver
*drv
= bdrv_find_format(format_name
);
312 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
315 typedef struct CreateCo
{
323 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
325 Error
*local_err
= NULL
;
328 CreateCo
*cco
= opaque
;
331 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
333 error_propagate(&cco
->err
, local_err
);
338 int bdrv_create(BlockDriver
*drv
, const char* filename
,
339 QemuOpts
*opts
, Error
**errp
)
346 .filename
= g_strdup(filename
),
352 if (!drv
->bdrv_create
) {
353 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
358 if (qemu_in_coroutine()) {
359 /* Fast-path if already in coroutine context */
360 bdrv_create_co_entry(&cco
);
362 co
= qemu_coroutine_create(bdrv_create_co_entry
);
363 qemu_coroutine_enter(co
, &cco
);
364 while (cco
.ret
== NOT_DONE
) {
365 aio_poll(qemu_get_aio_context(), true);
372 error_propagate(errp
, cco
.err
);
374 error_setg_errno(errp
, -ret
, "Could not create image");
379 g_free(cco
.filename
);
383 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
386 Error
*local_err
= NULL
;
389 drv
= bdrv_find_protocol(filename
, true, errp
);
394 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
396 error_propagate(errp
, local_err
);
402 * Try to get @bs's logical and physical block size.
403 * On success, store them in @bsz struct and return 0.
404 * On failure return -errno.
405 * @bs must not be empty.
407 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
409 BlockDriver
*drv
= bs
->drv
;
411 if (drv
&& drv
->bdrv_probe_blocksizes
) {
412 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
419 * Try to get @bs's geometry (cyls, heads, sectors).
420 * On success, store them in @geo struct and return 0.
421 * On failure return -errno.
422 * @bs must not be empty.
424 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
426 BlockDriver
*drv
= bs
->drv
;
428 if (drv
&& drv
->bdrv_probe_geometry
) {
429 return drv
->bdrv_probe_geometry(bs
, geo
);
436 * Create a uniquely-named empty temporary file.
437 * Return 0 upon success, otherwise a negative errno value.
439 int get_tmp_filename(char *filename
, int size
)
442 char temp_dir
[MAX_PATH
];
443 /* GetTempFileName requires that its output buffer (4th param)
444 have length MAX_PATH or greater. */
445 assert(size
>= MAX_PATH
);
446 return (GetTempPath(MAX_PATH
, temp_dir
)
447 && GetTempFileName(temp_dir
, "qem", 0, filename
)
448 ? 0 : -GetLastError());
452 tmpdir
= getenv("TMPDIR");
456 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
459 fd
= mkstemp(filename
);
463 if (close(fd
) != 0) {
472 * Detect host devices. By convention, /dev/cdrom[N] is always
473 * recognized as a host CDROM.
475 static BlockDriver
*find_hdev_driver(const char *filename
)
477 int score_max
= 0, score
;
478 BlockDriver
*drv
= NULL
, *d
;
480 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
481 if (d
->bdrv_probe_device
) {
482 score
= d
->bdrv_probe_device(filename
);
483 if (score
> score_max
) {
493 BlockDriver
*bdrv_find_protocol(const char *filename
,
494 bool allow_protocol_prefix
,
502 /* TODO Drivers without bdrv_file_open must be specified explicitly */
505 * XXX(hch): we really should not let host device detection
506 * override an explicit protocol specification, but moving this
507 * later breaks access to device names with colons in them.
508 * Thanks to the brain-dead persistent naming schemes on udev-
509 * based Linux systems those actually are quite common.
511 drv1
= find_hdev_driver(filename
);
516 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
520 p
= strchr(filename
, ':');
523 if (len
> sizeof(protocol
) - 1)
524 len
= sizeof(protocol
) - 1;
525 memcpy(protocol
, filename
, len
);
526 protocol
[len
] = '\0';
527 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
528 if (drv1
->protocol_name
&&
529 !strcmp(drv1
->protocol_name
, protocol
)) {
534 error_setg(errp
, "Unknown protocol '%s'", protocol
);
539 * Guess image format by probing its contents.
540 * This is not a good idea when your image is raw (CVE-2008-2004), but
541 * we do it anyway for backward compatibility.
543 * @buf contains the image's first @buf_size bytes.
544 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
545 * but can be smaller if the image file is smaller)
546 * @filename is its filename.
548 * For all block drivers, call the bdrv_probe() method to get its
550 * Return the first block driver with the highest probing score.
552 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
553 const char *filename
)
555 int score_max
= 0, score
;
556 BlockDriver
*drv
= NULL
, *d
;
558 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
560 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
561 if (score
> score_max
) {
571 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
572 BlockDriver
**pdrv
, Error
**errp
)
575 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
578 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
579 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
584 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
586 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
592 drv
= bdrv_probe_all(buf
, ret
, filename
);
594 error_setg(errp
, "Could not determine image format: No compatible "
603 * Set the current 'total_sectors' value
604 * Return 0 on success, -errno on error.
606 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
608 BlockDriver
*drv
= bs
->drv
;
610 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
614 /* query actual device if possible, otherwise just trust the hint */
615 if (drv
->bdrv_getlength
) {
616 int64_t length
= drv
->bdrv_getlength(bs
);
620 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
623 bs
->total_sectors
= hint
;
628 * Set open flags for a given discard mode
630 * Return 0 on success, -1 if the discard mode was invalid.
632 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
634 *flags
&= ~BDRV_O_UNMAP
;
636 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
638 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
639 *flags
|= BDRV_O_UNMAP
;
648 * Set open flags for a given cache mode
650 * Return 0 on success, -1 if the cache mode was invalid.
652 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
654 *flags
&= ~BDRV_O_CACHE_MASK
;
656 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
657 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
658 } else if (!strcmp(mode
, "directsync")) {
659 *flags
|= BDRV_O_NOCACHE
;
660 } else if (!strcmp(mode
, "writeback")) {
661 *flags
|= BDRV_O_CACHE_WB
;
662 } else if (!strcmp(mode
, "unsafe")) {
663 *flags
|= BDRV_O_CACHE_WB
;
664 *flags
|= BDRV_O_NO_FLUSH
;
665 } else if (!strcmp(mode
, "writethrough")) {
666 /* this is the default */
675 * Returns the flags that a temporary snapshot should get, based on the
676 * originally requested flags (the originally requested image will have flags
677 * like a backing file)
679 static int bdrv_temp_snapshot_flags(int flags
)
681 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
685 * Returns the flags that bs->file should get, based on the given flags for
688 static int bdrv_inherited_flags(int flags
)
690 /* Enable protocol handling, disable format probing for bs->file */
691 flags
|= BDRV_O_PROTOCOL
;
693 /* Our block drivers take care to send flushes and respect unmap policy,
694 * so we can enable both unconditionally on lower layers. */
695 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
697 /* Clear flags that only apply to the top layer */
698 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
704 * Returns the flags that bs->backing_hd should get, based on the given flags
707 static int bdrv_backing_flags(int flags
)
709 /* backing files always opened read-only */
710 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
712 /* snapshot=on is handled on the top layer */
713 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
718 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
720 int open_flags
= flags
| BDRV_O_CACHE_WB
;
723 * Clear flags that are internal to the block layer before opening the
726 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
729 * Snapshots should be writable.
731 if (flags
& BDRV_O_TEMPORARY
) {
732 open_flags
|= BDRV_O_RDWR
;
738 static void bdrv_assign_node_name(BlockDriverState
*bs
,
739 const char *node_name
,
746 /* Check for empty string or invalid characters */
747 if (!id_wellformed(node_name
)) {
748 error_setg(errp
, "Invalid node name");
752 /* takes care of avoiding namespaces collisions */
753 if (blk_by_name(node_name
)) {
754 error_setg(errp
, "node-name=%s is conflicting with a device id",
759 /* takes care of avoiding duplicates node names */
760 if (bdrv_find_node(node_name
)) {
761 error_setg(errp
, "Duplicate node name");
765 /* copy node name into the bs and insert it into the graph list */
766 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
767 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
771 * Common part for opening disk images and files
773 * Removes all processed options from *options.
775 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
776 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
779 const char *filename
;
780 const char *node_name
= NULL
;
781 Error
*local_err
= NULL
;
784 assert(bs
->file
== NULL
);
785 assert(options
!= NULL
&& bs
->options
!= options
);
788 filename
= file
->filename
;
790 filename
= qdict_get_try_str(options
, "filename");
793 if (drv
->bdrv_needs_filename
&& !filename
) {
794 error_setg(errp
, "The '%s' block driver requires a file name",
799 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
801 node_name
= qdict_get_try_str(options
, "node-name");
802 bdrv_assign_node_name(bs
, node_name
, &local_err
);
804 error_propagate(errp
, local_err
);
807 qdict_del(options
, "node-name");
809 /* bdrv_open() with directly using a protocol as drv. This layer is already
810 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
811 * and return immediately. */
812 if (file
!= NULL
&& drv
->bdrv_file_open
) {
817 bs
->open_flags
= flags
;
818 bs
->guest_block_size
= 512;
819 bs
->request_alignment
= 512;
820 bs
->zero_beyond_eof
= true;
821 open_flags
= bdrv_open_flags(bs
, flags
);
822 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
824 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
826 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
827 ? "Driver '%s' can only be used for read-only devices"
828 : "Driver '%s' is not whitelisted",
833 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
834 if (flags
& BDRV_O_COPY_ON_READ
) {
835 if (!bs
->read_only
) {
836 bdrv_enable_copy_on_read(bs
);
838 error_setg(errp
, "Can't use copy-on-read on read-only device");
843 if (filename
!= NULL
) {
844 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
846 bs
->filename
[0] = '\0';
848 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
851 bs
->opaque
= g_malloc0(drv
->instance_size
);
853 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
855 /* Open the image, either directly or using a protocol */
856 if (drv
->bdrv_file_open
) {
857 assert(file
== NULL
);
858 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
859 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
862 error_setg(errp
, "Can't use '%s' as a block driver for the "
863 "protocol level", drv
->format_name
);
868 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
873 error_propagate(errp
, local_err
);
874 } else if (bs
->filename
[0]) {
875 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
877 error_setg_errno(errp
, -ret
, "Could not open image");
883 error_report("Encrypted images are deprecated");
884 error_printf("Support for them will be removed in a future release.\n"
885 "You can use 'qemu-img convert' to convert your image"
886 " to an unencrypted one.\n");
889 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
891 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
895 bdrv_refresh_limits(bs
, &local_err
);
897 error_propagate(errp
, local_err
);
902 assert(bdrv_opt_mem_align(bs
) != 0);
903 assert(bdrv_min_mem_align(bs
) != 0);
904 assert((bs
->request_alignment
!= 0) || bs
->sg
);
915 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
917 QObject
*options_obj
;
921 ret
= strstart(filename
, "json:", &filename
);
924 options_obj
= qobject_from_json(filename
);
926 error_setg(errp
, "Could not parse the JSON options");
930 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
931 qobject_decref(options_obj
);
932 error_setg(errp
, "Invalid JSON object given");
936 options
= qobject_to_qdict(options_obj
);
937 qdict_flatten(options
);
943 * Fills in default options for opening images and converts the legacy
944 * filename/flags pair to option QDict entries.
946 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
947 BlockDriver
*drv
, Error
**errp
)
949 const char *filename
= *pfilename
;
951 bool protocol
= flags
& BDRV_O_PROTOCOL
;
952 bool parse_filename
= false;
953 Error
*local_err
= NULL
;
955 /* Parse json: pseudo-protocol */
956 if (filename
&& g_str_has_prefix(filename
, "json:")) {
957 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
959 error_propagate(errp
, local_err
);
963 /* Options given in the filename have lower priority than options
964 * specified directly */
965 qdict_join(*options
, json_options
, false);
966 QDECREF(json_options
);
967 *pfilename
= filename
= NULL
;
970 /* Fetch the file name from the options QDict if necessary */
971 if (protocol
&& filename
) {
972 if (!qdict_haskey(*options
, "filename")) {
973 qdict_put(*options
, "filename", qstring_from_str(filename
));
974 parse_filename
= true;
976 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
982 /* Find the right block driver */
983 filename
= qdict_get_try_str(*options
, "filename");
984 drvname
= qdict_get_try_str(*options
, "driver");
988 error_setg(errp
, "Driver specified twice");
991 drvname
= drv
->format_name
;
992 qdict_put(*options
, "driver", qstring_from_str(drvname
));
994 if (!drvname
&& protocol
) {
996 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1001 drvname
= drv
->format_name
;
1002 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1004 error_setg(errp
, "Must specify either driver or file");
1007 } else if (drvname
) {
1008 drv
= bdrv_find_format(drvname
);
1010 error_setg(errp
, "Unknown driver '%s'", drvname
);
1016 assert(drv
|| !protocol
);
1018 /* Driver-specific filename parsing */
1019 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1020 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1022 error_propagate(errp
, local_err
);
1026 if (!drv
->bdrv_needs_filename
) {
1027 qdict_del(*options
, "filename");
1034 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1037 if (bs
->backing_hd
) {
1038 assert(bs
->backing_blocker
);
1039 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1040 } else if (backing_hd
) {
1041 error_setg(&bs
->backing_blocker
,
1042 "node is used as backing hd of '%s'",
1043 bdrv_get_device_or_node_name(bs
));
1046 bs
->backing_hd
= backing_hd
;
1048 error_free(bs
->backing_blocker
);
1049 bs
->backing_blocker
= NULL
;
1052 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1053 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1054 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1055 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1057 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1058 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1059 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1060 bs
->backing_blocker
);
1062 bdrv_refresh_limits(bs
, NULL
);
1066 * Opens the backing file for a BlockDriverState if not yet open
1068 * options is a QDict of options to pass to the block drivers, or NULL for an
1069 * empty set of options. The reference to the QDict is transferred to this
1070 * function (even on failure), so if the caller intends to reuse the dictionary,
1071 * it needs to use QINCREF() before calling bdrv_file_open.
1073 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1075 char *backing_filename
= g_malloc0(PATH_MAX
);
1077 BlockDriverState
*backing_hd
;
1078 Error
*local_err
= NULL
;
1080 if (bs
->backing_hd
!= NULL
) {
1085 /* NULL means an empty set of options */
1086 if (options
== NULL
) {
1087 options
= qdict_new();
1090 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1091 if (qdict_haskey(options
, "file.filename")) {
1092 backing_filename
[0] = '\0';
1093 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1097 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1101 error_propagate(errp
, local_err
);
1107 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1109 error_setg(errp
, "Driver doesn't support backing files");
1114 backing_hd
= bdrv_new();
1116 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1117 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1120 assert(bs
->backing_hd
== NULL
);
1121 ret
= bdrv_open(&backing_hd
,
1122 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1123 bdrv_backing_flags(bs
->open_flags
), NULL
, &local_err
);
1125 bdrv_unref(backing_hd
);
1127 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1128 error_setg(errp
, "Could not open backing file: %s",
1129 error_get_pretty(local_err
));
1130 error_free(local_err
);
1133 bdrv_set_backing_hd(bs
, backing_hd
);
1136 g_free(backing_filename
);
1141 * Opens a disk image whose options are given as BlockdevRef in another block
1144 * If allow_none is true, no image will be opened if filename is false and no
1145 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1147 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1148 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1149 * itself, all options starting with "${bdref_key}." are considered part of the
1152 * The BlockdevRef will be removed from the options QDict.
1154 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1156 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1157 QDict
*options
, const char *bdref_key
, int flags
,
1158 bool allow_none
, Error
**errp
)
1160 QDict
*image_options
;
1162 char *bdref_key_dot
;
1163 const char *reference
;
1166 assert(*pbs
== NULL
);
1168 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1169 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1170 g_free(bdref_key_dot
);
1172 reference
= qdict_get_try_str(options
, bdref_key
);
1173 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1177 error_setg(errp
, "A block device must be specified for \"%s\"",
1181 QDECREF(image_options
);
1185 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1188 qdict_del(options
, bdref_key
);
1192 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1194 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1195 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1197 QemuOpts
*opts
= NULL
;
1198 QDict
*snapshot_options
;
1199 BlockDriverState
*bs_snapshot
;
1203 /* if snapshot, we create a temporary backing file and open it
1204 instead of opening 'filename' directly */
1206 /* Get the required size from the image */
1207 total_size
= bdrv_getlength(bs
);
1208 if (total_size
< 0) {
1210 error_setg_errno(errp
, -total_size
, "Could not get image size");
1214 /* Create the temporary image */
1215 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1217 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1221 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1223 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1224 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1225 qemu_opts_del(opts
);
1227 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1228 "'%s': %s", tmp_filename
,
1229 error_get_pretty(local_err
));
1230 error_free(local_err
);
1234 /* Prepare a new options QDict for the temporary file */
1235 snapshot_options
= qdict_new();
1236 qdict_put(snapshot_options
, "file.driver",
1237 qstring_from_str("file"));
1238 qdict_put(snapshot_options
, "file.filename",
1239 qstring_from_str(tmp_filename
));
1241 bs_snapshot
= bdrv_new();
1243 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1244 flags
, &bdrv_qcow2
, &local_err
);
1246 error_propagate(errp
, local_err
);
1250 bdrv_append(bs_snapshot
, bs
);
1253 g_free(tmp_filename
);
1258 * Opens a disk image (raw, qcow2, vmdk, ...)
1260 * options is a QDict of options to pass to the block drivers, or NULL for an
1261 * empty set of options. The reference to the QDict belongs to the block layer
1262 * after the call (even on failure), so if the caller intends to reuse the
1263 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1265 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1266 * If it is not NULL, the referenced BDS will be reused.
1268 * The reference parameter may be used to specify an existing block device which
1269 * should be opened. If specified, neither options nor a filename may be given,
1270 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1272 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1273 const char *reference
, QDict
*options
, int flags
,
1274 BlockDriver
*drv
, Error
**errp
)
1277 BlockDriverState
*file
= NULL
, *bs
;
1278 const char *drvname
;
1279 Error
*local_err
= NULL
;
1280 int snapshot_flags
= 0;
1285 bool options_non_empty
= options
? qdict_size(options
) : false;
1289 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1290 "another block device");
1294 if (filename
|| options_non_empty
) {
1295 error_setg(errp
, "Cannot reference an existing block device with "
1296 "additional options or a new filename");
1300 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1315 /* NULL means an empty set of options */
1316 if (options
== NULL
) {
1317 options
= qdict_new();
1320 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1325 /* Find the right image format driver */
1327 drvname
= qdict_get_try_str(options
, "driver");
1329 drv
= bdrv_find_format(drvname
);
1330 qdict_del(options
, "driver");
1332 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1338 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1339 if (drv
&& !drv
->bdrv_file_open
) {
1340 /* If the user explicitly wants a format driver here, we'll need to add
1341 * another layer for the protocol in bs->file */
1342 flags
&= ~BDRV_O_PROTOCOL
;
1345 bs
->options
= options
;
1346 options
= qdict_clone_shallow(options
);
1348 /* Open image file without format layer */
1349 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1350 if (flags
& BDRV_O_RDWR
) {
1351 flags
|= BDRV_O_ALLOW_RDWR
;
1353 if (flags
& BDRV_O_SNAPSHOT
) {
1354 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1355 flags
= bdrv_backing_flags(flags
);
1358 assert(file
== NULL
);
1359 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1360 bdrv_inherited_flags(flags
),
1367 /* Image format probing */
1370 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1375 error_setg(errp
, "Must specify either driver or file");
1380 /* Open the image */
1381 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1386 if (file
&& (bs
->file
!= file
)) {
1391 /* If there is a backing file, use it */
1392 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1393 QDict
*backing_options
;
1395 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1396 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1398 goto close_and_fail
;
1402 bdrv_refresh_filename(bs
);
1404 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1405 * temporary snapshot afterwards. */
1406 if (snapshot_flags
) {
1407 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1409 goto close_and_fail
;
1413 /* Check if any unknown options were used */
1414 if (options
&& (qdict_size(options
) != 0)) {
1415 const QDictEntry
*entry
= qdict_first(options
);
1416 if (flags
& BDRV_O_PROTOCOL
) {
1417 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1418 "'%s'", drv
->format_name
, entry
->key
);
1420 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1421 "support the option '%s'", drv
->format_name
,
1422 bdrv_get_device_name(bs
), entry
->key
);
1426 goto close_and_fail
;
1429 if (!bdrv_key_required(bs
)) {
1431 blk_dev_change_media_cb(bs
->blk
, true);
1433 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1434 && !runstate_check(RUN_STATE_INMIGRATE
)
1435 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1437 "Guest must be stopped for opening of encrypted image");
1439 goto close_and_fail
;
1450 QDECREF(bs
->options
);
1454 /* If *pbs is NULL, a new BDS has been created in this function and
1455 needs to be freed now. Otherwise, it does not need to be closed,
1456 since it has not really been opened yet. */
1460 error_propagate(errp
, local_err
);
1465 /* See fail path, but now the BDS has to be always closed */
1473 error_propagate(errp
, local_err
);
1478 typedef struct BlockReopenQueueEntry
{
1480 BDRVReopenState state
;
1481 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1482 } BlockReopenQueueEntry
;
1485 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1486 * reopen of multiple devices.
1488 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1489 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1490 * be created and initialized. This newly created BlockReopenQueue should be
1491 * passed back in for subsequent calls that are intended to be of the same
1494 * bs is the BlockDriverState to add to the reopen queue.
1496 * flags contains the open flags for the associated bs
1498 * returns a pointer to bs_queue, which is either the newly allocated
1499 * bs_queue, or the existing bs_queue being used.
1502 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1503 BlockDriverState
*bs
, int flags
)
1507 BlockReopenQueueEntry
*bs_entry
;
1508 if (bs_queue
== NULL
) {
1509 bs_queue
= g_new0(BlockReopenQueue
, 1);
1510 QSIMPLEQ_INIT(bs_queue
);
1513 /* bdrv_open() masks this flag out */
1514 flags
&= ~BDRV_O_PROTOCOL
;
1517 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1520 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1521 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1523 bs_entry
->state
.bs
= bs
;
1524 bs_entry
->state
.flags
= flags
;
1530 * Reopen multiple BlockDriverStates atomically & transactionally.
1532 * The queue passed in (bs_queue) must have been built up previous
1533 * via bdrv_reopen_queue().
1535 * Reopens all BDS specified in the queue, with the appropriate
1536 * flags. All devices are prepared for reopen, and failure of any
1537 * device will cause all device changes to be abandonded, and intermediate
1540 * If all devices prepare successfully, then the changes are committed
1544 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1547 BlockReopenQueueEntry
*bs_entry
, *next
;
1548 Error
*local_err
= NULL
;
1550 assert(bs_queue
!= NULL
);
1554 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1555 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1556 error_propagate(errp
, local_err
);
1559 bs_entry
->prepared
= true;
1562 /* If we reach this point, we have success and just need to apply the
1565 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1566 bdrv_reopen_commit(&bs_entry
->state
);
1572 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1573 if (ret
&& bs_entry
->prepared
) {
1574 bdrv_reopen_abort(&bs_entry
->state
);
1583 /* Reopen a single BlockDriverState with the specified flags. */
1584 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1587 Error
*local_err
= NULL
;
1588 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1590 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1591 if (local_err
!= NULL
) {
1592 error_propagate(errp
, local_err
);
1599 * Prepares a BlockDriverState for reopen. All changes are staged in the
1600 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1601 * the block driver layer .bdrv_reopen_prepare()
1603 * bs is the BlockDriverState to reopen
1604 * flags are the new open flags
1605 * queue is the reopen queue
1607 * Returns 0 on success, non-zero on error. On error errp will be set
1610 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1611 * It is the responsibility of the caller to then call the abort() or
1612 * commit() for any other BDS that have been left in a prepare() state
1615 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1619 Error
*local_err
= NULL
;
1622 assert(reopen_state
!= NULL
);
1623 assert(reopen_state
->bs
->drv
!= NULL
);
1624 drv
= reopen_state
->bs
->drv
;
1626 /* if we are to stay read-only, do not allow permission change
1628 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1629 reopen_state
->flags
& BDRV_O_RDWR
) {
1630 error_setg(errp
, "Node '%s' is read only",
1631 bdrv_get_device_or_node_name(reopen_state
->bs
));
1636 ret
= bdrv_flush(reopen_state
->bs
);
1638 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1643 if (drv
->bdrv_reopen_prepare
) {
1644 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1646 if (local_err
!= NULL
) {
1647 error_propagate(errp
, local_err
);
1649 error_setg(errp
, "failed while preparing to reopen image '%s'",
1650 reopen_state
->bs
->filename
);
1655 /* It is currently mandatory to have a bdrv_reopen_prepare()
1656 * handler for each supported drv. */
1657 error_setg(errp
, "Block format '%s' used by node '%s' "
1658 "does not support reopening files", drv
->format_name
,
1659 bdrv_get_device_or_node_name(reopen_state
->bs
));
1671 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1672 * makes them final by swapping the staging BlockDriverState contents into
1673 * the active BlockDriverState contents.
1675 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1679 assert(reopen_state
!= NULL
);
1680 drv
= reopen_state
->bs
->drv
;
1681 assert(drv
!= NULL
);
1683 /* If there are any driver level actions to take */
1684 if (drv
->bdrv_reopen_commit
) {
1685 drv
->bdrv_reopen_commit(reopen_state
);
1688 /* set BDS specific flags now */
1689 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1690 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1692 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1694 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1698 * Abort the reopen, and delete and free the staged changes in
1701 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1705 assert(reopen_state
!= NULL
);
1706 drv
= reopen_state
->bs
->drv
;
1707 assert(drv
!= NULL
);
1709 if (drv
->bdrv_reopen_abort
) {
1710 drv
->bdrv_reopen_abort(reopen_state
);
1715 void bdrv_close(BlockDriverState
*bs
)
1717 BdrvAioNotifier
*ban
, *ban_next
;
1720 block_job_cancel_sync(bs
->job
);
1722 bdrv_drain_all(); /* complete I/O */
1724 bdrv_drain_all(); /* in case flush left pending I/O */
1725 notifier_list_notify(&bs
->close_notifiers
, bs
);
1728 if (bs
->backing_hd
) {
1729 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1730 bdrv_set_backing_hd(bs
, NULL
);
1731 bdrv_unref(backing_hd
);
1733 bs
->drv
->bdrv_close(bs
);
1737 bs
->copy_on_read
= 0;
1738 bs
->backing_file
[0] = '\0';
1739 bs
->backing_format
[0] = '\0';
1740 bs
->total_sectors
= 0;
1744 bs
->zero_beyond_eof
= false;
1745 QDECREF(bs
->options
);
1747 QDECREF(bs
->full_open_options
);
1748 bs
->full_open_options
= NULL
;
1750 if (bs
->file
!= NULL
) {
1751 bdrv_unref(bs
->file
);
1757 blk_dev_change_media_cb(bs
->blk
, false);
1760 /*throttling disk I/O limits*/
1761 if (bs
->io_limits_enabled
) {
1762 bdrv_io_limits_disable(bs
);
1765 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1768 QLIST_INIT(&bs
->aio_notifiers
);
1771 void bdrv_close_all(void)
1773 BlockDriverState
*bs
;
1775 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1776 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1778 aio_context_acquire(aio_context
);
1780 aio_context_release(aio_context
);
1784 /* make a BlockDriverState anonymous by removing from bdrv_state and
1785 * graph_bdrv_state list.
1786 Also, NULL terminate the device_name to prevent double remove */
1787 void bdrv_make_anon(BlockDriverState
*bs
)
1790 * Take care to remove bs from bdrv_states only when it's actually
1791 * in it. Note that bs->device_list.tqe_prev is initially null,
1792 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1793 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1794 * resetting it to null on remove.
1796 if (bs
->device_list
.tqe_prev
) {
1797 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1798 bs
->device_list
.tqe_prev
= NULL
;
1800 if (bs
->node_name
[0] != '\0') {
1801 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1803 bs
->node_name
[0] = '\0';
1806 static void bdrv_rebind(BlockDriverState
*bs
)
1808 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1809 bs
->drv
->bdrv_rebind(bs
);
1813 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1814 BlockDriverState
*bs_src
)
1816 /* move some fields that need to stay attached to the device */
1819 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1820 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1822 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1824 /* i/o throttled req */
1825 bs_dest
->throttle_state
= bs_src
->throttle_state
,
1826 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1827 bs_dest
->pending_reqs
[0] = bs_src
->pending_reqs
[0];
1828 bs_dest
->pending_reqs
[1] = bs_src
->pending_reqs
[1];
1829 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1830 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1831 memcpy(&bs_dest
->round_robin
,
1832 &bs_src
->round_robin
,
1833 sizeof(bs_dest
->round_robin
));
1834 memcpy(&bs_dest
->throttle_timers
,
1835 &bs_src
->throttle_timers
,
1836 sizeof(ThrottleTimers
));
1839 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1840 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1843 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1844 bs_dest
->iostatus
= bs_src
->iostatus
;
1847 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1849 /* reference count */
1850 bs_dest
->refcnt
= bs_src
->refcnt
;
1853 bs_dest
->job
= bs_src
->job
;
1855 /* keep the same entry in bdrv_states */
1856 bs_dest
->device_list
= bs_src
->device_list
;
1857 bs_dest
->blk
= bs_src
->blk
;
1859 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1860 sizeof(bs_dest
->op_blockers
));
1864 * Swap bs contents for two image chains while they are live,
1865 * while keeping required fields on the BlockDriverState that is
1866 * actually attached to a device.
1868 * This will modify the BlockDriverState fields, and swap contents
1869 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1871 * bs_new must not be attached to a BlockBackend.
1873 * This function does not create any image files.
1875 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1877 BlockDriverState tmp
;
1879 /* The code needs to swap the node_name but simply swapping node_list won't
1880 * work so first remove the nodes from the graph list, do the swap then
1881 * insert them back if needed.
1883 if (bs_new
->node_name
[0] != '\0') {
1884 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
1886 if (bs_old
->node_name
[0] != '\0') {
1887 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
1890 /* bs_new must be unattached and shouldn't have anything fancy enabled */
1891 assert(!bs_new
->blk
);
1892 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
1893 assert(bs_new
->job
== NULL
);
1894 assert(bs_new
->io_limits_enabled
== false);
1895 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
1901 /* there are some fields that should not be swapped, move them back */
1902 bdrv_move_feature_fields(&tmp
, bs_old
);
1903 bdrv_move_feature_fields(bs_old
, bs_new
);
1904 bdrv_move_feature_fields(bs_new
, &tmp
);
1906 /* bs_new must remain unattached */
1907 assert(!bs_new
->blk
);
1909 /* Check a few fields that should remain attached to the device */
1910 assert(bs_new
->job
== NULL
);
1911 assert(bs_new
->io_limits_enabled
== false);
1912 assert(!throttle_timers_are_initialized(&bs_new
->throttle_timers
));
1914 /* insert the nodes back into the graph node list if needed */
1915 if (bs_new
->node_name
[0] != '\0') {
1916 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
1918 if (bs_old
->node_name
[0] != '\0') {
1919 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
1922 bdrv_rebind(bs_new
);
1923 bdrv_rebind(bs_old
);
1927 * Add new bs contents at the top of an image chain while the chain is
1928 * live, while keeping required fields on the top layer.
1930 * This will modify the BlockDriverState fields, and swap contents
1931 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1933 * bs_new must not be attached to a BlockBackend.
1935 * This function does not create any image files.
1937 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1939 bdrv_swap(bs_new
, bs_top
);
1941 /* The contents of 'tmp' will become bs_top, as we are
1942 * swapping bs_new and bs_top contents. */
1943 bdrv_set_backing_hd(bs_top
, bs_new
);
1946 static void bdrv_delete(BlockDriverState
*bs
)
1949 assert(bdrv_op_blocker_is_empty(bs
));
1950 assert(!bs
->refcnt
);
1951 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
1955 /* remove from list, if necessary */
1962 * Run consistency checks on an image
1964 * Returns 0 if the check could be completed (it doesn't mean that the image is
1965 * free of errors) or -errno when an internal error occurred. The results of the
1966 * check are stored in res.
1968 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1970 if (bs
->drv
== NULL
) {
1973 if (bs
->drv
->bdrv_check
== NULL
) {
1977 memset(res
, 0, sizeof(*res
));
1978 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1981 #define COMMIT_BUF_SECTORS 2048
1983 /* commit COW file into the raw image */
1984 int bdrv_commit(BlockDriverState
*bs
)
1986 BlockDriver
*drv
= bs
->drv
;
1987 int64_t sector
, total_sectors
, length
, backing_length
;
1988 int n
, ro
, open_flags
;
1990 uint8_t *buf
= NULL
;
1995 if (!bs
->backing_hd
) {
1999 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2000 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2004 ro
= bs
->backing_hd
->read_only
;
2005 open_flags
= bs
->backing_hd
->open_flags
;
2008 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2013 length
= bdrv_getlength(bs
);
2019 backing_length
= bdrv_getlength(bs
->backing_hd
);
2020 if (backing_length
< 0) {
2021 ret
= backing_length
;
2025 /* If our top snapshot is larger than the backing file image,
2026 * grow the backing file image if possible. If not possible,
2027 * we must return an error */
2028 if (length
> backing_length
) {
2029 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2035 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2037 /* qemu_try_blockalign() for bs will choose an alignment that works for
2038 * bs->backing_hd as well, so no need to compare the alignment manually. */
2039 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2045 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2046 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2051 ret
= bdrv_read(bs
, sector
, buf
, n
);
2056 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2063 if (drv
->bdrv_make_empty
) {
2064 ret
= drv
->bdrv_make_empty(bs
);
2072 * Make sure all data we wrote to the backing device is actually
2075 if (bs
->backing_hd
) {
2076 bdrv_flush(bs
->backing_hd
);
2084 /* ignoring error return here */
2085 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2091 int bdrv_commit_all(void)
2093 BlockDriverState
*bs
;
2095 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2096 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2098 aio_context_acquire(aio_context
);
2099 if (bs
->drv
&& bs
->backing_hd
) {
2100 int ret
= bdrv_commit(bs
);
2102 aio_context_release(aio_context
);
2106 aio_context_release(aio_context
);
2114 * -EINVAL - backing format specified, but no file
2115 * -ENOSPC - can't update the backing file because no space is left in the
2117 * -ENOTSUP - format driver doesn't support changing the backing file
2119 int bdrv_change_backing_file(BlockDriverState
*bs
,
2120 const char *backing_file
, const char *backing_fmt
)
2122 BlockDriver
*drv
= bs
->drv
;
2125 /* Backing file format doesn't make sense without a backing file */
2126 if (backing_fmt
&& !backing_file
) {
2130 if (drv
->bdrv_change_backing_file
!= NULL
) {
2131 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2137 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2138 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2144 * Finds the image layer in the chain that has 'bs' as its backing file.
2146 * active is the current topmost image.
2148 * Returns NULL if bs is not found in active's image chain,
2149 * or if active == bs.
2151 * Returns the bottommost base image if bs == NULL.
2153 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2154 BlockDriverState
*bs
)
2156 while (active
&& bs
!= active
->backing_hd
) {
2157 active
= active
->backing_hd
;
2163 /* Given a BDS, searches for the base layer. */
2164 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2166 return bdrv_find_overlay(bs
, NULL
);
2169 typedef struct BlkIntermediateStates
{
2170 BlockDriverState
*bs
;
2171 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2172 } BlkIntermediateStates
;
2176 * Drops images above 'base' up to and including 'top', and sets the image
2177 * above 'top' to have base as its backing file.
2179 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2180 * information in 'bs' can be properly updated.
2182 * E.g., this will convert the following chain:
2183 * bottom <- base <- intermediate <- top <- active
2187 * bottom <- base <- active
2189 * It is allowed for bottom==base, in which case it converts:
2191 * base <- intermediate <- top <- active
2197 * If backing_file_str is non-NULL, it will be used when modifying top's
2198 * overlay image metadata.
2201 * if active == top, that is considered an error
2204 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2205 BlockDriverState
*base
, const char *backing_file_str
)
2207 BlockDriverState
*intermediate
;
2208 BlockDriverState
*base_bs
= NULL
;
2209 BlockDriverState
*new_top_bs
= NULL
;
2210 BlkIntermediateStates
*intermediate_state
, *next
;
2213 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2214 QSIMPLEQ_INIT(&states_to_delete
);
2216 if (!top
->drv
|| !base
->drv
) {
2220 new_top_bs
= bdrv_find_overlay(active
, top
);
2222 if (new_top_bs
== NULL
) {
2223 /* we could not find the image above 'top', this is an error */
2227 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2228 * to do, no intermediate images */
2229 if (new_top_bs
->backing_hd
== base
) {
2236 /* now we will go down through the list, and add each BDS we find
2237 * into our deletion queue, until we hit the 'base'
2239 while (intermediate
) {
2240 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2241 intermediate_state
->bs
= intermediate
;
2242 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2244 if (intermediate
->backing_hd
== base
) {
2245 base_bs
= intermediate
->backing_hd
;
2248 intermediate
= intermediate
->backing_hd
;
2250 if (base_bs
== NULL
) {
2251 /* something went wrong, we did not end at the base. safely
2252 * unravel everything, and exit with error */
2256 /* success - we can delete the intermediate states, and link top->base */
2257 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2258 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2259 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2263 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2265 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2266 /* so that bdrv_close() does not recursively close the chain */
2267 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2268 bdrv_unref(intermediate_state
->bs
);
2273 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2274 g_free(intermediate_state
);
2280 * Truncate file to 'offset' bytes (needed only for file protocols)
2282 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2284 BlockDriver
*drv
= bs
->drv
;
2288 if (!drv
->bdrv_truncate
)
2293 ret
= drv
->bdrv_truncate(bs
, offset
);
2295 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2296 bdrv_dirty_bitmap_truncate(bs
);
2298 blk_dev_resize_cb(bs
->blk
);
2305 * Length of a allocated file in bytes. Sparse files are counted by actual
2306 * allocated space. Return < 0 if error or unknown.
2308 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2310 BlockDriver
*drv
= bs
->drv
;
2314 if (drv
->bdrv_get_allocated_file_size
) {
2315 return drv
->bdrv_get_allocated_file_size(bs
);
2318 return bdrv_get_allocated_file_size(bs
->file
);
2324 * Return number of sectors on success, -errno on error.
2326 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2328 BlockDriver
*drv
= bs
->drv
;
2333 if (drv
->has_variable_length
) {
2334 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2339 return bs
->total_sectors
;
2343 * Return length in bytes on success, -errno on error.
2344 * The length is always a multiple of BDRV_SECTOR_SIZE.
2346 int64_t bdrv_getlength(BlockDriverState
*bs
)
2348 int64_t ret
= bdrv_nb_sectors(bs
);
2350 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2351 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2354 /* return 0 as number of sectors if no device present or error */
2355 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2357 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2359 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2362 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2363 BlockdevOnError on_write_error
)
2365 bs
->on_read_error
= on_read_error
;
2366 bs
->on_write_error
= on_write_error
;
2369 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2371 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2374 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2376 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2379 case BLOCKDEV_ON_ERROR_ENOSPC
:
2380 return (error
== ENOSPC
) ?
2381 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
2382 case BLOCKDEV_ON_ERROR_STOP
:
2383 return BLOCK_ERROR_ACTION_STOP
;
2384 case BLOCKDEV_ON_ERROR_REPORT
:
2385 return BLOCK_ERROR_ACTION_REPORT
;
2386 case BLOCKDEV_ON_ERROR_IGNORE
:
2387 return BLOCK_ERROR_ACTION_IGNORE
;
2393 static void send_qmp_error_event(BlockDriverState
*bs
,
2394 BlockErrorAction action
,
2395 bool is_read
, int error
)
2397 IoOperationType optype
;
2399 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
2400 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
2401 bdrv_iostatus_is_enabled(bs
),
2402 error
== ENOSPC
, strerror(error
),
2406 /* This is done by device models because, while the block layer knows
2407 * about the error, it does not know whether an operation comes from
2408 * the device or the block layer (from a job, for example).
2410 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2411 bool is_read
, int error
)
2415 if (action
== BLOCK_ERROR_ACTION_STOP
) {
2416 /* First set the iostatus, so that "info block" returns an iostatus
2417 * that matches the events raised so far (an additional error iostatus
2418 * is fine, but not a lost one).
2420 bdrv_iostatus_set_err(bs
, error
);
2422 /* Then raise the request to stop the VM and the event.
2423 * qemu_system_vmstop_request_prepare has two effects. First,
2424 * it ensures that the STOP event always comes after the
2425 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2426 * can observe the STOP event and do a "cont" before the STOP
2427 * event is issued, the VM will not stop. In this case, vm_start()
2428 * also ensures that the STOP/RESUME pair of events is emitted.
2430 qemu_system_vmstop_request_prepare();
2431 send_qmp_error_event(bs
, action
, is_read
, error
);
2432 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
2434 send_qmp_error_event(bs
, action
, is_read
, error
);
2438 int bdrv_is_read_only(BlockDriverState
*bs
)
2440 return bs
->read_only
;
2443 int bdrv_is_sg(BlockDriverState
*bs
)
2448 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2450 return bs
->enable_write_cache
;
2453 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2455 bs
->enable_write_cache
= wce
;
2457 /* so a reopen() will preserve wce */
2459 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2461 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2465 int bdrv_is_encrypted(BlockDriverState
*bs
)
2467 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2469 return bs
->encrypted
;
2472 int bdrv_key_required(BlockDriverState
*bs
)
2474 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2476 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2478 return (bs
->encrypted
&& !bs
->valid_key
);
2481 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2484 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2485 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2491 if (!bs
->encrypted
) {
2493 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2496 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2499 } else if (!bs
->valid_key
) {
2502 /* call the change callback now, we skipped it on open */
2503 blk_dev_change_media_cb(bs
->blk
, true);
2510 * Provide an encryption key for @bs.
2511 * If @key is non-null:
2512 * If @bs is not encrypted, fail.
2513 * Else if the key is invalid, fail.
2514 * Else set @bs's key to @key, replacing the existing key, if any.
2516 * If @bs is encrypted and still lacks a key, fail.
2518 * On failure, store an error object through @errp if non-null.
2520 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2523 if (!bdrv_is_encrypted(bs
)) {
2524 error_setg(errp
, "Node '%s' is not encrypted",
2525 bdrv_get_device_or_node_name(bs
));
2526 } else if (bdrv_set_key(bs
, key
) < 0) {
2527 error_set(errp
, QERR_INVALID_PASSWORD
);
2530 if (bdrv_key_required(bs
)) {
2531 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2532 "'%s' (%s) is encrypted",
2533 bdrv_get_device_or_node_name(bs
),
2534 bdrv_get_encrypted_filename(bs
));
2539 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2541 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2544 static int qsort_strcmp(const void *a
, const void *b
)
2546 return strcmp(a
, b
);
2549 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2555 const char **formats
= NULL
;
2557 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2558 if (drv
->format_name
) {
2561 while (formats
&& i
&& !found
) {
2562 found
= !strcmp(formats
[--i
], drv
->format_name
);
2566 formats
= g_renew(const char *, formats
, count
+ 1);
2567 formats
[count
++] = drv
->format_name
;
2572 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2574 for (i
= 0; i
< count
; i
++) {
2575 it(opaque
, formats
[i
]);
2581 /* This function is to find a node in the bs graph */
2582 BlockDriverState
*bdrv_find_node(const char *node_name
)
2584 BlockDriverState
*bs
;
2588 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2589 if (!strcmp(node_name
, bs
->node_name
)) {
2596 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2597 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2599 BlockDeviceInfoList
*list
, *entry
;
2600 BlockDriverState
*bs
;
2603 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2604 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
2606 qapi_free_BlockDeviceInfoList(list
);
2609 entry
= g_malloc0(sizeof(*entry
));
2610 entry
->value
= info
;
2618 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2619 const char *node_name
,
2623 BlockDriverState
*bs
;
2626 blk
= blk_by_name(device
);
2634 bs
= bdrv_find_node(node_name
);
2641 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2642 device
? device
: "",
2643 node_name
? node_name
: "");
2647 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2648 * return false. If either argument is NULL, return false. */
2649 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2651 while (top
&& top
!= base
) {
2652 top
= top
->backing_hd
;
2658 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2661 return QTAILQ_FIRST(&graph_bdrv_states
);
2663 return QTAILQ_NEXT(bs
, node_list
);
2666 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2669 return QTAILQ_FIRST(&bdrv_states
);
2671 return QTAILQ_NEXT(bs
, device_list
);
2674 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2676 return bs
->node_name
;
2679 /* TODO check what callers really want: bs->node_name or blk_name() */
2680 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2682 return bs
->blk
? blk_name(bs
->blk
) : "";
2685 /* This can be used to identify nodes that might not have a device
2686 * name associated. Since node and device names live in the same
2687 * namespace, the result is unambiguous. The exception is if both are
2688 * absent, then this returns an empty (non-null) string. */
2689 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2691 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2694 int bdrv_get_flags(BlockDriverState
*bs
)
2696 return bs
->open_flags
;
2699 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2704 int bdrv_has_zero_init(BlockDriverState
*bs
)
2708 /* If BS is a copy on write image, it is initialized to
2709 the contents of the base image, which may not be zeroes. */
2710 if (bs
->backing_hd
) {
2713 if (bs
->drv
->bdrv_has_zero_init
) {
2714 return bs
->drv
->bdrv_has_zero_init(bs
);
2721 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2723 BlockDriverInfo bdi
;
2725 if (bs
->backing_hd
) {
2729 if (bdrv_get_info(bs
, &bdi
) == 0) {
2730 return bdi
.unallocated_blocks_are_zero
;
2736 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2738 BlockDriverInfo bdi
;
2740 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2744 if (bdrv_get_info(bs
, &bdi
) == 0) {
2745 return bdi
.can_write_zeroes_with_unmap
;
2751 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2753 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2754 return bs
->backing_file
;
2755 else if (bs
->encrypted
)
2756 return bs
->filename
;
2761 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2762 char *filename
, int filename_size
)
2764 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2767 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2769 BlockDriver
*drv
= bs
->drv
;
2772 if (!drv
->bdrv_get_info
)
2774 memset(bdi
, 0, sizeof(*bdi
));
2775 return drv
->bdrv_get_info(bs
, bdi
);
2778 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
2780 BlockDriver
*drv
= bs
->drv
;
2781 if (drv
&& drv
->bdrv_get_specific_info
) {
2782 return drv
->bdrv_get_specific_info(bs
);
2787 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2789 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
2793 bs
->drv
->bdrv_debug_event(bs
, event
);
2796 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
2799 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
2803 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
2804 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
2810 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
2812 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
2816 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
2817 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
2823 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
2825 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
2829 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
2830 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
2836 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
2838 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
2842 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
2843 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
2849 int bdrv_is_snapshot(BlockDriverState
*bs
)
2851 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2854 /* backing_file can either be relative, or absolute, or a protocol. If it is
2855 * relative, it must be relative to the chain. So, passing in bs->filename
2856 * from a BDS as backing_file should not be done, as that may be relative to
2857 * the CWD rather than the chain. */
2858 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2859 const char *backing_file
)
2861 char *filename_full
= NULL
;
2862 char *backing_file_full
= NULL
;
2863 char *filename_tmp
= NULL
;
2864 int is_protocol
= 0;
2865 BlockDriverState
*curr_bs
= NULL
;
2866 BlockDriverState
*retval
= NULL
;
2868 if (!bs
|| !bs
->drv
|| !backing_file
) {
2872 filename_full
= g_malloc(PATH_MAX
);
2873 backing_file_full
= g_malloc(PATH_MAX
);
2874 filename_tmp
= g_malloc(PATH_MAX
);
2876 is_protocol
= path_has_protocol(backing_file
);
2878 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
2880 /* If either of the filename paths is actually a protocol, then
2881 * compare unmodified paths; otherwise make paths relative */
2882 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
2883 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
2884 retval
= curr_bs
->backing_hd
;
2888 /* If not an absolute filename path, make it relative to the current
2889 * image's filename path */
2890 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2893 /* We are going to compare absolute pathnames */
2894 if (!realpath(filename_tmp
, filename_full
)) {
2898 /* We need to make sure the backing filename we are comparing against
2899 * is relative to the current image filename (or absolute) */
2900 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
2901 curr_bs
->backing_file
);
2903 if (!realpath(filename_tmp
, backing_file_full
)) {
2907 if (strcmp(backing_file_full
, filename_full
) == 0) {
2908 retval
= curr_bs
->backing_hd
;
2914 g_free(filename_full
);
2915 g_free(backing_file_full
);
2916 g_free(filename_tmp
);
2920 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
2926 if (!bs
->backing_hd
) {
2930 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
2933 void bdrv_init(void)
2935 module_call_init(MODULE_INIT_BLOCK
);
2938 void bdrv_init_with_whitelist(void)
2940 use_bdrv_whitelist
= 1;
2944 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
2946 Error
*local_err
= NULL
;
2953 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
2956 bs
->open_flags
&= ~BDRV_O_INCOMING
;
2958 if (bs
->drv
->bdrv_invalidate_cache
) {
2959 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
2960 } else if (bs
->file
) {
2961 bdrv_invalidate_cache(bs
->file
, &local_err
);
2964 error_propagate(errp
, local_err
);
2968 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2970 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
2975 void bdrv_invalidate_cache_all(Error
**errp
)
2977 BlockDriverState
*bs
;
2978 Error
*local_err
= NULL
;
2980 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2981 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2983 aio_context_acquire(aio_context
);
2984 bdrv_invalidate_cache(bs
, &local_err
);
2985 aio_context_release(aio_context
);
2987 error_propagate(errp
, local_err
);
2993 /**************************************************************/
2994 /* removable device support */
2997 * Return TRUE if the media is present
2999 int bdrv_is_inserted(BlockDriverState
*bs
)
3001 BlockDriver
*drv
= bs
->drv
;
3005 if (!drv
->bdrv_is_inserted
)
3007 return drv
->bdrv_is_inserted(bs
);
3011 * Return whether the media changed since the last call to this
3012 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3014 int bdrv_media_changed(BlockDriverState
*bs
)
3016 BlockDriver
*drv
= bs
->drv
;
3018 if (drv
&& drv
->bdrv_media_changed
) {
3019 return drv
->bdrv_media_changed(bs
);
3025 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3027 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3029 BlockDriver
*drv
= bs
->drv
;
3030 const char *device_name
;
3032 if (drv
&& drv
->bdrv_eject
) {
3033 drv
->bdrv_eject(bs
, eject_flag
);
3036 device_name
= bdrv_get_device_name(bs
);
3037 if (device_name
[0] != '\0') {
3038 qapi_event_send_device_tray_moved(device_name
,
3039 eject_flag
, &error_abort
);
3044 * Lock or unlock the media (if it is locked, the user won't be able
3045 * to eject it manually).
3047 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3049 BlockDriver
*drv
= bs
->drv
;
3051 trace_bdrv_lock_medium(bs
, locked
);
3053 if (drv
&& drv
->bdrv_lock_medium
) {
3054 drv
->bdrv_lock_medium(bs
, locked
);
3058 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
3060 bs
->guest_block_size
= align
;
3063 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
3065 BdrvDirtyBitmap
*bm
;
3068 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3069 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
3076 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap
*bitmap
)
3078 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3079 g_free(bitmap
->name
);
3080 bitmap
->name
= NULL
;
3083 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
3084 uint32_t granularity
,
3088 int64_t bitmap_size
;
3089 BdrvDirtyBitmap
*bitmap
;
3090 uint32_t sector_granularity
;
3092 assert((granularity
& (granularity
- 1)) == 0);
3094 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
3095 error_setg(errp
, "Bitmap already exists: %s", name
);
3098 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
3099 assert(sector_granularity
);
3100 bitmap_size
= bdrv_nb_sectors(bs
);
3101 if (bitmap_size
< 0) {
3102 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
3103 errno
= -bitmap_size
;
3106 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
3107 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
3108 bitmap
->size
= bitmap_size
;
3109 bitmap
->name
= g_strdup(name
);
3110 bitmap
->disabled
= false;
3111 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
3115 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
3117 return bitmap
->successor
;
3120 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
3122 return !(bitmap
->disabled
|| bitmap
->successor
);
3125 DirtyBitmapStatus
bdrv_dirty_bitmap_status(BdrvDirtyBitmap
*bitmap
)
3127 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3128 return DIRTY_BITMAP_STATUS_FROZEN
;
3129 } else if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3130 return DIRTY_BITMAP_STATUS_DISABLED
;
3132 return DIRTY_BITMAP_STATUS_ACTIVE
;
3137 * Create a successor bitmap destined to replace this bitmap after an operation.
3138 * Requires that the bitmap is not frozen and has no successor.
3140 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
3141 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
3143 uint64_t granularity
;
3144 BdrvDirtyBitmap
*child
;
3146 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3147 error_setg(errp
, "Cannot create a successor for a bitmap that is "
3148 "currently frozen");
3151 assert(!bitmap
->successor
);
3153 /* Create an anonymous successor */
3154 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
3155 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
3160 /* Successor will be on or off based on our current state. */
3161 child
->disabled
= bitmap
->disabled
;
3163 /* Install the successor and freeze the parent */
3164 bitmap
->successor
= child
;
3169 * For a bitmap with a successor, yield our name to the successor,
3170 * delete the old bitmap, and return a handle to the new bitmap.
3172 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
3173 BdrvDirtyBitmap
*bitmap
,
3177 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
3179 if (successor
== NULL
) {
3180 error_setg(errp
, "Cannot relinquish control if "
3181 "there's no successor present");
3185 name
= bitmap
->name
;
3186 bitmap
->name
= NULL
;
3187 successor
->name
= name
;
3188 bitmap
->successor
= NULL
;
3189 bdrv_release_dirty_bitmap(bs
, bitmap
);
3195 * In cases of failure where we can no longer safely delete the parent,
3196 * we may wish to re-join the parent and child/successor.
3197 * The merged parent will be un-frozen, but not explicitly re-enabled.
3199 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
3200 BdrvDirtyBitmap
*parent
,
3203 BdrvDirtyBitmap
*successor
= parent
->successor
;
3206 error_setg(errp
, "Cannot reclaim a successor when none is present");
3210 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
3211 error_setg(errp
, "Merging of parent and successor bitmap failed");
3214 bdrv_release_dirty_bitmap(bs
, successor
);
3215 parent
->successor
= NULL
;
3221 * Truncates _all_ bitmaps attached to a BDS.
3223 static void bdrv_dirty_bitmap_truncate(BlockDriverState
*bs
)
3225 BdrvDirtyBitmap
*bitmap
;
3226 uint64_t size
= bdrv_nb_sectors(bs
);
3228 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3229 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
3232 hbitmap_truncate(bitmap
->bitmap
, size
);
3236 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
3238 BdrvDirtyBitmap
*bm
, *next
;
3239 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
3241 assert(!bdrv_dirty_bitmap_frozen(bm
));
3242 QLIST_REMOVE(bitmap
, list
);
3243 hbitmap_free(bitmap
->bitmap
);
3244 g_free(bitmap
->name
);
3251 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3253 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3254 bitmap
->disabled
= true;
3257 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3259 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
3260 bitmap
->disabled
= false;
3263 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
3265 BdrvDirtyBitmap
*bm
;
3266 BlockDirtyInfoList
*list
= NULL
;
3267 BlockDirtyInfoList
**plist
= &list
;
3269 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
3270 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
3271 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
3272 info
->count
= bdrv_get_dirty_count(bm
);
3273 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
3274 info
->has_name
= !!bm
->name
;
3275 info
->name
= g_strdup(bm
->name
);
3276 info
->status
= bdrv_dirty_bitmap_status(bm
);
3277 entry
->value
= info
;
3279 plist
= &entry
->next
;
3285 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
3288 return hbitmap_get(bitmap
->bitmap
, sector
);
3295 * Chooses a default granularity based on the existing cluster size,
3296 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3297 * is no cluster size information available.
3299 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
3301 BlockDriverInfo bdi
;
3302 uint32_t granularity
;
3304 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
3305 granularity
= MAX(4096, bdi
.cluster_size
);
3306 granularity
= MIN(65536, granularity
);
3308 granularity
= 65536;
3314 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
3316 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
3319 void bdrv_dirty_iter_init(BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
3321 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
3324 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3325 int64_t cur_sector
, int nr_sectors
)
3327 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3328 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3331 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap
*bitmap
,
3332 int64_t cur_sector
, int nr_sectors
)
3334 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3335 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3338 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
3340 assert(bdrv_dirty_bitmap_enabled(bitmap
));
3341 hbitmap_reset(bitmap
->bitmap
, 0, bitmap
->size
);
3344 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3347 BdrvDirtyBitmap
*bitmap
;
3348 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3349 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3352 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3356 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3359 BdrvDirtyBitmap
*bitmap
;
3360 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
3361 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
3364 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
3369 * Advance an HBitmapIter to an arbitrary offset.
3371 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
3374 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
3377 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap
*bitmap
)
3379 return hbitmap_count(bitmap
->bitmap
);
3382 /* Get a reference to bs */
3383 void bdrv_ref(BlockDriverState
*bs
)
3388 /* Release a previously grabbed reference to bs.
3389 * If after releasing, reference count is zero, the BlockDriverState is
3391 void bdrv_unref(BlockDriverState
*bs
)
3396 assert(bs
->refcnt
> 0);
3397 if (--bs
->refcnt
== 0) {
3402 struct BdrvOpBlocker
{
3404 QLIST_ENTRY(BdrvOpBlocker
) list
;
3407 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3409 BdrvOpBlocker
*blocker
;
3410 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3411 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3412 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3414 error_setg(errp
, "Node '%s' is busy: %s",
3415 bdrv_get_device_or_node_name(bs
),
3416 error_get_pretty(blocker
->reason
));
3423 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3425 BdrvOpBlocker
*blocker
;
3426 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3428 blocker
= g_new0(BdrvOpBlocker
, 1);
3429 blocker
->reason
= reason
;
3430 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3433 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3435 BdrvOpBlocker
*blocker
, *next
;
3436 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3437 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3438 if (blocker
->reason
== reason
) {
3439 QLIST_REMOVE(blocker
, list
);
3445 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3448 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3449 bdrv_op_block(bs
, i
, reason
);
3453 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3456 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3457 bdrv_op_unblock(bs
, i
, reason
);
3461 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3465 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3466 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3473 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3475 bs
->iostatus_enabled
= true;
3476 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3479 /* The I/O status is only enabled if the drive explicitly
3480 * enables it _and_ the VM is configured to stop on errors */
3481 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3483 return (bs
->iostatus_enabled
&&
3484 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
3485 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
3486 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
3489 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3491 bs
->iostatus_enabled
= false;
3494 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3496 if (bdrv_iostatus_is_enabled(bs
)) {
3497 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3499 block_job_iostatus_reset(bs
->job
);
3504 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3506 assert(bdrv_iostatus_is_enabled(bs
));
3507 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3508 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3509 BLOCK_DEVICE_IO_STATUS_FAILED
;
3513 void bdrv_img_create(const char *filename
, const char *fmt
,
3514 const char *base_filename
, const char *base_fmt
,
3515 char *options
, uint64_t img_size
, int flags
,
3516 Error
**errp
, bool quiet
)
3518 QemuOptsList
*create_opts
= NULL
;
3519 QemuOpts
*opts
= NULL
;
3520 const char *backing_fmt
, *backing_file
;
3522 BlockDriver
*drv
, *proto_drv
;
3523 BlockDriver
*backing_drv
= NULL
;
3524 Error
*local_err
= NULL
;
3527 /* Find driver and parse its options */
3528 drv
= bdrv_find_format(fmt
);
3530 error_setg(errp
, "Unknown file format '%s'", fmt
);
3534 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3539 if (!drv
->create_opts
) {
3540 error_setg(errp
, "Format driver '%s' does not support image creation",
3545 if (!proto_drv
->create_opts
) {
3546 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3547 proto_drv
->format_name
);
3551 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3552 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3554 /* Create parameter list with default values */
3555 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3556 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3558 /* Parse -o options */
3560 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3562 error_report_err(local_err
);
3564 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3569 if (base_filename
) {
3570 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3572 error_setg(errp
, "Backing file not supported for file format '%s'",
3579 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3581 error_setg(errp
, "Backing file format not supported for file "
3582 "format '%s'", fmt
);
3587 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3589 if (!strcmp(filename
, backing_file
)) {
3590 error_setg(errp
, "Error: Trying to create an image with the "
3591 "same filename as the backing file");
3596 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3598 backing_drv
= bdrv_find_format(backing_fmt
);
3600 error_setg(errp
, "Unknown backing file format '%s'",
3606 // The size for the image must always be specified, with one exception:
3607 // If we are using a backing file, we can obtain the size from there
3608 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3611 BlockDriverState
*bs
;
3612 char *full_backing
= g_new0(char, PATH_MAX
);
3616 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3617 full_backing
, PATH_MAX
,
3620 g_free(full_backing
);
3624 /* backing files always opened read-only */
3626 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3629 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
3630 backing_drv
, &local_err
);
3631 g_free(full_backing
);
3635 size
= bdrv_getlength(bs
);
3637 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3643 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3647 error_setg(errp
, "Image creation needs a size parameter");
3653 printf("Formatting '%s', fmt=%s", filename
, fmt
);
3654 qemu_opts_print(opts
, " ");
3658 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3660 if (ret
== -EFBIG
) {
3661 /* This is generally a better message than whatever the driver would
3662 * deliver (especially because of the cluster_size_hint), since that
3663 * is most probably not much different from "image too large". */
3664 const char *cluster_size_hint
= "";
3665 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3666 cluster_size_hint
= " (try using a larger cluster size)";
3668 error_setg(errp
, "The image size is too large for file format '%s'"
3669 "%s", fmt
, cluster_size_hint
);
3670 error_free(local_err
);
3675 qemu_opts_del(opts
);
3676 qemu_opts_free(create_opts
);
3678 error_propagate(errp
, local_err
);
3682 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3684 return bs
->aio_context
;
3687 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3689 BdrvAioNotifier
*baf
;
3695 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3696 baf
->detach_aio_context(baf
->opaque
);
3699 if (bs
->io_limits_enabled
) {
3700 throttle_timers_detach_aio_context(&bs
->throttle_timers
);
3702 if (bs
->drv
->bdrv_detach_aio_context
) {
3703 bs
->drv
->bdrv_detach_aio_context(bs
);
3706 bdrv_detach_aio_context(bs
->file
);
3708 if (bs
->backing_hd
) {
3709 bdrv_detach_aio_context(bs
->backing_hd
);
3712 bs
->aio_context
= NULL
;
3715 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3716 AioContext
*new_context
)
3718 BdrvAioNotifier
*ban
;
3724 bs
->aio_context
= new_context
;
3726 if (bs
->backing_hd
) {
3727 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
3730 bdrv_attach_aio_context(bs
->file
, new_context
);
3732 if (bs
->drv
->bdrv_attach_aio_context
) {
3733 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3735 if (bs
->io_limits_enabled
) {
3736 throttle_timers_attach_aio_context(&bs
->throttle_timers
, new_context
);
3739 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3740 ban
->attached_aio_context(new_context
, ban
->opaque
);
3744 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3746 bdrv_drain_all(); /* ensure there are no in-flight requests */
3748 bdrv_detach_aio_context(bs
);
3750 /* This function executes in the old AioContext so acquire the new one in
3751 * case it runs in a different thread.
3753 aio_context_acquire(new_context
);
3754 bdrv_attach_aio_context(bs
, new_context
);
3755 aio_context_release(new_context
);
3758 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3759 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3760 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3762 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3763 *ban
= (BdrvAioNotifier
){
3764 .attached_aio_context
= attached_aio_context
,
3765 .detach_aio_context
= detach_aio_context
,
3769 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3772 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3773 void (*attached_aio_context
)(AioContext
*,
3775 void (*detach_aio_context
)(void *),
3778 BdrvAioNotifier
*ban
, *ban_next
;
3780 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3781 if (ban
->attached_aio_context
== attached_aio_context
&&
3782 ban
->detach_aio_context
== detach_aio_context
&&
3783 ban
->opaque
== opaque
)
3785 QLIST_REMOVE(ban
, list
);
3795 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3796 BlockDriverAmendStatusCB
*status_cb
)
3798 if (!bs
->drv
->bdrv_amend_options
) {
3801 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
3804 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3805 * of block filter and by bdrv_is_first_non_filter.
3806 * It is used to test if the given bs is the candidate or recurse more in the
3809 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3810 BlockDriverState
*candidate
)
3812 /* return false if basic checks fails */
3813 if (!bs
|| !bs
->drv
) {
3817 /* the code reached a non block filter driver -> check if the bs is
3818 * the same as the candidate. It's the recursion termination condition.
3820 if (!bs
->drv
->is_filter
) {
3821 return bs
== candidate
;
3823 /* Down this path the driver is a block filter driver */
3825 /* If the block filter recursion method is defined use it to recurse down
3828 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
3829 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
3832 /* the driver is a block filter but don't allow to recurse -> return false
3837 /* This function checks if the candidate is the first non filter bs down it's
3838 * bs chain. Since we don't have pointers to parents it explore all bs chains
3839 * from the top. Some filters can choose not to pass down the recursion.
3841 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
3843 BlockDriverState
*bs
;
3845 /* walk down the bs forest recursively */
3846 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3849 /* try to recurse in this top level bs */
3850 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
3852 /* candidate is the first non filter */
3861 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
3863 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
3864 AioContext
*aio_context
;
3866 if (!to_replace_bs
) {
3867 error_setg(errp
, "Node name '%s' not found", node_name
);
3871 aio_context
= bdrv_get_aio_context(to_replace_bs
);
3872 aio_context_acquire(aio_context
);
3874 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
3875 to_replace_bs
= NULL
;
3879 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3880 * most non filter in order to prevent data corruption.
3881 * Another benefit is that this tests exclude backing files which are
3882 * blocked by the backing blockers.
3884 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
3885 error_setg(errp
, "Only top most non filter can be replaced");
3886 to_replace_bs
= NULL
;
3891 aio_context_release(aio_context
);
3892 return to_replace_bs
;
3895 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
3897 const QDictEntry
*entry
;
3898 bool found_any
= false;
3900 for (entry
= qdict_first(bs
->options
); entry
;
3901 entry
= qdict_next(bs
->options
, entry
))
3903 /* Only take options for this level and exclude all non-driver-specific
3905 if (!strchr(qdict_entry_key(entry
), '.') &&
3906 strcmp(qdict_entry_key(entry
), "node-name"))
3908 qobject_incref(qdict_entry_value(entry
));
3909 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
3917 /* Updates the following BDS fields:
3918 * - exact_filename: A filename which may be used for opening a block device
3919 * which (mostly) equals the given BDS (even without any
3920 * other options; so reading and writing must return the same
3921 * results, but caching etc. may be different)
3922 * - full_open_options: Options which, when given when opening a block device
3923 * (without a filename), result in a BDS (mostly)
3924 * equalling the given one
3925 * - filename: If exact_filename is set, it is copied here. Otherwise,
3926 * full_open_options is converted to a JSON object, prefixed with
3927 * "json:" (for use through the JSON pseudo protocol) and put here.
3929 void bdrv_refresh_filename(BlockDriverState
*bs
)
3931 BlockDriver
*drv
= bs
->drv
;
3938 /* This BDS's file name will most probably depend on its file's name, so
3939 * refresh that first */
3941 bdrv_refresh_filename(bs
->file
);
3944 if (drv
->bdrv_refresh_filename
) {
3945 /* Obsolete information is of no use here, so drop the old file name
3946 * information before refreshing it */
3947 bs
->exact_filename
[0] = '\0';
3948 if (bs
->full_open_options
) {
3949 QDECREF(bs
->full_open_options
);
3950 bs
->full_open_options
= NULL
;
3953 drv
->bdrv_refresh_filename(bs
);
3954 } else if (bs
->file
) {
3955 /* Try to reconstruct valid information from the underlying file */
3956 bool has_open_options
;
3958 bs
->exact_filename
[0] = '\0';
3959 if (bs
->full_open_options
) {
3960 QDECREF(bs
->full_open_options
);
3961 bs
->full_open_options
= NULL
;
3965 has_open_options
= append_open_options(opts
, bs
);
3967 /* If no specific options have been given for this BDS, the filename of
3968 * the underlying file should suffice for this one as well */
3969 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
3970 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
3972 /* Reconstructing the full options QDict is simple for most format block
3973 * drivers, as long as the full options are known for the underlying
3974 * file BDS. The full options QDict of that file BDS should somehow
3975 * contain a representation of the filename, therefore the following
3976 * suffices without querying the (exact_)filename of this BDS. */
3977 if (bs
->file
->full_open_options
) {
3978 qdict_put_obj(opts
, "driver",
3979 QOBJECT(qstring_from_str(drv
->format_name
)));
3980 QINCREF(bs
->file
->full_open_options
);
3981 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
3983 bs
->full_open_options
= opts
;
3987 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
3988 /* There is no underlying file BDS (at least referenced by BDS.file),
3989 * so the full options QDict should be equal to the options given
3990 * specifically for this block device when it was opened (plus the
3991 * driver specification).
3992 * Because those options don't change, there is no need to update
3993 * full_open_options when it's already set. */
3996 append_open_options(opts
, bs
);
3997 qdict_put_obj(opts
, "driver",
3998 QOBJECT(qstring_from_str(drv
->format_name
)));
4000 if (bs
->exact_filename
[0]) {
4001 /* This may not work for all block protocol drivers (some may
4002 * require this filename to be parsed), but we have to find some
4003 * default solution here, so just include it. If some block driver
4004 * does not support pure options without any filename at all or
4005 * needs some special format of the options QDict, it needs to
4006 * implement the driver-specific bdrv_refresh_filename() function.
4008 qdict_put_obj(opts
, "filename",
4009 QOBJECT(qstring_from_str(bs
->exact_filename
)));
4012 bs
->full_open_options
= opts
;
4015 if (bs
->exact_filename
[0]) {
4016 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
4017 } else if (bs
->full_open_options
) {
4018 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
4019 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
4020 qstring_get_str(json
));
4025 /* This accessor function purpose is to allow the device models to access the
4026 * BlockAcctStats structure embedded inside a BlockDriverState without being
4027 * aware of the BlockDriverState structure layout.
4028 * It will go away when the BlockAcctStats structure will be moved inside
4029 * the device models.
4031 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)