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 "qemu/osdep.h"
26 #include "block/block_int.h"
27 #include "block/blockjob.h"
28 #include "qemu/error-report.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qerror.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "qemu/cutils.h"
45 #include <sys/ioctl.h>
46 #include <sys/queue.h>
56 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
58 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
61 static QTAILQ_HEAD(, BlockDriverState
) all_bdrv_states
=
62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states
);
64 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
65 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
67 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
68 const char *reference
, QDict
*options
, int flags
,
69 BlockDriverState
*parent
,
70 const BdrvChildRole
*child_role
, Error
**errp
);
72 /* If non-zero, use only whitelisted block drivers */
73 static int use_bdrv_whitelist
;
75 static void bdrv_close(BlockDriverState
*bs
);
78 static int is_windows_drive_prefix(const char *filename
)
80 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
81 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
85 int is_windows_drive(const char *filename
)
87 if (is_windows_drive_prefix(filename
) &&
90 if (strstart(filename
, "\\\\.\\", NULL
) ||
91 strstart(filename
, "//./", NULL
))
97 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
99 if (!bs
|| !bs
->drv
) {
100 /* page size or 4k (hdd sector size) should be on the safe side */
101 return MAX(4096, getpagesize());
104 return bs
->bl
.opt_mem_alignment
;
107 size_t bdrv_min_mem_align(BlockDriverState
*bs
)
109 if (!bs
|| !bs
->drv
) {
110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
114 return bs
->bl
.min_mem_alignment
;
117 /* check if the path starts with "<protocol>:" */
118 int path_has_protocol(const char *path
)
123 if (is_windows_drive(path
) ||
124 is_windows_drive_prefix(path
)) {
127 p
= path
+ strcspn(path
, ":/\\");
129 p
= path
+ strcspn(path
, ":/");
135 int path_is_absolute(const char *path
)
138 /* specific case for names like: "\\.\d:" */
139 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
142 return (*path
== '/' || *path
== '\\');
144 return (*path
== '/');
148 /* if filename is absolute, just copy it to dest. Otherwise, build a
149 path to it by considering it is relative to base_path. URL are
151 void path_combine(char *dest
, int dest_size
,
152 const char *base_path
,
153 const char *filename
)
160 if (path_is_absolute(filename
)) {
161 pstrcpy(dest
, dest_size
, filename
);
163 p
= strchr(base_path
, ':');
168 p1
= strrchr(base_path
, '/');
172 p2
= strrchr(base_path
, '\\');
184 if (len
> dest_size
- 1)
186 memcpy(dest
, base_path
, len
);
188 pstrcat(dest
, dest_size
, filename
);
192 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
194 char *dest
, size_t sz
,
197 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
198 path_is_absolute(backing
))
200 pstrcpy(dest
, sz
, backing
);
201 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
202 error_setg(errp
, "Cannot use relative backing file names for '%s'",
205 path_combine(dest
, sz
, backed
, backing
);
209 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
212 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
214 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
218 void bdrv_register(BlockDriver
*bdrv
)
220 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
223 BlockDriverState
*bdrv_new_root(void)
228 BlockDriverState
*bdrv_new(void)
230 BlockDriverState
*bs
;
233 bs
= g_new0(BlockDriverState
, 1);
234 QLIST_INIT(&bs
->dirty_bitmaps
);
235 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
236 QLIST_INIT(&bs
->op_blockers
[i
]);
238 notifier_with_return_list_init(&bs
->before_write_notifiers
);
240 bs
->aio_context
= qemu_get_aio_context();
242 QTAILQ_INSERT_TAIL(&all_bdrv_states
, bs
, bs_list
);
247 BlockDriver
*bdrv_find_format(const char *format_name
)
250 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
251 if (!strcmp(drv1
->format_name
, format_name
)) {
258 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
260 static const char *whitelist_rw
[] = {
261 CONFIG_BDRV_RW_WHITELIST
263 static const char *whitelist_ro
[] = {
264 CONFIG_BDRV_RO_WHITELIST
268 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
269 return 1; /* no whitelist, anything goes */
272 for (p
= whitelist_rw
; *p
; p
++) {
273 if (!strcmp(drv
->format_name
, *p
)) {
278 for (p
= whitelist_ro
; *p
; p
++) {
279 if (!strcmp(drv
->format_name
, *p
)) {
287 bool bdrv_uses_whitelist(void)
289 return use_bdrv_whitelist
;
292 typedef struct CreateCo
{
300 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
302 Error
*local_err
= NULL
;
305 CreateCo
*cco
= opaque
;
308 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
310 error_propagate(&cco
->err
, local_err
);
315 int bdrv_create(BlockDriver
*drv
, const char* filename
,
316 QemuOpts
*opts
, Error
**errp
)
323 .filename
= g_strdup(filename
),
329 if (!drv
->bdrv_create
) {
330 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
335 if (qemu_in_coroutine()) {
336 /* Fast-path if already in coroutine context */
337 bdrv_create_co_entry(&cco
);
339 co
= qemu_coroutine_create(bdrv_create_co_entry
);
340 qemu_coroutine_enter(co
, &cco
);
341 while (cco
.ret
== NOT_DONE
) {
342 aio_poll(qemu_get_aio_context(), true);
349 error_propagate(errp
, cco
.err
);
351 error_setg_errno(errp
, -ret
, "Could not create image");
356 g_free(cco
.filename
);
360 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
363 Error
*local_err
= NULL
;
366 drv
= bdrv_find_protocol(filename
, true, errp
);
371 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
373 error_propagate(errp
, local_err
);
379 * Try to get @bs's logical and physical block size.
380 * On success, store them in @bsz struct and return 0.
381 * On failure return -errno.
382 * @bs must not be empty.
384 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
386 BlockDriver
*drv
= bs
->drv
;
388 if (drv
&& drv
->bdrv_probe_blocksizes
) {
389 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
396 * Try to get @bs's geometry (cyls, heads, sectors).
397 * On success, store them in @geo struct and return 0.
398 * On failure return -errno.
399 * @bs must not be empty.
401 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
403 BlockDriver
*drv
= bs
->drv
;
405 if (drv
&& drv
->bdrv_probe_geometry
) {
406 return drv
->bdrv_probe_geometry(bs
, geo
);
413 * Create a uniquely-named empty temporary file.
414 * Return 0 upon success, otherwise a negative errno value.
416 int get_tmp_filename(char *filename
, int size
)
419 char temp_dir
[MAX_PATH
];
420 /* GetTempFileName requires that its output buffer (4th param)
421 have length MAX_PATH or greater. */
422 assert(size
>= MAX_PATH
);
423 return (GetTempPath(MAX_PATH
, temp_dir
)
424 && GetTempFileName(temp_dir
, "qem", 0, filename
)
425 ? 0 : -GetLastError());
429 tmpdir
= getenv("TMPDIR");
433 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
436 fd
= mkstemp(filename
);
440 if (close(fd
) != 0) {
449 * Detect host devices. By convention, /dev/cdrom[N] is always
450 * recognized as a host CDROM.
452 static BlockDriver
*find_hdev_driver(const char *filename
)
454 int score_max
= 0, score
;
455 BlockDriver
*drv
= NULL
, *d
;
457 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
458 if (d
->bdrv_probe_device
) {
459 score
= d
->bdrv_probe_device(filename
);
460 if (score
> score_max
) {
470 BlockDriver
*bdrv_find_protocol(const char *filename
,
471 bool allow_protocol_prefix
,
479 /* TODO Drivers without bdrv_file_open must be specified explicitly */
482 * XXX(hch): we really should not let host device detection
483 * override an explicit protocol specification, but moving this
484 * later breaks access to device names with colons in them.
485 * Thanks to the brain-dead persistent naming schemes on udev-
486 * based Linux systems those actually are quite common.
488 drv1
= find_hdev_driver(filename
);
493 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
497 p
= strchr(filename
, ':');
500 if (len
> sizeof(protocol
) - 1)
501 len
= sizeof(protocol
) - 1;
502 memcpy(protocol
, filename
, len
);
503 protocol
[len
] = '\0';
504 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
505 if (drv1
->protocol_name
&&
506 !strcmp(drv1
->protocol_name
, protocol
)) {
511 error_setg(errp
, "Unknown protocol '%s'", protocol
);
516 * Guess image format by probing its contents.
517 * This is not a good idea when your image is raw (CVE-2008-2004), but
518 * we do it anyway for backward compatibility.
520 * @buf contains the image's first @buf_size bytes.
521 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
522 * but can be smaller if the image file is smaller)
523 * @filename is its filename.
525 * For all block drivers, call the bdrv_probe() method to get its
527 * Return the first block driver with the highest probing score.
529 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
530 const char *filename
)
532 int score_max
= 0, score
;
533 BlockDriver
*drv
= NULL
, *d
;
535 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
537 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
538 if (score
> score_max
) {
548 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
549 BlockDriver
**pdrv
, Error
**errp
)
552 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
555 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
556 if (bdrv_is_sg(bs
) || !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
561 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
563 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
569 drv
= bdrv_probe_all(buf
, ret
, filename
);
571 error_setg(errp
, "Could not determine image format: No compatible "
580 * Set the current 'total_sectors' value
581 * Return 0 on success, -errno on error.
583 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
585 BlockDriver
*drv
= bs
->drv
;
587 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
591 /* query actual device if possible, otherwise just trust the hint */
592 if (drv
->bdrv_getlength
) {
593 int64_t length
= drv
->bdrv_getlength(bs
);
597 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
600 bs
->total_sectors
= hint
;
605 * Combines a QDict of new block driver @options with any missing options taken
606 * from @old_options, so that leaving out an option defaults to its old value.
608 static void bdrv_join_options(BlockDriverState
*bs
, QDict
*options
,
611 if (bs
->drv
&& bs
->drv
->bdrv_join_options
) {
612 bs
->drv
->bdrv_join_options(options
, old_options
);
614 qdict_join(options
, old_options
, false);
619 * Set open flags for a given discard mode
621 * Return 0 on success, -1 if the discard mode was invalid.
623 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
625 *flags
&= ~BDRV_O_UNMAP
;
627 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
629 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
630 *flags
|= BDRV_O_UNMAP
;
639 * Set open flags for a given cache mode
641 * Return 0 on success, -1 if the cache mode was invalid.
643 int bdrv_parse_cache_mode(const char *mode
, int *flags
, bool *writethrough
)
645 *flags
&= ~BDRV_O_CACHE_MASK
;
647 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
648 *writethrough
= false;
649 *flags
|= BDRV_O_NOCACHE
;
650 } else if (!strcmp(mode
, "directsync")) {
651 *writethrough
= true;
652 *flags
|= BDRV_O_NOCACHE
;
653 } else if (!strcmp(mode
, "writeback")) {
654 *writethrough
= false;
655 } else if (!strcmp(mode
, "unsafe")) {
656 *writethrough
= false;
657 *flags
|= BDRV_O_NO_FLUSH
;
658 } else if (!strcmp(mode
, "writethrough")) {
659 *writethrough
= true;
668 * Returns the options and flags that a temporary snapshot should get, based on
669 * the originally requested flags (the originally requested image will have
670 * flags like a backing file)
672 static void bdrv_temp_snapshot_options(int *child_flags
, QDict
*child_options
,
673 int parent_flags
, QDict
*parent_options
)
675 *child_flags
= (parent_flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
677 /* For temporary files, unconditional cache=unsafe is fine */
678 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_DIRECT
, "off");
679 qdict_set_default_str(child_options
, BDRV_OPT_CACHE_NO_FLUSH
, "on");
683 * Returns the options and flags that bs->file should get if a protocol driver
684 * is expected, based on the given options and flags for the parent BDS
686 static void bdrv_inherited_options(int *child_flags
, QDict
*child_options
,
687 int parent_flags
, QDict
*parent_options
)
689 int flags
= parent_flags
;
691 /* Enable protocol handling, disable format probing for bs->file */
692 flags
|= BDRV_O_PROTOCOL
;
694 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
696 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
697 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
699 /* Our block drivers take care to send flushes and respect unmap policy,
700 * so we can default to enable both on lower layers regardless of the
701 * corresponding parent options. */
702 flags
|= BDRV_O_UNMAP
;
704 /* Clear flags that only apply to the top layer */
705 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
|
708 *child_flags
= flags
;
711 const BdrvChildRole child_file
= {
712 .inherit_options
= bdrv_inherited_options
,
716 * Returns the options and flags that bs->file should get if the use of formats
717 * (and not only protocols) is permitted for it, based on the given options and
718 * flags for the parent BDS
720 static void bdrv_inherited_fmt_options(int *child_flags
, QDict
*child_options
,
721 int parent_flags
, QDict
*parent_options
)
723 child_file
.inherit_options(child_flags
, child_options
,
724 parent_flags
, parent_options
);
726 *child_flags
&= ~(BDRV_O_PROTOCOL
| BDRV_O_NO_IO
);
729 const BdrvChildRole child_format
= {
730 .inherit_options
= bdrv_inherited_fmt_options
,
734 * Returns the options and flags that bs->backing should get, based on the
735 * given options and flags for the parent BDS
737 static void bdrv_backing_options(int *child_flags
, QDict
*child_options
,
738 int parent_flags
, QDict
*parent_options
)
740 int flags
= parent_flags
;
742 /* The cache mode is inherited unmodified for backing files; except WCE,
743 * which is only applied on the top level (BlockBackend) */
744 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_DIRECT
);
745 qdict_copy_default(child_options
, parent_options
, BDRV_OPT_CACHE_NO_FLUSH
);
747 /* backing files always opened read-only */
748 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
750 /* snapshot=on is handled on the top layer */
751 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
753 *child_flags
= flags
;
756 static const BdrvChildRole child_backing
= {
757 .inherit_options
= bdrv_backing_options
,
760 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
762 int open_flags
= flags
;
765 * Clear flags that are internal to the block layer before opening the
768 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
771 * Snapshots should be writable.
773 if (flags
& BDRV_O_TEMPORARY
) {
774 open_flags
|= BDRV_O_RDWR
;
780 static void update_flags_from_options(int *flags
, QemuOpts
*opts
)
782 *flags
&= ~BDRV_O_CACHE_MASK
;
784 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_NO_FLUSH
));
785 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_NO_FLUSH
, false)) {
786 *flags
|= BDRV_O_NO_FLUSH
;
789 assert(qemu_opt_find(opts
, BDRV_OPT_CACHE_DIRECT
));
790 if (qemu_opt_get_bool(opts
, BDRV_OPT_CACHE_DIRECT
, false)) {
791 *flags
|= BDRV_O_NOCACHE
;
795 static void update_options_from_flags(QDict
*options
, int flags
)
797 if (!qdict_haskey(options
, BDRV_OPT_CACHE_DIRECT
)) {
798 qdict_put(options
, BDRV_OPT_CACHE_DIRECT
,
799 qbool_from_bool(flags
& BDRV_O_NOCACHE
));
801 if (!qdict_haskey(options
, BDRV_OPT_CACHE_NO_FLUSH
)) {
802 qdict_put(options
, BDRV_OPT_CACHE_NO_FLUSH
,
803 qbool_from_bool(flags
& BDRV_O_NO_FLUSH
));
807 static void bdrv_assign_node_name(BlockDriverState
*bs
,
808 const char *node_name
,
811 char *gen_node_name
= NULL
;
814 node_name
= gen_node_name
= id_generate(ID_BLOCK
);
815 } else if (!id_wellformed(node_name
)) {
817 * Check for empty string or invalid characters, but not if it is
818 * generated (generated names use characters not available to the user)
820 error_setg(errp
, "Invalid node name");
824 /* takes care of avoiding namespaces collisions */
825 if (blk_by_name(node_name
)) {
826 error_setg(errp
, "node-name=%s is conflicting with a device id",
831 /* takes care of avoiding duplicates node names */
832 if (bdrv_find_node(node_name
)) {
833 error_setg(errp
, "Duplicate node name");
837 /* copy node name into the bs and insert it into the graph list */
838 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
839 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
841 g_free(gen_node_name
);
844 static QemuOptsList bdrv_runtime_opts
= {
845 .name
= "bdrv_common",
846 .head
= QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts
.head
),
850 .type
= QEMU_OPT_STRING
,
851 .help
= "Node name of the block device node",
855 .type
= QEMU_OPT_STRING
,
856 .help
= "Block driver to use for the node",
859 .name
= BDRV_OPT_CACHE_DIRECT
,
860 .type
= QEMU_OPT_BOOL
,
861 .help
= "Bypass software writeback cache on the host",
864 .name
= BDRV_OPT_CACHE_NO_FLUSH
,
865 .type
= QEMU_OPT_BOOL
,
866 .help
= "Ignore flush requests",
868 { /* end of list */ }
873 * Common part for opening disk images and files
875 * Removes all processed options from *options.
877 static int bdrv_open_common(BlockDriverState
*bs
, BdrvChild
*file
,
878 QDict
*options
, Error
**errp
)
881 const char *filename
;
882 const char *driver_name
= NULL
;
883 const char *node_name
= NULL
;
886 Error
*local_err
= NULL
;
888 assert(bs
->file
== NULL
);
889 assert(options
!= NULL
&& bs
->options
!= options
);
891 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
892 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
894 error_propagate(errp
, local_err
);
899 driver_name
= qemu_opt_get(opts
, "driver");
900 drv
= bdrv_find_format(driver_name
);
904 filename
= file
->bs
->filename
;
906 filename
= qdict_get_try_str(options
, "filename");
909 if (drv
->bdrv_needs_filename
&& !filename
) {
910 error_setg(errp
, "The '%s' block driver requires a file name",
916 trace_bdrv_open_common(bs
, filename
?: "", bs
->open_flags
,
919 node_name
= qemu_opt_get(opts
, "node-name");
920 bdrv_assign_node_name(bs
, node_name
, &local_err
);
922 error_propagate(errp
, local_err
);
927 bs
->request_alignment
= 512;
928 bs
->zero_beyond_eof
= true;
929 bs
->read_only
= !(bs
->open_flags
& BDRV_O_RDWR
);
931 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
933 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
934 ? "Driver '%s' can only be used for read-only devices"
935 : "Driver '%s' is not whitelisted",
941 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
942 if (bs
->open_flags
& BDRV_O_COPY_ON_READ
) {
943 if (!bs
->read_only
) {
944 bdrv_enable_copy_on_read(bs
);
946 error_setg(errp
, "Can't use copy-on-read on read-only device");
952 if (filename
!= NULL
) {
953 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
955 bs
->filename
[0] = '\0';
957 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
960 bs
->opaque
= g_malloc0(drv
->instance_size
);
962 /* Apply cache mode options */
963 update_flags_from_options(&bs
->open_flags
, opts
);
965 /* Open the image, either directly or using a protocol */
966 open_flags
= bdrv_open_flags(bs
, bs
->open_flags
);
967 if (drv
->bdrv_file_open
) {
968 assert(file
== NULL
);
969 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
970 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
973 error_setg(errp
, "Can't use '%s' as a block driver for the "
974 "protocol level", drv
->format_name
);
979 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
984 error_propagate(errp
, local_err
);
985 } else if (bs
->filename
[0]) {
986 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
988 error_setg_errno(errp
, -ret
, "Could not open image");
993 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
995 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
999 bdrv_refresh_limits(bs
, &local_err
);
1001 error_propagate(errp
, local_err
);
1006 assert(bdrv_opt_mem_align(bs
) != 0);
1007 assert(bdrv_min_mem_align(bs
) != 0);
1008 assert((bs
->request_alignment
!= 0) || bdrv_is_sg(bs
));
1010 qemu_opts_del(opts
);
1019 qemu_opts_del(opts
);
1023 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1025 QObject
*options_obj
;
1029 ret
= strstart(filename
, "json:", &filename
);
1032 options_obj
= qobject_from_json(filename
);
1034 error_setg(errp
, "Could not parse the JSON options");
1038 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1039 qobject_decref(options_obj
);
1040 error_setg(errp
, "Invalid JSON object given");
1044 options
= qobject_to_qdict(options_obj
);
1045 qdict_flatten(options
);
1050 static void parse_json_protocol(QDict
*options
, const char **pfilename
,
1053 QDict
*json_options
;
1054 Error
*local_err
= NULL
;
1056 /* Parse json: pseudo-protocol */
1057 if (!*pfilename
|| !g_str_has_prefix(*pfilename
, "json:")) {
1061 json_options
= parse_json_filename(*pfilename
, &local_err
);
1063 error_propagate(errp
, local_err
);
1067 /* Options given in the filename have lower priority than options
1068 * specified directly */
1069 qdict_join(options
, json_options
, false);
1070 QDECREF(json_options
);
1075 * Fills in default options for opening images and converts the legacy
1076 * filename/flags pair to option QDict entries.
1077 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1078 * block driver has been specified explicitly.
1080 static int bdrv_fill_options(QDict
**options
, const char *filename
,
1081 int *flags
, Error
**errp
)
1083 const char *drvname
;
1084 bool protocol
= *flags
& BDRV_O_PROTOCOL
;
1085 bool parse_filename
= false;
1086 BlockDriver
*drv
= NULL
;
1087 Error
*local_err
= NULL
;
1089 drvname
= qdict_get_try_str(*options
, "driver");
1091 drv
= bdrv_find_format(drvname
);
1093 error_setg(errp
, "Unknown driver '%s'", drvname
);
1096 /* If the user has explicitly specified the driver, this choice should
1097 * override the BDRV_O_PROTOCOL flag */
1098 protocol
= drv
->bdrv_file_open
;
1102 *flags
|= BDRV_O_PROTOCOL
;
1104 *flags
&= ~BDRV_O_PROTOCOL
;
1107 /* Translate cache options from flags into options */
1108 update_options_from_flags(*options
, *flags
);
1110 /* Fetch the file name from the options QDict if necessary */
1111 if (protocol
&& filename
) {
1112 if (!qdict_haskey(*options
, "filename")) {
1113 qdict_put(*options
, "filename", qstring_from_str(filename
));
1114 parse_filename
= true;
1116 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1122 /* Find the right block driver */
1123 filename
= qdict_get_try_str(*options
, "filename");
1125 if (!drvname
&& protocol
) {
1127 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1132 drvname
= drv
->format_name
;
1133 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1135 error_setg(errp
, "Must specify either driver or file");
1140 assert(drv
|| !protocol
);
1142 /* Driver-specific filename parsing */
1143 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1144 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1146 error_propagate(errp
, local_err
);
1150 if (!drv
->bdrv_needs_filename
) {
1151 qdict_del(*options
, "filename");
1158 BdrvChild
*bdrv_root_attach_child(BlockDriverState
*child_bs
,
1159 const char *child_name
,
1160 const BdrvChildRole
*child_role
)
1162 BdrvChild
*child
= g_new(BdrvChild
, 1);
1163 *child
= (BdrvChild
) {
1165 .name
= g_strdup(child_name
),
1169 QLIST_INSERT_HEAD(&child_bs
->parents
, child
, next_parent
);
1174 BdrvChild
*bdrv_attach_child(BlockDriverState
*parent_bs
,
1175 BlockDriverState
*child_bs
,
1176 const char *child_name
,
1177 const BdrvChildRole
*child_role
)
1179 BdrvChild
*child
= bdrv_root_attach_child(child_bs
, child_name
, child_role
);
1180 QLIST_INSERT_HEAD(&parent_bs
->children
, child
, next
);
1184 static void bdrv_detach_child(BdrvChild
*child
)
1186 if (child
->next
.le_prev
) {
1187 QLIST_REMOVE(child
, next
);
1188 child
->next
.le_prev
= NULL
;
1190 QLIST_REMOVE(child
, next_parent
);
1191 g_free(child
->name
);
1195 void bdrv_root_unref_child(BdrvChild
*child
)
1197 BlockDriverState
*child_bs
;
1199 child_bs
= child
->bs
;
1200 bdrv_detach_child(child
);
1201 bdrv_unref(child_bs
);
1204 void bdrv_unref_child(BlockDriverState
*parent
, BdrvChild
*child
)
1206 if (child
== NULL
) {
1210 if (child
->bs
->inherits_from
== parent
) {
1211 child
->bs
->inherits_from
= NULL
;
1214 bdrv_root_unref_child(child
);
1218 * Sets the backing file link of a BDS. A new reference is created; callers
1219 * which don't need their own reference any more must call bdrv_unref().
1221 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1224 bdrv_ref(backing_hd
);
1228 assert(bs
->backing_blocker
);
1229 bdrv_op_unblock_all(bs
->backing
->bs
, bs
->backing_blocker
);
1230 bdrv_unref_child(bs
, bs
->backing
);
1231 } else if (backing_hd
) {
1232 error_setg(&bs
->backing_blocker
,
1233 "node is used as backing hd of '%s'",
1234 bdrv_get_device_or_node_name(bs
));
1238 error_free(bs
->backing_blocker
);
1239 bs
->backing_blocker
= NULL
;
1243 bs
->backing
= bdrv_attach_child(bs
, backing_hd
, "backing", &child_backing
);
1244 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1245 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1246 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1247 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1249 bdrv_op_block_all(backing_hd
, bs
->backing_blocker
);
1250 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1251 bdrv_op_unblock(backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1252 bs
->backing_blocker
);
1254 bdrv_refresh_limits(bs
, NULL
);
1258 * Opens the backing file for a BlockDriverState if not yet open
1260 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1261 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1262 * itself, all options starting with "${bdref_key}." are considered part of the
1265 * TODO Can this be unified with bdrv_open_image()?
1267 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*parent_options
,
1268 const char *bdref_key
, Error
**errp
)
1270 char *backing_filename
= g_malloc0(PATH_MAX
);
1271 char *bdref_key_dot
;
1272 const char *reference
= NULL
;
1274 BlockDriverState
*backing_hd
;
1276 QDict
*tmp_parent_options
= NULL
;
1277 Error
*local_err
= NULL
;
1279 if (bs
->backing
!= NULL
) {
1283 /* NULL means an empty set of options */
1284 if (parent_options
== NULL
) {
1285 tmp_parent_options
= qdict_new();
1286 parent_options
= tmp_parent_options
;
1289 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1291 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1292 qdict_extract_subqdict(parent_options
, &options
, bdref_key_dot
);
1293 g_free(bdref_key_dot
);
1295 reference
= qdict_get_try_str(parent_options
, bdref_key
);
1296 if (reference
|| qdict_haskey(options
, "file.filename")) {
1297 backing_filename
[0] = '\0';
1298 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1302 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1306 error_propagate(errp
, local_err
);
1312 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1314 error_setg(errp
, "Driver doesn't support backing files");
1319 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1320 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1324 ret
= bdrv_open_inherit(&backing_hd
,
1325 *backing_filename
? backing_filename
: NULL
,
1326 reference
, options
, 0, bs
, &child_backing
,
1329 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1330 error_prepend(errp
, "Could not open backing file: ");
1334 /* Hook up the backing file link; drop our reference, bs owns the
1335 * backing_hd reference now */
1336 bdrv_set_backing_hd(bs
, backing_hd
);
1337 bdrv_unref(backing_hd
);
1339 qdict_del(parent_options
, bdref_key
);
1342 g_free(backing_filename
);
1343 QDECREF(tmp_parent_options
);
1348 * Opens a disk image whose options are given as BlockdevRef in another block
1351 * If allow_none is true, no image will be opened if filename is false and no
1352 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1354 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1355 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1356 * itself, all options starting with "${bdref_key}." are considered part of the
1359 * The BlockdevRef will be removed from the options QDict.
1361 BdrvChild
*bdrv_open_child(const char *filename
,
1362 QDict
*options
, const char *bdref_key
,
1363 BlockDriverState
* parent
,
1364 const BdrvChildRole
*child_role
,
1365 bool allow_none
, Error
**errp
)
1367 BdrvChild
*c
= NULL
;
1368 BlockDriverState
*bs
;
1369 QDict
*image_options
;
1371 char *bdref_key_dot
;
1372 const char *reference
;
1374 assert(child_role
!= NULL
);
1376 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1377 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1378 g_free(bdref_key_dot
);
1380 reference
= qdict_get_try_str(options
, bdref_key
);
1381 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1383 error_setg(errp
, "A block device must be specified for \"%s\"",
1386 QDECREF(image_options
);
1391 ret
= bdrv_open_inherit(&bs
, filename
, reference
, image_options
, 0,
1392 parent
, child_role
, errp
);
1397 c
= bdrv_attach_child(parent
, bs
, bdref_key
, child_role
);
1400 qdict_del(options
, bdref_key
);
1404 static int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
,
1405 QDict
*snapshot_options
, Error
**errp
)
1407 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1408 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1410 QemuOpts
*opts
= NULL
;
1411 BlockDriverState
*bs_snapshot
;
1412 Error
*local_err
= NULL
;
1415 /* if snapshot, we create a temporary backing file and open it
1416 instead of opening 'filename' directly */
1418 /* Get the required size from the image */
1419 total_size
= bdrv_getlength(bs
);
1420 if (total_size
< 0) {
1422 error_setg_errno(errp
, -total_size
, "Could not get image size");
1426 /* Create the temporary image */
1427 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1429 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1433 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1435 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1436 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, errp
);
1437 qemu_opts_del(opts
);
1439 error_prepend(errp
, "Could not create temporary overlay '%s': ",
1444 /* Prepare options QDict for the temporary file */
1445 qdict_put(snapshot_options
, "file.driver",
1446 qstring_from_str("file"));
1447 qdict_put(snapshot_options
, "file.filename",
1448 qstring_from_str(tmp_filename
));
1449 qdict_put(snapshot_options
, "driver",
1450 qstring_from_str("qcow2"));
1452 bs_snapshot
= bdrv_new();
1454 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1456 snapshot_options
= NULL
;
1458 error_propagate(errp
, local_err
);
1462 bdrv_append(bs_snapshot
, bs
);
1465 QDECREF(snapshot_options
);
1466 g_free(tmp_filename
);
1471 * Opens a disk image (raw, qcow2, vmdk, ...)
1473 * options is a QDict of options to pass to the block drivers, or NULL for an
1474 * empty set of options. The reference to the QDict belongs to the block layer
1475 * after the call (even on failure), so if the caller intends to reuse the
1476 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1478 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1479 * If it is not NULL, the referenced BDS will be reused.
1481 * The reference parameter may be used to specify an existing block device which
1482 * should be opened. If specified, neither options nor a filename may be given,
1483 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1485 static int bdrv_open_inherit(BlockDriverState
**pbs
, const char *filename
,
1486 const char *reference
, QDict
*options
, int flags
,
1487 BlockDriverState
*parent
,
1488 const BdrvChildRole
*child_role
, Error
**errp
)
1491 BdrvChild
*file
= NULL
;
1492 BlockDriverState
*bs
;
1493 BlockDriver
*drv
= NULL
;
1494 const char *drvname
;
1495 const char *backing
;
1496 Error
*local_err
= NULL
;
1497 QDict
*snapshot_options
= NULL
;
1498 int snapshot_flags
= 0;
1501 assert(!child_role
|| !flags
);
1502 assert(!child_role
== !parent
);
1505 bool options_non_empty
= options
? qdict_size(options
) : false;
1509 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1510 "another block device");
1514 if (filename
|| options_non_empty
) {
1515 error_setg(errp
, "Cannot reference an existing block device with "
1516 "additional options or a new filename");
1520 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1525 if (bs
->blk
&& blk_get_public(bs
->blk
)->throttle_state
) {
1526 error_setg(errp
, "Cannot reference an existing block device for "
1527 "which I/O throttling is enabled");
1542 /* NULL means an empty set of options */
1543 if (options
== NULL
) {
1544 options
= qdict_new();
1547 /* json: syntax counts as explicit options, as if in the QDict */
1548 parse_json_protocol(options
, &filename
, &local_err
);
1554 bs
->explicit_options
= qdict_clone_shallow(options
);
1557 bs
->inherits_from
= parent
;
1558 child_role
->inherit_options(&flags
, options
,
1559 parent
->open_flags
, parent
->options
);
1562 ret
= bdrv_fill_options(&options
, filename
, &flags
, &local_err
);
1567 bs
->open_flags
= flags
;
1568 bs
->options
= options
;
1569 options
= qdict_clone_shallow(options
);
1571 /* Find the right image format driver */
1572 drvname
= qdict_get_try_str(options
, "driver");
1574 drv
= bdrv_find_format(drvname
);
1576 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1582 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1584 backing
= qdict_get_try_str(options
, "backing");
1585 if (backing
&& *backing
== '\0') {
1586 flags
|= BDRV_O_NO_BACKING
;
1587 qdict_del(options
, "backing");
1590 /* Open image file without format layer */
1591 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1592 if (flags
& BDRV_O_RDWR
) {
1593 flags
|= BDRV_O_ALLOW_RDWR
;
1595 if (flags
& BDRV_O_SNAPSHOT
) {
1596 snapshot_options
= qdict_new();
1597 bdrv_temp_snapshot_options(&snapshot_flags
, snapshot_options
,
1599 bdrv_backing_options(&flags
, options
, flags
, options
);
1602 bs
->open_flags
= flags
;
1604 file
= bdrv_open_child(filename
, options
, "file", bs
,
1605 &child_file
, true, &local_err
);
1612 /* Image format probing */
1615 ret
= find_image_format(file
->bs
, filename
, &drv
, &local_err
);
1620 * This option update would logically belong in bdrv_fill_options(),
1621 * but we first need to open bs->file for the probing to work, while
1622 * opening bs->file already requires the (mostly) final set of options
1623 * so that cache mode etc. can be inherited.
1625 * Adding the driver later is somewhat ugly, but it's not an option
1626 * that would ever be inherited, so it's correct. We just need to make
1627 * sure to update both bs->options (which has the full effective
1628 * options for bs) and options (which has file.* already removed).
1630 qdict_put(bs
->options
, "driver", qstring_from_str(drv
->format_name
));
1631 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1633 error_setg(errp
, "Must specify either driver or file");
1638 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1639 assert(!!(flags
& BDRV_O_PROTOCOL
) == !!drv
->bdrv_file_open
);
1640 /* file must be NULL if a protocol BDS is about to be created
1641 * (the inverse results in an error message from bdrv_open_common()) */
1642 assert(!(flags
& BDRV_O_PROTOCOL
) || !file
);
1644 /* Open the image */
1645 ret
= bdrv_open_common(bs
, file
, options
, &local_err
);
1650 if (file
&& (bs
->file
!= file
)) {
1651 bdrv_unref_child(bs
, file
);
1655 /* If there is a backing file, use it */
1656 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1657 ret
= bdrv_open_backing_file(bs
, options
, "backing", &local_err
);
1659 goto close_and_fail
;
1663 bdrv_refresh_filename(bs
);
1665 /* Check if any unknown options were used */
1666 if (options
&& (qdict_size(options
) != 0)) {
1667 const QDictEntry
*entry
= qdict_first(options
);
1668 if (flags
& BDRV_O_PROTOCOL
) {
1669 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1670 "'%s'", drv
->format_name
, entry
->key
);
1673 "Block format '%s' does not support the option '%s'",
1674 drv
->format_name
, entry
->key
);
1678 goto close_and_fail
;
1681 if (!bdrv_key_required(bs
)) {
1683 blk_dev_change_media_cb(bs
->blk
, true);
1685 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1686 && !runstate_check(RUN_STATE_INMIGRATE
)
1687 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1689 "Guest must be stopped for opening of encrypted image");
1691 goto close_and_fail
;
1697 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1698 * temporary snapshot afterwards. */
1699 if (snapshot_flags
) {
1700 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, snapshot_options
,
1702 snapshot_options
= NULL
;
1704 goto close_and_fail
;
1712 bdrv_unref_child(bs
, file
);
1714 QDECREF(snapshot_options
);
1715 QDECREF(bs
->explicit_options
);
1716 QDECREF(bs
->options
);
1720 /* If *pbs is NULL, a new BDS has been created in this function and
1721 needs to be freed now. Otherwise, it does not need to be closed,
1722 since it has not really been opened yet. */
1726 error_propagate(errp
, local_err
);
1731 /* See fail path, but now the BDS has to be always closed */
1737 QDECREF(snapshot_options
);
1740 error_propagate(errp
, local_err
);
1745 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1746 const char *reference
, QDict
*options
, int flags
, Error
**errp
)
1748 return bdrv_open_inherit(pbs
, filename
, reference
, options
, flags
, NULL
,
1752 typedef struct BlockReopenQueueEntry
{
1754 BDRVReopenState state
;
1755 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1756 } BlockReopenQueueEntry
;
1759 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1760 * reopen of multiple devices.
1762 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1763 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1764 * be created and initialized. This newly created BlockReopenQueue should be
1765 * passed back in for subsequent calls that are intended to be of the same
1768 * bs is the BlockDriverState to add to the reopen queue.
1770 * options contains the changed options for the associated bs
1771 * (the BlockReopenQueue takes ownership)
1773 * flags contains the open flags for the associated bs
1775 * returns a pointer to bs_queue, which is either the newly allocated
1776 * bs_queue, or the existing bs_queue being used.
1779 static BlockReopenQueue
*bdrv_reopen_queue_child(BlockReopenQueue
*bs_queue
,
1780 BlockDriverState
*bs
,
1783 const BdrvChildRole
*role
,
1784 QDict
*parent_options
,
1789 BlockReopenQueueEntry
*bs_entry
;
1791 QDict
*old_options
, *explicit_options
;
1793 if (bs_queue
== NULL
) {
1794 bs_queue
= g_new0(BlockReopenQueue
, 1);
1795 QSIMPLEQ_INIT(bs_queue
);
1799 options
= qdict_new();
1803 * Precedence of options:
1804 * 1. Explicitly passed in options (highest)
1805 * 2. Set in flags (only for top level)
1806 * 3. Retained from explicitly set options of bs
1807 * 4. Inherited from parent node
1808 * 5. Retained from effective options of bs
1811 if (!parent_options
) {
1813 * Any setting represented by flags is always updated. If the
1814 * corresponding QDict option is set, it takes precedence. Otherwise
1815 * the flag is translated into a QDict option. The old setting of bs is
1818 update_options_from_flags(options
, flags
);
1821 /* Old explicitly set values (don't overwrite by inherited value) */
1822 old_options
= qdict_clone_shallow(bs
->explicit_options
);
1823 bdrv_join_options(bs
, options
, old_options
);
1824 QDECREF(old_options
);
1826 explicit_options
= qdict_clone_shallow(options
);
1828 /* Inherit from parent node */
1829 if (parent_options
) {
1831 role
->inherit_options(&flags
, options
, parent_flags
, parent_options
);
1834 /* Old values are used for options that aren't set yet */
1835 old_options
= qdict_clone_shallow(bs
->options
);
1836 bdrv_join_options(bs
, options
, old_options
);
1837 QDECREF(old_options
);
1839 /* bdrv_open() masks this flag out */
1840 flags
&= ~BDRV_O_PROTOCOL
;
1842 QLIST_FOREACH(child
, &bs
->children
, next
) {
1843 QDict
*new_child_options
;
1844 char *child_key_dot
;
1846 /* reopen can only change the options of block devices that were
1847 * implicitly created and inherited options. For other (referenced)
1848 * block devices, a syntax like "backing.foo" results in an error. */
1849 if (child
->bs
->inherits_from
!= bs
) {
1853 child_key_dot
= g_strdup_printf("%s.", child
->name
);
1854 qdict_extract_subqdict(options
, &new_child_options
, child_key_dot
);
1855 g_free(child_key_dot
);
1857 bdrv_reopen_queue_child(bs_queue
, child
->bs
, new_child_options
, 0,
1858 child
->role
, options
, flags
);
1861 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1862 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1864 bs_entry
->state
.bs
= bs
;
1865 bs_entry
->state
.options
= options
;
1866 bs_entry
->state
.explicit_options
= explicit_options
;
1867 bs_entry
->state
.flags
= flags
;
1872 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1873 BlockDriverState
*bs
,
1874 QDict
*options
, int flags
)
1876 return bdrv_reopen_queue_child(bs_queue
, bs
, options
, flags
,
1881 * Reopen multiple BlockDriverStates atomically & transactionally.
1883 * The queue passed in (bs_queue) must have been built up previous
1884 * via bdrv_reopen_queue().
1886 * Reopens all BDS specified in the queue, with the appropriate
1887 * flags. All devices are prepared for reopen, and failure of any
1888 * device will cause all device changes to be abandonded, and intermediate
1891 * If all devices prepare successfully, then the changes are committed
1895 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1898 BlockReopenQueueEntry
*bs_entry
, *next
;
1899 Error
*local_err
= NULL
;
1901 assert(bs_queue
!= NULL
);
1905 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1906 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1907 error_propagate(errp
, local_err
);
1910 bs_entry
->prepared
= true;
1913 /* If we reach this point, we have success and just need to apply the
1916 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1917 bdrv_reopen_commit(&bs_entry
->state
);
1923 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1924 if (ret
&& bs_entry
->prepared
) {
1925 bdrv_reopen_abort(&bs_entry
->state
);
1927 QDECREF(bs_entry
->state
.explicit_options
);
1929 QDECREF(bs_entry
->state
.options
);
1937 /* Reopen a single BlockDriverState with the specified flags. */
1938 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1941 Error
*local_err
= NULL
;
1942 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, NULL
, bdrv_flags
);
1944 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1945 if (local_err
!= NULL
) {
1946 error_propagate(errp
, local_err
);
1953 * Prepares a BlockDriverState for reopen. All changes are staged in the
1954 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1955 * the block driver layer .bdrv_reopen_prepare()
1957 * bs is the BlockDriverState to reopen
1958 * flags are the new open flags
1959 * queue is the reopen queue
1961 * Returns 0 on success, non-zero on error. On error errp will be set
1964 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1965 * It is the responsibility of the caller to then call the abort() or
1966 * commit() for any other BDS that have been left in a prepare() state
1969 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1973 Error
*local_err
= NULL
;
1978 assert(reopen_state
!= NULL
);
1979 assert(reopen_state
->bs
->drv
!= NULL
);
1980 drv
= reopen_state
->bs
->drv
;
1982 /* Process generic block layer options */
1983 opts
= qemu_opts_create(&bdrv_runtime_opts
, NULL
, 0, &error_abort
);
1984 qemu_opts_absorb_qdict(opts
, reopen_state
->options
, &local_err
);
1986 error_propagate(errp
, local_err
);
1991 update_flags_from_options(&reopen_state
->flags
, opts
);
1993 /* node-name and driver must be unchanged. Put them back into the QDict, so
1994 * that they are checked at the end of this function. */
1995 value
= qemu_opt_get(opts
, "node-name");
1997 qdict_put(reopen_state
->options
, "node-name", qstring_from_str(value
));
2000 value
= qemu_opt_get(opts
, "driver");
2002 qdict_put(reopen_state
->options
, "driver", qstring_from_str(value
));
2005 /* if we are to stay read-only, do not allow permission change
2007 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
2008 reopen_state
->flags
& BDRV_O_RDWR
) {
2009 error_setg(errp
, "Node '%s' is read only",
2010 bdrv_get_device_or_node_name(reopen_state
->bs
));
2015 ret
= bdrv_flush(reopen_state
->bs
);
2017 error_setg_errno(errp
, -ret
, "Error flushing drive");
2021 if (drv
->bdrv_reopen_prepare
) {
2022 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
2024 if (local_err
!= NULL
) {
2025 error_propagate(errp
, local_err
);
2027 error_setg(errp
, "failed while preparing to reopen image '%s'",
2028 reopen_state
->bs
->filename
);
2033 /* It is currently mandatory to have a bdrv_reopen_prepare()
2034 * handler for each supported drv. */
2035 error_setg(errp
, "Block format '%s' used by node '%s' "
2036 "does not support reopening files", drv
->format_name
,
2037 bdrv_get_device_or_node_name(reopen_state
->bs
));
2042 /* Options that are not handled are only okay if they are unchanged
2043 * compared to the old state. It is expected that some options are only
2044 * used for the initial open, but not reopen (e.g. filename) */
2045 if (qdict_size(reopen_state
->options
)) {
2046 const QDictEntry
*entry
= qdict_first(reopen_state
->options
);
2049 QString
*new_obj
= qobject_to_qstring(entry
->value
);
2050 const char *new = qstring_get_str(new_obj
);
2051 const char *old
= qdict_get_try_str(reopen_state
->bs
->options
,
2054 if (!old
|| strcmp(new, old
)) {
2055 error_setg(errp
, "Cannot change the option '%s'", entry
->key
);
2059 } while ((entry
= qdict_next(reopen_state
->options
, entry
)));
2065 qemu_opts_del(opts
);
2070 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2071 * makes them final by swapping the staging BlockDriverState contents into
2072 * the active BlockDriverState contents.
2074 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
2078 assert(reopen_state
!= NULL
);
2079 drv
= reopen_state
->bs
->drv
;
2080 assert(drv
!= NULL
);
2082 /* If there are any driver level actions to take */
2083 if (drv
->bdrv_reopen_commit
) {
2084 drv
->bdrv_reopen_commit(reopen_state
);
2087 /* set BDS specific flags now */
2088 QDECREF(reopen_state
->bs
->explicit_options
);
2090 reopen_state
->bs
->explicit_options
= reopen_state
->explicit_options
;
2091 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
2092 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
2094 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
2098 * Abort the reopen, and delete and free the staged changes in
2101 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
2105 assert(reopen_state
!= NULL
);
2106 drv
= reopen_state
->bs
->drv
;
2107 assert(drv
!= NULL
);
2109 if (drv
->bdrv_reopen_abort
) {
2110 drv
->bdrv_reopen_abort(reopen_state
);
2113 QDECREF(reopen_state
->explicit_options
);
2117 static void bdrv_close(BlockDriverState
*bs
)
2119 BdrvAioNotifier
*ban
, *ban_next
;
2123 bdrv_drained_begin(bs
); /* complete I/O */
2125 bdrv_drain(bs
); /* in case flush left pending I/O */
2127 bdrv_release_named_dirty_bitmaps(bs
);
2128 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2131 blk_dev_change_media_cb(bs
->blk
, false);
2135 BdrvChild
*child
, *next
;
2137 bs
->drv
->bdrv_close(bs
);
2140 bdrv_set_backing_hd(bs
, NULL
);
2142 if (bs
->file
!= NULL
) {
2143 bdrv_unref_child(bs
, bs
->file
);
2147 QLIST_FOREACH_SAFE(child
, &bs
->children
, next
, next
) {
2148 /* TODO Remove bdrv_unref() from drivers' close function and use
2149 * bdrv_unref_child() here */
2150 if (child
->bs
->inherits_from
== bs
) {
2151 child
->bs
->inherits_from
= NULL
;
2153 bdrv_detach_child(child
);
2158 bs
->copy_on_read
= 0;
2159 bs
->backing_file
[0] = '\0';
2160 bs
->backing_format
[0] = '\0';
2161 bs
->total_sectors
= 0;
2165 bs
->zero_beyond_eof
= false;
2166 QDECREF(bs
->options
);
2167 QDECREF(bs
->explicit_options
);
2169 QDECREF(bs
->full_open_options
);
2170 bs
->full_open_options
= NULL
;
2173 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
2176 QLIST_INIT(&bs
->aio_notifiers
);
2177 bdrv_drained_end(bs
);
2180 void bdrv_close_all(void)
2182 BlockDriverState
*bs
;
2183 AioContext
*aio_context
;
2185 /* Drop references from requests still in flight, such as canceled block
2186 * jobs whose AIO context has not been polled yet */
2189 blk_remove_all_bs();
2190 blockdev_close_all_bdrv_states();
2192 /* Cancel all block jobs */
2193 while (!QTAILQ_EMPTY(&all_bdrv_states
)) {
2194 QTAILQ_FOREACH(bs
, &all_bdrv_states
, bs_list
) {
2195 aio_context
= bdrv_get_aio_context(bs
);
2197 aio_context_acquire(aio_context
);
2199 block_job_cancel_sync(bs
->job
);
2200 aio_context_release(aio_context
);
2203 aio_context_release(aio_context
);
2206 /* All the remaining BlockDriverStates are referenced directly or
2207 * indirectly from block jobs, so there needs to be at least one BDS
2208 * directly used by a block job */
2213 /* Fields that need to stay with the top-level BDS */
2214 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2215 BlockDriverState
*bs_src
)
2217 /* move some fields that need to stay attached to the device */
2220 static void change_parent_backing_link(BlockDriverState
*from
,
2221 BlockDriverState
*to
)
2223 BdrvChild
*c
, *next
;
2226 /* FIXME We bypass blk_set_bs(), so we need to make these updates
2227 * manually. The root problem is not in this change function, but the
2228 * existence of BlockDriverState.blk. */
2229 to
->blk
= from
->blk
;
2233 QLIST_FOREACH_SAFE(c
, &from
->parents
, next_parent
, next
) {
2234 assert(c
->role
!= &child_backing
);
2236 QLIST_REMOVE(c
, next_parent
);
2237 QLIST_INSERT_HEAD(&to
->parents
, c
, next_parent
);
2243 static void swap_feature_fields(BlockDriverState
*bs_top
,
2244 BlockDriverState
*bs_new
)
2246 BlockDriverState tmp
;
2248 bdrv_move_feature_fields(&tmp
, bs_top
);
2249 bdrv_move_feature_fields(bs_top
, bs_new
);
2250 bdrv_move_feature_fields(bs_new
, &tmp
);
2254 * Add new bs contents at the top of an image chain while the chain is
2255 * live, while keeping required fields on the top layer.
2257 * This will modify the BlockDriverState fields, and swap contents
2258 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2260 * bs_new must not be attached to a BlockBackend.
2262 * This function does not create any image files.
2264 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2265 * that's what the callers commonly need. bs_new will be referenced by the old
2266 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2267 * reference of its own, it must call bdrv_ref().
2269 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2271 assert(!bdrv_requests_pending(bs_top
));
2272 assert(!bdrv_requests_pending(bs_new
));
2276 /* Some fields always stay on top of the backing file chain */
2277 swap_feature_fields(bs_top
, bs_new
);
2279 change_parent_backing_link(bs_top
, bs_new
);
2280 bdrv_set_backing_hd(bs_new
, bs_top
);
2283 /* bs_new is now referenced by its new parents, we don't need the
2284 * additional reference any more. */
2288 void bdrv_replace_in_backing_chain(BlockDriverState
*old
, BlockDriverState
*new)
2290 assert(!bdrv_requests_pending(old
));
2291 assert(!bdrv_requests_pending(new));
2296 /* As long as these fields aren't in BlockBackend, but in the top-level
2297 * BlockDriverState, it's not possible for a BDS to have two BBs.
2299 * We really want to copy the fields from old to new, but we go for a
2300 * swap instead so that pointers aren't duplicated and cause trouble.
2301 * (Also, bdrv_swap() used to do the same.) */
2303 swap_feature_fields(old
, new);
2305 change_parent_backing_link(old
, new);
2307 /* Change backing files if a previously independent node is added to the
2308 * chain. For active commit, we replace top by its own (indirect) backing
2309 * file and don't do anything here so we don't build a loop. */
2310 if (new->backing
== NULL
&& !bdrv_chain_contains(backing_bs(old
), new)) {
2311 bdrv_set_backing_hd(new, backing_bs(old
));
2312 bdrv_set_backing_hd(old
, NULL
);
2318 static void bdrv_delete(BlockDriverState
*bs
)
2321 assert(bdrv_op_blocker_is_empty(bs
));
2322 assert(!bs
->refcnt
);
2326 /* remove from list, if necessary */
2327 if (bs
->node_name
[0] != '\0') {
2328 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2330 QTAILQ_REMOVE(&all_bdrv_states
, bs
, bs_list
);
2336 * Run consistency checks on an image
2338 * Returns 0 if the check could be completed (it doesn't mean that the image is
2339 * free of errors) or -errno when an internal error occurred. The results of the
2340 * check are stored in res.
2342 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2344 if (bs
->drv
== NULL
) {
2347 if (bs
->drv
->bdrv_check
== NULL
) {
2351 memset(res
, 0, sizeof(*res
));
2352 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2355 #define COMMIT_BUF_SECTORS 2048
2357 /* commit COW file into the raw image */
2358 int bdrv_commit(BlockDriverState
*bs
)
2360 BlockDriver
*drv
= bs
->drv
;
2361 int64_t sector
, total_sectors
, length
, backing_length
;
2362 int n
, ro
, open_flags
;
2364 uint8_t *buf
= NULL
;
2373 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2374 bdrv_op_is_blocked(bs
->backing
->bs
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2378 ro
= bs
->backing
->bs
->read_only
;
2379 open_flags
= bs
->backing
->bs
->open_flags
;
2382 if (bdrv_reopen(bs
->backing
->bs
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2387 length
= bdrv_getlength(bs
);
2393 backing_length
= bdrv_getlength(bs
->backing
->bs
);
2394 if (backing_length
< 0) {
2395 ret
= backing_length
;
2399 /* If our top snapshot is larger than the backing file image,
2400 * grow the backing file image if possible. If not possible,
2401 * we must return an error */
2402 if (length
> backing_length
) {
2403 ret
= bdrv_truncate(bs
->backing
->bs
, length
);
2409 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2411 /* qemu_try_blockalign() for bs will choose an alignment that works for
2412 * bs->backing->bs as well, so no need to compare the alignment manually. */
2413 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2419 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2420 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2425 ret
= bdrv_read(bs
, sector
, buf
, n
);
2430 ret
= bdrv_write(bs
->backing
->bs
, sector
, buf
, n
);
2437 if (drv
->bdrv_make_empty
) {
2438 ret
= drv
->bdrv_make_empty(bs
);
2446 * Make sure all data we wrote to the backing device is actually
2450 bdrv_flush(bs
->backing
->bs
);
2458 /* ignoring error return here */
2459 bdrv_reopen(bs
->backing
->bs
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2468 * -EINVAL - backing format specified, but no file
2469 * -ENOSPC - can't update the backing file because no space is left in the
2471 * -ENOTSUP - format driver doesn't support changing the backing file
2473 int bdrv_change_backing_file(BlockDriverState
*bs
,
2474 const char *backing_file
, const char *backing_fmt
)
2476 BlockDriver
*drv
= bs
->drv
;
2479 /* Backing file format doesn't make sense without a backing file */
2480 if (backing_fmt
&& !backing_file
) {
2484 if (drv
->bdrv_change_backing_file
!= NULL
) {
2485 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2491 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2492 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2498 * Finds the image layer in the chain that has 'bs' as its backing file.
2500 * active is the current topmost image.
2502 * Returns NULL if bs is not found in active's image chain,
2503 * or if active == bs.
2505 * Returns the bottommost base image if bs == NULL.
2507 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2508 BlockDriverState
*bs
)
2510 while (active
&& bs
!= backing_bs(active
)) {
2511 active
= backing_bs(active
);
2517 /* Given a BDS, searches for the base layer. */
2518 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2520 return bdrv_find_overlay(bs
, NULL
);
2524 * Drops images above 'base' up to and including 'top', and sets the image
2525 * above 'top' to have base as its backing file.
2527 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2528 * information in 'bs' can be properly updated.
2530 * E.g., this will convert the following chain:
2531 * bottom <- base <- intermediate <- top <- active
2535 * bottom <- base <- active
2537 * It is allowed for bottom==base, in which case it converts:
2539 * base <- intermediate <- top <- active
2545 * If backing_file_str is non-NULL, it will be used when modifying top's
2546 * overlay image metadata.
2549 * if active == top, that is considered an error
2552 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2553 BlockDriverState
*base
, const char *backing_file_str
)
2555 BlockDriverState
*new_top_bs
= NULL
;
2558 if (!top
->drv
|| !base
->drv
) {
2562 new_top_bs
= bdrv_find_overlay(active
, top
);
2564 if (new_top_bs
== NULL
) {
2565 /* we could not find the image above 'top', this is an error */
2569 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2570 * to do, no intermediate images */
2571 if (backing_bs(new_top_bs
) == base
) {
2576 /* Make sure that base is in the backing chain of top */
2577 if (!bdrv_chain_contains(top
, base
)) {
2581 /* success - we can delete the intermediate states, and link top->base */
2582 backing_file_str
= backing_file_str
? backing_file_str
: base
->filename
;
2583 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2584 base
->drv
? base
->drv
->format_name
: "");
2588 bdrv_set_backing_hd(new_top_bs
, base
);
2596 * Truncate file to 'offset' bytes (needed only for file protocols)
2598 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2600 BlockDriver
*drv
= bs
->drv
;
2604 if (!drv
->bdrv_truncate
)
2609 ret
= drv
->bdrv_truncate(bs
, offset
);
2611 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2612 bdrv_dirty_bitmap_truncate(bs
);
2614 blk_dev_resize_cb(bs
->blk
);
2621 * Length of a allocated file in bytes. Sparse files are counted by actual
2622 * allocated space. Return < 0 if error or unknown.
2624 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2626 BlockDriver
*drv
= bs
->drv
;
2630 if (drv
->bdrv_get_allocated_file_size
) {
2631 return drv
->bdrv_get_allocated_file_size(bs
);
2634 return bdrv_get_allocated_file_size(bs
->file
->bs
);
2640 * Return number of sectors on success, -errno on error.
2642 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
2644 BlockDriver
*drv
= bs
->drv
;
2649 if (drv
->has_variable_length
) {
2650 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
2655 return bs
->total_sectors
;
2659 * Return length in bytes on success, -errno on error.
2660 * The length is always a multiple of BDRV_SECTOR_SIZE.
2662 int64_t bdrv_getlength(BlockDriverState
*bs
)
2664 int64_t ret
= bdrv_nb_sectors(bs
);
2666 ret
= ret
> INT64_MAX
/ BDRV_SECTOR_SIZE
? -EFBIG
: ret
;
2667 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
2670 /* return 0 as number of sectors if no device present or error */
2671 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2673 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
2675 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
2678 int bdrv_is_read_only(BlockDriverState
*bs
)
2680 return bs
->read_only
;
2683 int bdrv_is_sg(BlockDriverState
*bs
)
2688 int bdrv_is_encrypted(BlockDriverState
*bs
)
2690 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2693 return bs
->encrypted
;
2696 int bdrv_key_required(BlockDriverState
*bs
)
2698 BdrvChild
*backing
= bs
->backing
;
2700 if (backing
&& backing
->bs
->encrypted
&& !backing
->bs
->valid_key
) {
2703 return (bs
->encrypted
&& !bs
->valid_key
);
2706 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2709 if (bs
->backing
&& bs
->backing
->bs
->encrypted
) {
2710 ret
= bdrv_set_key(bs
->backing
->bs
, key
);
2716 if (!bs
->encrypted
) {
2718 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2721 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2724 } else if (!bs
->valid_key
) {
2727 /* call the change callback now, we skipped it on open */
2728 blk_dev_change_media_cb(bs
->blk
, true);
2735 * Provide an encryption key for @bs.
2736 * If @key is non-null:
2737 * If @bs is not encrypted, fail.
2738 * Else if the key is invalid, fail.
2739 * Else set @bs's key to @key, replacing the existing key, if any.
2741 * If @bs is encrypted and still lacks a key, fail.
2743 * On failure, store an error object through @errp if non-null.
2745 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
2748 if (!bdrv_is_encrypted(bs
)) {
2749 error_setg(errp
, "Node '%s' is not encrypted",
2750 bdrv_get_device_or_node_name(bs
));
2751 } else if (bdrv_set_key(bs
, key
) < 0) {
2752 error_setg(errp
, QERR_INVALID_PASSWORD
);
2755 if (bdrv_key_required(bs
)) {
2756 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
2757 "'%s' (%s) is encrypted",
2758 bdrv_get_device_or_node_name(bs
),
2759 bdrv_get_encrypted_filename(bs
));
2764 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2766 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2769 static int qsort_strcmp(const void *a
, const void *b
)
2771 return strcmp(a
, b
);
2774 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2780 const char **formats
= NULL
;
2782 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2783 if (drv
->format_name
) {
2786 while (formats
&& i
&& !found
) {
2787 found
= !strcmp(formats
[--i
], drv
->format_name
);
2791 formats
= g_renew(const char *, formats
, count
+ 1);
2792 formats
[count
++] = drv
->format_name
;
2797 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
2799 for (i
= 0; i
< count
; i
++) {
2800 it(opaque
, formats
[i
]);
2806 /* This function is to find a node in the bs graph */
2807 BlockDriverState
*bdrv_find_node(const char *node_name
)
2809 BlockDriverState
*bs
;
2813 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2814 if (!strcmp(node_name
, bs
->node_name
)) {
2821 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2822 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
2824 BlockDeviceInfoList
*list
, *entry
;
2825 BlockDriverState
*bs
;
2828 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
2829 BlockDeviceInfo
*info
= bdrv_block_device_info(NULL
, bs
, errp
);
2831 qapi_free_BlockDeviceInfoList(list
);
2834 entry
= g_malloc0(sizeof(*entry
));
2835 entry
->value
= info
;
2843 BlockDriverState
*bdrv_lookup_bs(const char *device
,
2844 const char *node_name
,
2848 BlockDriverState
*bs
;
2851 blk
= blk_by_name(device
);
2856 error_setg(errp
, "Device '%s' has no medium", device
);
2864 bs
= bdrv_find_node(node_name
);
2871 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
2872 device
? device
: "",
2873 node_name
? node_name
: "");
2877 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2878 * return false. If either argument is NULL, return false. */
2879 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
2881 while (top
&& top
!= base
) {
2882 top
= backing_bs(top
);
2888 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
2891 return QTAILQ_FIRST(&graph_bdrv_states
);
2893 return QTAILQ_NEXT(bs
, node_list
);
2896 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
2897 * the monitor or attached to a BlockBackend */
2898 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2900 if (!bs
|| bs
->blk
) {
2901 bs
= blk_next_root_bs(bs
);
2907 /* Ignore all BDSs that are attached to a BlockBackend here; they have been
2908 * handled by the above block already */
2910 bs
= bdrv_next_monitor_owned(bs
);
2911 } while (bs
&& bs
->blk
);
2915 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
2917 return bs
->node_name
;
2920 /* TODO check what callers really want: bs->node_name or blk_name() */
2921 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
2923 return bs
->blk
? blk_name(bs
->blk
) : "";
2926 /* This can be used to identify nodes that might not have a device
2927 * name associated. Since node and device names live in the same
2928 * namespace, the result is unambiguous. The exception is if both are
2929 * absent, then this returns an empty (non-null) string. */
2930 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
2932 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
2935 int bdrv_get_flags(BlockDriverState
*bs
)
2937 return bs
->open_flags
;
2940 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2945 int bdrv_has_zero_init(BlockDriverState
*bs
)
2949 /* If BS is a copy on write image, it is initialized to
2950 the contents of the base image, which may not be zeroes. */
2954 if (bs
->drv
->bdrv_has_zero_init
) {
2955 return bs
->drv
->bdrv_has_zero_init(bs
);
2962 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
2964 BlockDriverInfo bdi
;
2970 if (bdrv_get_info(bs
, &bdi
) == 0) {
2971 return bdi
.unallocated_blocks_are_zero
;
2977 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
2979 BlockDriverInfo bdi
;
2981 if (bs
->backing
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
2985 if (bdrv_get_info(bs
, &bdi
) == 0) {
2986 return bdi
.can_write_zeroes_with_unmap
;
2992 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2994 if (bs
->backing
&& bs
->backing
->bs
->encrypted
)
2995 return bs
->backing_file
;
2996 else if (bs
->encrypted
)
2997 return bs
->filename
;
3002 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3003 char *filename
, int filename_size
)
3005 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3008 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3010 BlockDriver
*drv
= bs
->drv
;
3013 if (!drv
->bdrv_get_info
)
3015 memset(bdi
, 0, sizeof(*bdi
));
3016 return drv
->bdrv_get_info(bs
, bdi
);
3019 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3021 BlockDriver
*drv
= bs
->drv
;
3022 if (drv
&& drv
->bdrv_get_specific_info
) {
3023 return drv
->bdrv_get_specific_info(bs
);
3028 void bdrv_debug_event(BlockDriverState
*bs
, BlkdebugEvent event
)
3030 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3034 bs
->drv
->bdrv_debug_event(bs
, event
);
3037 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3040 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3041 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3044 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3045 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3051 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
3053 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
3054 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3057 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
3058 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
3064 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3066 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
3067 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3070 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3071 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3077 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3079 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3080 bs
= bs
->file
? bs
->file
->bs
: NULL
;
3083 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3084 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3090 int bdrv_is_snapshot(BlockDriverState
*bs
)
3092 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3095 /* backing_file can either be relative, or absolute, or a protocol. If it is
3096 * relative, it must be relative to the chain. So, passing in bs->filename
3097 * from a BDS as backing_file should not be done, as that may be relative to
3098 * the CWD rather than the chain. */
3099 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3100 const char *backing_file
)
3102 char *filename_full
= NULL
;
3103 char *backing_file_full
= NULL
;
3104 char *filename_tmp
= NULL
;
3105 int is_protocol
= 0;
3106 BlockDriverState
*curr_bs
= NULL
;
3107 BlockDriverState
*retval
= NULL
;
3109 if (!bs
|| !bs
->drv
|| !backing_file
) {
3113 filename_full
= g_malloc(PATH_MAX
);
3114 backing_file_full
= g_malloc(PATH_MAX
);
3115 filename_tmp
= g_malloc(PATH_MAX
);
3117 is_protocol
= path_has_protocol(backing_file
);
3119 for (curr_bs
= bs
; curr_bs
->backing
; curr_bs
= curr_bs
->backing
->bs
) {
3121 /* If either of the filename paths is actually a protocol, then
3122 * compare unmodified paths; otherwise make paths relative */
3123 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3124 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3125 retval
= curr_bs
->backing
->bs
;
3129 /* If not an absolute filename path, make it relative to the current
3130 * image's filename path */
3131 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3134 /* We are going to compare absolute pathnames */
3135 if (!realpath(filename_tmp
, filename_full
)) {
3139 /* We need to make sure the backing filename we are comparing against
3140 * is relative to the current image filename (or absolute) */
3141 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3142 curr_bs
->backing_file
);
3144 if (!realpath(filename_tmp
, backing_file_full
)) {
3148 if (strcmp(backing_file_full
, filename_full
) == 0) {
3149 retval
= curr_bs
->backing
->bs
;
3155 g_free(filename_full
);
3156 g_free(backing_file_full
);
3157 g_free(filename_tmp
);
3161 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3171 return 1 + bdrv_get_backing_file_depth(bs
->backing
->bs
);
3174 void bdrv_init(void)
3176 module_call_init(MODULE_INIT_BLOCK
);
3179 void bdrv_init_with_whitelist(void)
3181 use_bdrv_whitelist
= 1;
3185 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
3188 Error
*local_err
= NULL
;
3195 if (!(bs
->open_flags
& BDRV_O_INACTIVE
)) {
3198 bs
->open_flags
&= ~BDRV_O_INACTIVE
;
3200 if (bs
->drv
->bdrv_invalidate_cache
) {
3201 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
3203 bs
->open_flags
|= BDRV_O_INACTIVE
;
3204 error_propagate(errp
, local_err
);
3209 QLIST_FOREACH(child
, &bs
->children
, next
) {
3210 bdrv_invalidate_cache(child
->bs
, &local_err
);
3212 bs
->open_flags
|= BDRV_O_INACTIVE
;
3213 error_propagate(errp
, local_err
);
3218 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3220 bs
->open_flags
|= BDRV_O_INACTIVE
;
3221 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
3226 void bdrv_invalidate_cache_all(Error
**errp
)
3228 BlockDriverState
*bs
= NULL
;
3229 Error
*local_err
= NULL
;
3231 while ((bs
= bdrv_next(bs
)) != NULL
) {
3232 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3234 aio_context_acquire(aio_context
);
3235 bdrv_invalidate_cache(bs
, &local_err
);
3236 aio_context_release(aio_context
);
3238 error_propagate(errp
, local_err
);
3244 static int bdrv_inactivate_recurse(BlockDriverState
*bs
,
3250 if (!setting_flag
&& bs
->drv
->bdrv_inactivate
) {
3251 ret
= bs
->drv
->bdrv_inactivate(bs
);
3257 QLIST_FOREACH(child
, &bs
->children
, next
) {
3258 ret
= bdrv_inactivate_recurse(child
->bs
, setting_flag
);
3265 bs
->open_flags
|= BDRV_O_INACTIVE
;
3270 int bdrv_inactivate_all(void)
3272 BlockDriverState
*bs
= NULL
;
3276 while ((bs
= bdrv_next(bs
)) != NULL
) {
3277 aio_context_acquire(bdrv_get_aio_context(bs
));
3280 /* We do two passes of inactivation. The first pass calls to drivers'
3281 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
3282 * the second pass sets the BDRV_O_INACTIVE flag so that no further write
3284 for (pass
= 0; pass
< 2; pass
++) {
3286 while ((bs
= bdrv_next(bs
)) != NULL
) {
3287 ret
= bdrv_inactivate_recurse(bs
, pass
);
3296 while ((bs
= bdrv_next(bs
)) != NULL
) {
3297 aio_context_release(bdrv_get_aio_context(bs
));
3303 /**************************************************************/
3304 /* removable device support */
3307 * Return TRUE if the media is present
3309 bool bdrv_is_inserted(BlockDriverState
*bs
)
3311 BlockDriver
*drv
= bs
->drv
;
3317 if (drv
->bdrv_is_inserted
) {
3318 return drv
->bdrv_is_inserted(bs
);
3320 QLIST_FOREACH(child
, &bs
->children
, next
) {
3321 if (!bdrv_is_inserted(child
->bs
)) {
3329 * Return whether the media changed since the last call to this
3330 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3332 int bdrv_media_changed(BlockDriverState
*bs
)
3334 BlockDriver
*drv
= bs
->drv
;
3336 if (drv
&& drv
->bdrv_media_changed
) {
3337 return drv
->bdrv_media_changed(bs
);
3343 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3345 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3347 BlockDriver
*drv
= bs
->drv
;
3348 const char *device_name
;
3350 if (drv
&& drv
->bdrv_eject
) {
3351 drv
->bdrv_eject(bs
, eject_flag
);
3354 device_name
= bdrv_get_device_name(bs
);
3355 if (device_name
[0] != '\0') {
3356 qapi_event_send_device_tray_moved(device_name
,
3357 eject_flag
, &error_abort
);
3362 * Lock or unlock the media (if it is locked, the user won't be able
3363 * to eject it manually).
3365 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3367 BlockDriver
*drv
= bs
->drv
;
3369 trace_bdrv_lock_medium(bs
, locked
);
3371 if (drv
&& drv
->bdrv_lock_medium
) {
3372 drv
->bdrv_lock_medium(bs
, locked
);
3376 /* Get a reference to bs */
3377 void bdrv_ref(BlockDriverState
*bs
)
3382 /* Release a previously grabbed reference to bs.
3383 * If after releasing, reference count is zero, the BlockDriverState is
3385 void bdrv_unref(BlockDriverState
*bs
)
3390 assert(bs
->refcnt
> 0);
3391 if (--bs
->refcnt
== 0) {
3396 struct BdrvOpBlocker
{
3398 QLIST_ENTRY(BdrvOpBlocker
) list
;
3401 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
3403 BdrvOpBlocker
*blocker
;
3404 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3405 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
3406 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
3408 *errp
= error_copy(blocker
->reason
);
3409 error_prepend(errp
, "Node '%s' is busy: ",
3410 bdrv_get_device_or_node_name(bs
));
3417 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3419 BdrvOpBlocker
*blocker
;
3420 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3422 blocker
= g_new0(BdrvOpBlocker
, 1);
3423 blocker
->reason
= reason
;
3424 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
3427 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
3429 BdrvOpBlocker
*blocker
, *next
;
3430 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
3431 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
3432 if (blocker
->reason
== reason
) {
3433 QLIST_REMOVE(blocker
, list
);
3439 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
3442 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3443 bdrv_op_block(bs
, i
, reason
);
3447 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
3450 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3451 bdrv_op_unblock(bs
, i
, reason
);
3455 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
3459 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
3460 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
3467 void bdrv_img_create(const char *filename
, const char *fmt
,
3468 const char *base_filename
, const char *base_fmt
,
3469 char *options
, uint64_t img_size
, int flags
,
3470 Error
**errp
, bool quiet
)
3472 QemuOptsList
*create_opts
= NULL
;
3473 QemuOpts
*opts
= NULL
;
3474 const char *backing_fmt
, *backing_file
;
3476 BlockDriver
*drv
, *proto_drv
;
3477 Error
*local_err
= NULL
;
3480 /* Find driver and parse its options */
3481 drv
= bdrv_find_format(fmt
);
3483 error_setg(errp
, "Unknown file format '%s'", fmt
);
3487 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
3492 if (!drv
->create_opts
) {
3493 error_setg(errp
, "Format driver '%s' does not support image creation",
3498 if (!proto_drv
->create_opts
) {
3499 error_setg(errp
, "Protocol driver '%s' does not support image creation",
3500 proto_drv
->format_name
);
3504 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
3505 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
3507 /* Create parameter list with default values */
3508 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
3509 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
3511 /* Parse -o options */
3513 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
3515 error_report_err(local_err
);
3517 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
3522 if (base_filename
) {
3523 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
3525 error_setg(errp
, "Backing file not supported for file format '%s'",
3532 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
3534 error_setg(errp
, "Backing file format not supported for file "
3535 "format '%s'", fmt
);
3540 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
3542 if (!strcmp(filename
, backing_file
)) {
3543 error_setg(errp
, "Error: Trying to create an image with the "
3544 "same filename as the backing file");
3549 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
3551 // The size for the image must always be specified, with one exception:
3552 // If we are using a backing file, we can obtain the size from there
3553 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
3556 BlockDriverState
*bs
;
3557 char *full_backing
= g_new0(char, PATH_MAX
);
3560 QDict
*backing_options
= NULL
;
3562 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
3563 full_backing
, PATH_MAX
,
3566 g_free(full_backing
);
3570 /* backing files always opened read-only */
3572 back_flags
&= ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
3575 backing_options
= qdict_new();
3576 qdict_put(backing_options
, "driver",
3577 qstring_from_str(backing_fmt
));
3581 ret
= bdrv_open(&bs
, full_backing
, NULL
, backing_options
,
3582 back_flags
, &local_err
);
3583 g_free(full_backing
);
3587 size
= bdrv_getlength(bs
);
3589 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
3595 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
3599 error_setg(errp
, "Image creation needs a size parameter");
3605 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3606 qemu_opts_print(opts
, " ");
3610 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
3612 if (ret
== -EFBIG
) {
3613 /* This is generally a better message than whatever the driver would
3614 * deliver (especially because of the cluster_size_hint), since that
3615 * is most probably not much different from "image too large". */
3616 const char *cluster_size_hint
= "";
3617 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
3618 cluster_size_hint
= " (try using a larger cluster size)";
3620 error_setg(errp
, "The image size is too large for file format '%s'"
3621 "%s", fmt
, cluster_size_hint
);
3622 error_free(local_err
);
3627 qemu_opts_del(opts
);
3628 qemu_opts_free(create_opts
);
3630 error_propagate(errp
, local_err
);
3634 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
3636 return bs
->aio_context
;
3639 void bdrv_detach_aio_context(BlockDriverState
*bs
)
3641 BdrvAioNotifier
*baf
;
3647 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
3648 baf
->detach_aio_context(baf
->opaque
);
3651 if (bs
->drv
->bdrv_detach_aio_context
) {
3652 bs
->drv
->bdrv_detach_aio_context(bs
);
3655 bdrv_detach_aio_context(bs
->file
->bs
);
3658 bdrv_detach_aio_context(bs
->backing
->bs
);
3661 bs
->aio_context
= NULL
;
3664 void bdrv_attach_aio_context(BlockDriverState
*bs
,
3665 AioContext
*new_context
)
3667 BdrvAioNotifier
*ban
;
3673 bs
->aio_context
= new_context
;
3676 bdrv_attach_aio_context(bs
->backing
->bs
, new_context
);
3679 bdrv_attach_aio_context(bs
->file
->bs
, new_context
);
3681 if (bs
->drv
->bdrv_attach_aio_context
) {
3682 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
3685 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
3686 ban
->attached_aio_context(new_context
, ban
->opaque
);
3690 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
3692 bdrv_drain(bs
); /* ensure there are no in-flight requests */
3694 bdrv_detach_aio_context(bs
);
3696 /* This function executes in the old AioContext so acquire the new one in
3697 * case it runs in a different thread.
3699 aio_context_acquire(new_context
);
3700 bdrv_attach_aio_context(bs
, new_context
);
3701 aio_context_release(new_context
);
3704 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
3705 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
3706 void (*detach_aio_context
)(void *opaque
), void *opaque
)
3708 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
3709 *ban
= (BdrvAioNotifier
){
3710 .attached_aio_context
= attached_aio_context
,
3711 .detach_aio_context
= detach_aio_context
,
3715 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
3718 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
3719 void (*attached_aio_context
)(AioContext
*,
3721 void (*detach_aio_context
)(void *),
3724 BdrvAioNotifier
*ban
, *ban_next
;
3726 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
3727 if (ban
->attached_aio_context
== attached_aio_context
&&
3728 ban
->detach_aio_context
== detach_aio_context
&&
3729 ban
->opaque
== opaque
)
3731 QLIST_REMOVE(ban
, list
);
3741 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
3742 BlockDriverAmendStatusCB
*status_cb
, void *cb_opaque
)
3744 if (!bs
->drv
->bdrv_amend_options
) {
3747 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
, cb_opaque
);
3750 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3751 * of block filter and by bdrv_is_first_non_filter.
3752 * It is used to test if the given bs is the candidate or recurse more in the
3755 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
3756 BlockDriverState
*candidate
)
3758 /* return false if basic checks fails */
3759 if (!bs
|| !bs
->drv
) {
3763 /* the code reached a non block filter driver -> check if the bs is
3764 * the same as the candidate. It's the recursion termination condition.
3766 if (!bs
->drv
->is_filter
) {
3767 return bs
== candidate
;
3769 /* Down this path the driver is a block filter driver */
3771 /* If the block filter recursion method is defined use it to recurse down
3774 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
3775 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
3778 /* the driver is a block filter but don't allow to recurse -> return false
3783 /* This function checks if the candidate is the first non filter bs down it's
3784 * bs chain. Since we don't have pointers to parents it explore all bs chains
3785 * from the top. Some filters can choose not to pass down the recursion.
3787 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
3789 BlockDriverState
*bs
= NULL
;
3791 /* walk down the bs forest recursively */
3792 while ((bs
= bdrv_next(bs
)) != NULL
) {
3795 /* try to recurse in this top level bs */
3796 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
3798 /* candidate is the first non filter */
3807 BlockDriverState
*check_to_replace_node(BlockDriverState
*parent_bs
,
3808 const char *node_name
, Error
**errp
)
3810 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
3811 AioContext
*aio_context
;
3813 if (!to_replace_bs
) {
3814 error_setg(errp
, "Node name '%s' not found", node_name
);
3818 aio_context
= bdrv_get_aio_context(to_replace_bs
);
3819 aio_context_acquire(aio_context
);
3821 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
3822 to_replace_bs
= NULL
;
3826 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3827 * most non filter in order to prevent data corruption.
3828 * Another benefit is that this tests exclude backing files which are
3829 * blocked by the backing blockers.
3831 if (!bdrv_recurse_is_first_non_filter(parent_bs
, to_replace_bs
)) {
3832 error_setg(errp
, "Only top most non filter can be replaced");
3833 to_replace_bs
= NULL
;
3838 aio_context_release(aio_context
);
3839 return to_replace_bs
;
3842 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
3844 const QDictEntry
*entry
;
3847 bool found_any
= false;
3850 for (entry
= qdict_first(bs
->options
); entry
;
3851 entry
= qdict_next(bs
->options
, entry
))
3853 /* Exclude options for children */
3854 QLIST_FOREACH(child
, &bs
->children
, next
) {
3855 if (strstart(qdict_entry_key(entry
), child
->name
, &p
)
3856 && (!*p
|| *p
== '.'))
3865 /* And exclude all non-driver-specific options */
3866 for (desc
= bdrv_runtime_opts
.desc
; desc
->name
; desc
++) {
3867 if (!strcmp(qdict_entry_key(entry
), desc
->name
)) {
3875 qobject_incref(qdict_entry_value(entry
));
3876 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
3883 /* Updates the following BDS fields:
3884 * - exact_filename: A filename which may be used for opening a block device
3885 * which (mostly) equals the given BDS (even without any
3886 * other options; so reading and writing must return the same
3887 * results, but caching etc. may be different)
3888 * - full_open_options: Options which, when given when opening a block device
3889 * (without a filename), result in a BDS (mostly)
3890 * equalling the given one
3891 * - filename: If exact_filename is set, it is copied here. Otherwise,
3892 * full_open_options is converted to a JSON object, prefixed with
3893 * "json:" (for use through the JSON pseudo protocol) and put here.
3895 void bdrv_refresh_filename(BlockDriverState
*bs
)
3897 BlockDriver
*drv
= bs
->drv
;
3904 /* This BDS's file name will most probably depend on its file's name, so
3905 * refresh that first */
3907 bdrv_refresh_filename(bs
->file
->bs
);
3910 if (drv
->bdrv_refresh_filename
) {
3911 /* Obsolete information is of no use here, so drop the old file name
3912 * information before refreshing it */
3913 bs
->exact_filename
[0] = '\0';
3914 if (bs
->full_open_options
) {
3915 QDECREF(bs
->full_open_options
);
3916 bs
->full_open_options
= NULL
;
3920 append_open_options(opts
, bs
);
3921 drv
->bdrv_refresh_filename(bs
, opts
);
3923 } else if (bs
->file
) {
3924 /* Try to reconstruct valid information from the underlying file */
3925 bool has_open_options
;
3927 bs
->exact_filename
[0] = '\0';
3928 if (bs
->full_open_options
) {
3929 QDECREF(bs
->full_open_options
);
3930 bs
->full_open_options
= NULL
;
3934 has_open_options
= append_open_options(opts
, bs
);
3936 /* If no specific options have been given for this BDS, the filename of
3937 * the underlying file should suffice for this one as well */
3938 if (bs
->file
->bs
->exact_filename
[0] && !has_open_options
) {
3939 strcpy(bs
->exact_filename
, bs
->file
->bs
->exact_filename
);
3941 /* Reconstructing the full options QDict is simple for most format block
3942 * drivers, as long as the full options are known for the underlying
3943 * file BDS. The full options QDict of that file BDS should somehow
3944 * contain a representation of the filename, therefore the following
3945 * suffices without querying the (exact_)filename of this BDS. */
3946 if (bs
->file
->bs
->full_open_options
) {
3947 qdict_put_obj(opts
, "driver",
3948 QOBJECT(qstring_from_str(drv
->format_name
)));
3949 QINCREF(bs
->file
->bs
->full_open_options
);
3950 qdict_put_obj(opts
, "file",
3951 QOBJECT(bs
->file
->bs
->full_open_options
));
3953 bs
->full_open_options
= opts
;
3957 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
3958 /* There is no underlying file BDS (at least referenced by BDS.file),
3959 * so the full options QDict should be equal to the options given
3960 * specifically for this block device when it was opened (plus the
3961 * driver specification).
3962 * Because those options don't change, there is no need to update
3963 * full_open_options when it's already set. */
3966 append_open_options(opts
, bs
);
3967 qdict_put_obj(opts
, "driver",
3968 QOBJECT(qstring_from_str(drv
->format_name
)));
3970 if (bs
->exact_filename
[0]) {
3971 /* This may not work for all block protocol drivers (some may
3972 * require this filename to be parsed), but we have to find some
3973 * default solution here, so just include it. If some block driver
3974 * does not support pure options without any filename at all or
3975 * needs some special format of the options QDict, it needs to
3976 * implement the driver-specific bdrv_refresh_filename() function.
3978 qdict_put_obj(opts
, "filename",
3979 QOBJECT(qstring_from_str(bs
->exact_filename
)));
3982 bs
->full_open_options
= opts
;
3985 if (bs
->exact_filename
[0]) {
3986 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
3987 } else if (bs
->full_open_options
) {
3988 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
3989 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
3990 qstring_get_str(json
));
3996 * Hot add/remove a BDS's child. So the user can take a child offline when
3997 * it is broken and take a new child online
3999 void bdrv_add_child(BlockDriverState
*parent_bs
, BlockDriverState
*child_bs
,
4003 if (!parent_bs
->drv
|| !parent_bs
->drv
->bdrv_add_child
) {
4004 error_setg(errp
, "The node %s does not support adding a child",
4005 bdrv_get_device_or_node_name(parent_bs
));
4009 if (!QLIST_EMPTY(&child_bs
->parents
)) {
4010 error_setg(errp
, "The node %s already has a parent",
4011 child_bs
->node_name
);
4015 parent_bs
->drv
->bdrv_add_child(parent_bs
, child_bs
, errp
);
4018 void bdrv_del_child(BlockDriverState
*parent_bs
, BdrvChild
*child
, Error
**errp
)
4022 if (!parent_bs
->drv
|| !parent_bs
->drv
->bdrv_del_child
) {
4023 error_setg(errp
, "The node %s does not support removing a child",
4024 bdrv_get_device_or_node_name(parent_bs
));
4028 QLIST_FOREACH(tmp
, &parent_bs
->children
, next
) {
4035 error_setg(errp
, "The node %s does not have a child named %s",
4036 bdrv_get_device_or_node_name(parent_bs
),
4037 bdrv_get_device_or_node_name(child
->bs
));
4041 parent_bs
->drv
->bdrv_del_child(parent_bs
, child
, errp
);