2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "qemu/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
44 #include <sys/types.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
65 struct BdrvDirtyBitmap {
66 HBitmap *bitmap; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
68 char *name; /* Optional non-empty unique ID */
69 int64_t size; /* Size of the bitmap (Number of sectors) */
70 bool disabled; /* Bitmap is read-only */
71 QLIST_ENTRY(BdrvDirtyBitmap) list;
74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
76 struct BdrvStates bdrv_states = QTAILQ_HEAD_INITIALIZER(bdrv_states);
78 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
79 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
81 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
82 QLIST_HEAD_INITIALIZER(bdrv_drivers);
84 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
85 const char *reference, QDict *options, int flags,
86 BlockDriverState *parent,
87 const BdrvChildRole *child_role, Error **errp);
89 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
90 /* If non-zero, use only whitelisted block drivers */
91 static int use_bdrv_whitelist;
94 static int is_windows_drive_prefix(const char *filename)
96 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
97 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
101 int is_windows_drive(const char *filename)
103 if (is_windows_drive_prefix(filename) &&
106 if (strstart(filename, "\\\\.\\", NULL) ||
107 strstart(filename, "//./", NULL))
113 size_t bdrv_opt_mem_align(BlockDriverState *bs)
115 if (!bs || !bs->drv) {
116 /* page size or 4k (hdd sector size) should be on the safe side */
117 return MAX(4096, getpagesize());
120 return bs->bl.opt_mem_alignment;
123 size_t bdrv_min_mem_align(BlockDriverState *bs)
125 if (!bs || !bs->drv) {
126 /* page size or 4k (hdd sector size) should be on the safe side */
127 return MAX(4096, getpagesize());
130 return bs->bl.min_mem_alignment;
133 /* check if the path starts with "<protocol>:" */
134 int path_has_protocol(const char *path)
139 if (is_windows_drive(path) ||
140 is_windows_drive_prefix(path)) {
143 p = path + strcspn(path, ":/\\");
145 p = path + strcspn(path, ":/");
151 int path_is_absolute(const char *path)
154 /* specific case for names like: "\\.\d:" */
155 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
158 return (*path == '/' || *path == '\\');
160 return (*path == '/');
164 /* if filename is absolute, just copy it to dest. Otherwise, build a
165 path to it by considering it is relative to base_path. URL are
167 void path_combine(char *dest, int dest_size,
168 const char *base_path,
169 const char *filename)
176 if (path_is_absolute(filename)) {
177 pstrcpy(dest, dest_size, filename);
179 p = strchr(base_path, ':');
184 p1 = strrchr(base_path, '/');
188 p2 = strrchr(base_path, '\\');
200 if (len > dest_size - 1)
202 memcpy(dest, base_path, len);
204 pstrcat(dest, dest_size, filename);
208 void bdrv_get_full_backing_filename_from_filename(const char *backed,
210 char *dest, size_t sz,
213 if (backing[0] == '\0' || path_has_protocol(backing) ||
214 path_is_absolute(backing))
216 pstrcpy(dest, sz, backing);
217 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
218 error_setg(errp, "Cannot use relative backing file names for '%s'",
221 path_combine(dest, sz, backed, backing);
225 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
228 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
230 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
234 void bdrv_register(BlockDriver *bdrv)
236 bdrv_setup_io_funcs(bdrv);
238 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
241 BlockDriverState *bdrv_new_root(void)
243 BlockDriverState *bs = bdrv_new();
245 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
249 BlockDriverState *bdrv_new(void)
251 BlockDriverState *bs;
254 bs = g_new0(BlockDriverState, 1);
255 QLIST_INIT(&bs->dirty_bitmaps);
256 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
257 QLIST_INIT(&bs->op_blockers[i]);
259 notifier_list_init(&bs->close_notifiers);
260 notifier_with_return_list_init(&bs->before_write_notifiers);
261 qemu_co_queue_init(&bs->throttled_reqs[0]);
262 qemu_co_queue_init(&bs->throttled_reqs[1]);
264 bs->aio_context = qemu_get_aio_context();
269 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
271 notifier_list_add(&bs->close_notifiers, notify);
274 BlockDriver *bdrv_find_format(const char *format_name)
277 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
278 if (!strcmp(drv1->format_name, format_name)) {
285 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
287 static const char *whitelist_rw[] = {
288 CONFIG_BDRV_RW_WHITELIST
290 static const char *whitelist_ro[] = {
291 CONFIG_BDRV_RO_WHITELIST
295 if (!whitelist_rw[0] && !whitelist_ro[0]) {
296 return 1; /* no whitelist, anything goes */
299 for (p = whitelist_rw; *p; p++) {
300 if (!strcmp(drv->format_name, *p)) {
305 for (p = whitelist_ro; *p; p++) {
306 if (!strcmp(drv->format_name, *p)) {
314 typedef struct CreateCo {
322 static void coroutine_fn bdrv_create_co_entry(void *opaque)
324 Error *local_err = NULL;
327 CreateCo *cco = opaque;
330 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
332 error_propagate(&cco->err, local_err);
337 int bdrv_create(BlockDriver *drv, const char* filename,
338 QemuOpts *opts, Error **errp)
345 .filename = g_strdup(filename),
351 if (!drv->bdrv_create) {
352 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
357 if (qemu_in_coroutine()) {
358 /* Fast-path if already in coroutine context */
359 bdrv_create_co_entry(&cco);
361 co = qemu_coroutine_create(bdrv_create_co_entry);
362 qemu_coroutine_enter(co, &cco);
363 while (cco.ret == NOT_DONE) {
364 aio_poll(qemu_get_aio_context(), true);
371 error_propagate(errp, cco.err);
373 error_setg_errno(errp, -ret, "Could not create image");
378 g_free(cco.filename);
382 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
385 Error *local_err = NULL;
388 drv = bdrv_find_protocol(filename, true, errp);
393 ret = bdrv_create(drv, filename, opts, &local_err);
395 error_propagate(errp, local_err);
401 * Try to get @bs's logical and physical block size.
402 * On success, store them in @bsz struct and return 0.
403 * On failure return -errno.
404 * @bs must not be empty.
406 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
408 BlockDriver *drv = bs->drv;
410 if (drv && drv->bdrv_probe_blocksizes) {
411 return drv->bdrv_probe_blocksizes(bs, bsz);
418 * Try to get @bs's geometry (cyls, heads, sectors).
419 * On success, store them in @geo struct and return 0.
420 * On failure return -errno.
421 * @bs must not be empty.
423 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
425 BlockDriver *drv = bs->drv;
427 if (drv && drv->bdrv_probe_geometry) {
428 return drv->bdrv_probe_geometry(bs, geo);
435 * Create a uniquely-named empty temporary file.
436 * Return 0 upon success, otherwise a negative errno value.
438 int get_tmp_filename(char *filename, int size)
441 char temp_dir[MAX_PATH];
442 /* GetTempFileName requires that its output buffer (4th param)
443 have length MAX_PATH or greater. */
444 assert(size >= MAX_PATH);
445 return (GetTempPath(MAX_PATH, temp_dir)
446 && GetTempFileName(temp_dir, "qem", 0, filename)
447 ? 0 : -GetLastError());
451 tmpdir = getenv("TMPDIR");
455 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
458 fd = mkstemp(filename);
462 if (close(fd) != 0) {
471 * Detect host devices. By convention, /dev/cdrom[N] is always
472 * recognized as a host CDROM.
474 static BlockDriver *find_hdev_driver(const char *filename)
476 int score_max = 0, score;
477 BlockDriver *drv = NULL, *d;
479 QLIST_FOREACH(d, &bdrv_drivers, list) {
480 if (d->bdrv_probe_device) {
481 score = d->bdrv_probe_device(filename);
482 if (score > score_max) {
492 BlockDriver *bdrv_find_protocol(const char *filename,
493 bool allow_protocol_prefix,
501 /* TODO Drivers without bdrv_file_open must be specified explicitly */
504 * XXX(hch): we really should not let host device detection
505 * override an explicit protocol specification, but moving this
506 * later breaks access to device names with colons in them.
507 * Thanks to the brain-dead persistent naming schemes on udev-
508 * based Linux systems those actually are quite common.
510 drv1 = find_hdev_driver(filename);
515 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
519 p = strchr(filename, ':');
522 if (len > sizeof(protocol) - 1)
523 len = sizeof(protocol) - 1;
524 memcpy(protocol, filename, len);
525 protocol[len] = '\0';
526 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
527 if (drv1->protocol_name &&
528 !strcmp(drv1->protocol_name, protocol)) {
533 error_setg(errp, "Unknown protocol '%s'", protocol);
538 * Guess image format by probing its contents.
539 * This is not a good idea when your image is raw (CVE-2008-2004), but
540 * we do it anyway for backward compatibility.
542 * @buf contains the image's first @buf_size bytes.
543 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
544 * but can be smaller if the image file is smaller)
545 * @filename is its filename.
547 * For all block drivers, call the bdrv_probe() method to get its
549 * Return the first block driver with the highest probing score.
551 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
552 const char *filename)
554 int score_max = 0, score;
555 BlockDriver *drv = NULL, *d;
557 QLIST_FOREACH(d, &bdrv_drivers, list) {
559 score = d->bdrv_probe(buf, buf_size, filename);
560 if (score > score_max) {
570 static int find_image_format(BlockDriverState *bs, const char *filename,
571 BlockDriver **pdrv, Error **errp)
574 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
577 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
578 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
583 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
585 error_setg_errno(errp, -ret, "Could not read image for determining its "
591 drv = bdrv_probe_all(buf, ret, filename);
593 error_setg(errp, "Could not determine image format: No compatible "
602 * Set the current 'total_sectors' value
603 * Return 0 on success, -errno on error.
605 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
607 BlockDriver *drv = bs->drv;
609 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
613 /* query actual device if possible, otherwise just trust the hint */
614 if (drv->bdrv_getlength) {
615 int64_t length = drv->bdrv_getlength(bs);
619 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
622 bs->total_sectors = hint;
627 * Set open flags for a given discard mode
629 * Return 0 on success, -1 if the discard mode was invalid.
631 int bdrv_parse_discard_flags(const char *mode, int *flags)
633 *flags &= ~BDRV_O_UNMAP;
635 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
637 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
638 *flags |= BDRV_O_UNMAP;
647 * Set open flags for a given cache mode
649 * Return 0 on success, -1 if the cache mode was invalid.
651 int bdrv_parse_cache_flags(const char *mode, int *flags)
653 *flags &= ~BDRV_O_CACHE_MASK;
655 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
656 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
657 } else if (!strcmp(mode, "directsync")) {
658 *flags |= BDRV_O_NOCACHE;
659 } else if (!strcmp(mode, "writeback")) {
660 *flags |= BDRV_O_CACHE_WB;
661 } else if (!strcmp(mode, "unsafe")) {
662 *flags |= BDRV_O_CACHE_WB;
663 *flags |= BDRV_O_NO_FLUSH;
664 } else if (!strcmp(mode, "writethrough")) {
665 /* this is the default */
674 * Returns the flags that a temporary snapshot should get, based on the
675 * originally requested flags (the originally requested image will have flags
676 * like a backing file)
678 static int bdrv_temp_snapshot_flags(int flags)
680 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
684 * Returns the flags that bs->file should get if a protocol driver is expected,
685 * based on the given flags for the parent BDS
687 static int bdrv_inherited_flags(int flags)
689 /* Enable protocol handling, disable format probing for bs->file */
690 flags |= BDRV_O_PROTOCOL;
692 /* Our block drivers take care to send flushes and respect unmap policy,
693 * so we can enable both unconditionally on lower layers. */
694 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
696 /* Clear flags that only apply to the top layer */
697 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
702 const BdrvChildRole child_file = {
703 .inherit_flags = bdrv_inherited_flags,
707 * Returns the flags that bs->file should get if the use of formats (and not
708 * only protocols) is permitted for it, based on the given flags for the parent
711 static int bdrv_inherited_fmt_flags(int parent_flags)
713 int flags = child_file.inherit_flags(parent_flags);
714 return flags & ~BDRV_O_PROTOCOL;
717 const BdrvChildRole child_format = {
718 .inherit_flags = bdrv_inherited_fmt_flags,
722 * Returns the flags that bs->backing should get, based on the given flags
725 static int bdrv_backing_flags(int flags)
727 /* backing files always opened read-only */
728 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
730 /* snapshot=on is handled on the top layer */
731 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
736 static const BdrvChildRole child_backing = {
737 .inherit_flags = bdrv_backing_flags,
740 static int bdrv_open_flags(BlockDriverState *bs, int flags)
742 int open_flags = flags | BDRV_O_CACHE_WB;
745 * Clear flags that are internal to the block layer before opening the
748 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
751 * Snapshots should be writable.
753 if (flags & BDRV_O_TEMPORARY) {
754 open_flags |= BDRV_O_RDWR;
760 static void bdrv_assign_node_name(BlockDriverState *bs,
761 const char *node_name,
764 char *gen_node_name = NULL;
767 node_name = gen_node_name = id_generate(ID_BLOCK);
768 } else if (!id_wellformed(node_name)) {
770 * Check for empty string or invalid characters, but not if it is
771 * generated (generated names use characters not available to the user)
773 error_setg(errp, "Invalid node name");
777 /* takes care of avoiding namespaces collisions */
778 if (blk_by_name(node_name)) {
779 error_setg(errp, "node-name=%s is conflicting with a device id",
784 /* takes care of avoiding duplicates node names */
785 if (bdrv_find_node(node_name)) {
786 error_setg(errp, "Duplicate node name");
790 /* copy node name into the bs and insert it into the graph list */
791 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
792 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
794 g_free(gen_node_name);
797 static QemuOptsList bdrv_runtime_opts = {
798 .name = "bdrv_common",
799 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
803 .type = QEMU_OPT_STRING,
804 .help = "Node name of the block device node",
806 { /* end of list */ }
811 * Common part for opening disk images and files
813 * Removes all processed options from *options.
815 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
816 QDict *options, int flags, BlockDriver *drv, Error **errp)
819 const char *filename;
820 const char *node_name = NULL;
822 Error *local_err = NULL;
825 assert(bs->file == NULL);
826 assert(options != NULL && bs->options != options);
829 filename = file->bs->filename;
831 filename = qdict_get_try_str(options, "filename");
834 if (drv->bdrv_needs_filename && !filename) {
835 error_setg(errp, "The '%s' block driver requires a file name",
840 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
842 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
843 qemu_opts_absorb_qdict(opts, options, &local_err);
845 error_propagate(errp, local_err);
850 node_name = qemu_opt_get(opts, "node-name");
851 bdrv_assign_node_name(bs, node_name, &local_err);
853 error_propagate(errp, local_err);
858 bs->request_alignment = 512;
859 bs->zero_beyond_eof = true;
860 open_flags = bdrv_open_flags(bs, flags);
861 bs->read_only = !(open_flags & BDRV_O_RDWR);
863 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
865 !bs->read_only && bdrv_is_whitelisted(drv, true)
866 ? "Driver '%s' can only be used for read-only devices"
867 : "Driver '%s' is not whitelisted",
873 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
874 if (flags & BDRV_O_COPY_ON_READ) {
875 if (!bs->read_only) {
876 bdrv_enable_copy_on_read(bs);
878 error_setg(errp, "Can't use copy-on-read on read-only device");
884 if (filename != NULL) {
885 pstrcpy(bs->filename, sizeof(bs->filename), filename);
887 bs->filename[0] = '\0';
889 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
892 bs->opaque = g_malloc0(drv->instance_size);
894 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
896 /* Open the image, either directly or using a protocol */
897 if (drv->bdrv_file_open) {
898 assert(file == NULL);
899 assert(!drv->bdrv_needs_filename || filename != NULL);
900 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
903 error_setg(errp, "Can't use '%s' as a block driver for the "
904 "protocol level", drv->format_name);
909 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
914 error_propagate(errp, local_err);
915 } else if (bs->filename[0]) {
916 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
918 error_setg_errno(errp, -ret, "Could not open image");
924 error_report("Encrypted images are deprecated");
925 error_printf("Support for them will be removed in a future release.\n"
926 "You can use 'qemu-img convert' to convert your image"
927 " to an unencrypted one.\n");
930 ret = refresh_total_sectors(bs, bs->total_sectors);
932 error_setg_errno(errp, -ret, "Could not refresh total sector count");
936 bdrv_refresh_limits(bs, &local_err);
938 error_propagate(errp, local_err);
943 assert(bdrv_opt_mem_align(bs) != 0);
944 assert(bdrv_min_mem_align(bs) != 0);
945 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
960 static QDict *parse_json_filename(const char *filename, Error **errp)
962 QObject *options_obj;
966 ret = strstart(filename, "json:", &filename);
969 options_obj = qobject_from_json(filename);
971 error_setg(errp, "Could not parse the JSON options");
975 if (qobject_type(options_obj) != QTYPE_QDICT) {
976 qobject_decref(options_obj);
977 error_setg(errp, "Invalid JSON object given");
981 options = qobject_to_qdict(options_obj);
982 qdict_flatten(options);
988 * Fills in default options for opening images and converts the legacy
989 * filename/flags pair to option QDict entries.
990 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
991 * block driver has been specified explicitly.
993 static int bdrv_fill_options(QDict **options, const char **pfilename,
994 int *flags, Error **errp)
996 const char *filename = *pfilename;
998 bool protocol = *flags & BDRV_O_PROTOCOL;
999 bool parse_filename = false;
1000 BlockDriver *drv = NULL;
1001 Error *local_err = NULL;
1003 /* Parse json: pseudo-protocol */
1004 if (filename && g_str_has_prefix(filename, "json:")) {
1005 QDict *json_options = parse_json_filename(filename, &local_err);
1007 error_propagate(errp, local_err);
1011 /* Options given in the filename have lower priority than options
1012 * specified directly */
1013 qdict_join(*options, json_options, false);
1014 QDECREF(json_options);
1015 *pfilename = filename = NULL;
1018 drvname = qdict_get_try_str(*options, "driver");
1020 drv = bdrv_find_format(drvname);
1022 error_setg(errp, "Unknown driver '%s'", drvname);
1025 /* If the user has explicitly specified the driver, this choice should
1026 * override the BDRV_O_PROTOCOL flag */
1027 protocol = drv->bdrv_file_open;
1031 *flags |= BDRV_O_PROTOCOL;
1033 *flags &= ~BDRV_O_PROTOCOL;
1036 /* Fetch the file name from the options QDict if necessary */
1037 if (protocol && filename) {
1038 if (!qdict_haskey(*options, "filename")) {
1039 qdict_put(*options, "filename", qstring_from_str(filename));
1040 parse_filename = true;
1042 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1048 /* Find the right block driver */
1049 filename = qdict_get_try_str(*options, "filename");
1051 if (!drvname && protocol) {
1053 drv = bdrv_find_protocol(filename, parse_filename, errp);
1058 drvname = drv->format_name;
1059 qdict_put(*options, "driver", qstring_from_str(drvname));
1061 error_setg(errp, "Must specify either driver or file");
1066 assert(drv || !protocol);
1068 /* Driver-specific filename parsing */
1069 if (drv && drv->bdrv_parse_filename && parse_filename) {
1070 drv->bdrv_parse_filename(filename, *options, &local_err);
1072 error_propagate(errp, local_err);
1076 if (!drv->bdrv_needs_filename) {
1077 qdict_del(*options, "filename");
1081 if (runstate_check(RUN_STATE_INMIGRATE)) {
1082 *flags |= BDRV_O_INCOMING;
1088 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1089 BlockDriverState *child_bs,
1090 const BdrvChildRole *child_role)
1092 BdrvChild *child = g_new(BdrvChild, 1);
1093 *child = (BdrvChild) {
1098 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1099 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1104 static void bdrv_detach_child(BdrvChild *child)
1106 QLIST_REMOVE(child, next);
1107 QLIST_REMOVE(child, next_parent);
1111 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1113 BlockDriverState *child_bs;
1115 if (child == NULL) {
1119 if (child->bs->inherits_from == parent) {
1120 child->bs->inherits_from = NULL;
1123 child_bs = child->bs;
1124 bdrv_detach_child(child);
1125 bdrv_unref(child_bs);
1129 * Sets the backing file link of a BDS. A new reference is created; callers
1130 * which don't need their own reference any more must call bdrv_unref().
1132 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1135 bdrv_ref(backing_hd);
1139 assert(bs->backing_blocker);
1140 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1141 bdrv_unref_child(bs, bs->backing);
1142 } else if (backing_hd) {
1143 error_setg(&bs->backing_blocker,
1144 "node is used as backing hd of '%s'",
1145 bdrv_get_device_or_node_name(bs));
1149 error_free(bs->backing_blocker);
1150 bs->backing_blocker = NULL;
1154 bs->backing = bdrv_attach_child(bs, backing_hd, &child_backing);
1155 bs->open_flags &= ~BDRV_O_NO_BACKING;
1156 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1157 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1158 backing_hd->drv ? backing_hd->drv->format_name : "");
1160 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1161 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1162 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1163 bs->backing_blocker);
1165 bdrv_refresh_limits(bs, NULL);
1169 * Opens the backing file for a BlockDriverState if not yet open
1171 * options is a QDict of options to pass to the block drivers, or NULL for an
1172 * empty set of options. The reference to the QDict is transferred to this
1173 * function (even on failure), so if the caller intends to reuse the dictionary,
1174 * it needs to use QINCREF() before calling bdrv_file_open.
1176 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1178 char *backing_filename = g_malloc0(PATH_MAX);
1180 BlockDriverState *backing_hd;
1181 Error *local_err = NULL;
1183 if (bs->backing != NULL) {
1188 /* NULL means an empty set of options */
1189 if (options == NULL) {
1190 options = qdict_new();
1193 bs->open_flags &= ~BDRV_O_NO_BACKING;
1194 if (qdict_haskey(options, "file.filename")) {
1195 backing_filename[0] = '\0';
1196 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1200 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1204 error_propagate(errp, local_err);
1210 if (!bs->drv || !bs->drv->supports_backing) {
1212 error_setg(errp, "Driver doesn't support backing files");
1217 backing_hd = bdrv_new();
1219 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1220 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1223 assert(bs->backing == NULL);
1224 ret = bdrv_open_inherit(&backing_hd,
1225 *backing_filename ? backing_filename : NULL,
1226 NULL, options, 0, bs, &child_backing, &local_err);
1228 bdrv_unref(backing_hd);
1230 bs->open_flags |= BDRV_O_NO_BACKING;
1231 error_setg(errp, "Could not open backing file: %s",
1232 error_get_pretty(local_err));
1233 error_free(local_err);
1237 /* Hook up the backing file link; drop our reference, bs owns the
1238 * backing_hd reference now */
1239 bdrv_set_backing_hd(bs, backing_hd);
1240 bdrv_unref(backing_hd);
1243 g_free(backing_filename);
1248 * Opens a disk image whose options are given as BlockdevRef in another block
1251 * If allow_none is true, no image will be opened if filename is false and no
1252 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1254 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1255 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1256 * itself, all options starting with "${bdref_key}." are considered part of the
1259 * The BlockdevRef will be removed from the options QDict.
1261 BdrvChild *bdrv_open_child(const char *filename,
1262 QDict *options, const char *bdref_key,
1263 BlockDriverState* parent,
1264 const BdrvChildRole *child_role,
1265 bool allow_none, Error **errp)
1267 BdrvChild *c = NULL;
1268 BlockDriverState *bs;
1269 QDict *image_options;
1271 char *bdref_key_dot;
1272 const char *reference;
1274 assert(child_role != NULL);
1276 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1277 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1278 g_free(bdref_key_dot);
1280 reference = qdict_get_try_str(options, bdref_key);
1281 if (!filename && !reference && !qdict_size(image_options)) {
1283 error_setg(errp, "A block device must be specified for \"%s\"",
1286 QDECREF(image_options);
1291 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1292 parent, child_role, errp);
1297 c = bdrv_attach_child(parent, bs, child_role);
1300 qdict_del(options, bdref_key);
1304 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1306 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1307 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1309 QemuOpts *opts = NULL;
1310 QDict *snapshot_options;
1311 BlockDriverState *bs_snapshot;
1312 Error *local_err = NULL;
1315 /* if snapshot, we create a temporary backing file and open it
1316 instead of opening 'filename' directly */
1318 /* Get the required size from the image */
1319 total_size = bdrv_getlength(bs);
1320 if (total_size < 0) {
1322 error_setg_errno(errp, -total_size, "Could not get image size");
1326 /* Create the temporary image */
1327 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1329 error_setg_errno(errp, -ret, "Could not get temporary filename");
1333 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1335 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1336 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1337 qemu_opts_del(opts);
1339 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1340 "'%s': %s", tmp_filename,
1341 error_get_pretty(local_err));
1342 error_free(local_err);
1346 /* Prepare a new options QDict for the temporary file */
1347 snapshot_options = qdict_new();
1348 qdict_put(snapshot_options, "file.driver",
1349 qstring_from_str("file"));
1350 qdict_put(snapshot_options, "file.filename",
1351 qstring_from_str(tmp_filename));
1352 qdict_put(snapshot_options, "driver",
1353 qstring_from_str("qcow2"));
1355 bs_snapshot = bdrv_new();
1357 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1360 error_propagate(errp, local_err);
1364 bdrv_append(bs_snapshot, bs);
1367 g_free(tmp_filename);
1372 * Opens a disk image (raw, qcow2, vmdk, ...)
1374 * options is a QDict of options to pass to the block drivers, or NULL for an
1375 * empty set of options. The reference to the QDict belongs to the block layer
1376 * after the call (even on failure), so if the caller intends to reuse the
1377 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1379 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1380 * If it is not NULL, the referenced BDS will be reused.
1382 * The reference parameter may be used to specify an existing block device which
1383 * should be opened. If specified, neither options nor a filename may be given,
1384 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1386 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1387 const char *reference, QDict *options, int flags,
1388 BlockDriverState *parent,
1389 const BdrvChildRole *child_role, Error **errp)
1392 BdrvChild *file = NULL;
1393 BlockDriverState *bs;
1394 BlockDriver *drv = NULL;
1395 const char *drvname;
1396 const char *backing;
1397 Error *local_err = NULL;
1398 int snapshot_flags = 0;
1401 assert(!child_role || !flags);
1402 assert(!child_role == !parent);
1405 bool options_non_empty = options ? qdict_size(options) : false;
1409 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1410 "another block device");
1414 if (filename || options_non_empty) {
1415 error_setg(errp, "Cannot reference an existing block device with "
1416 "additional options or a new filename");
1420 bs = bdrv_lookup_bs(reference, reference, errp);
1435 /* NULL means an empty set of options */
1436 if (options == NULL) {
1437 options = qdict_new();
1441 bs->inherits_from = parent;
1442 flags = child_role->inherit_flags(parent->open_flags);
1445 ret = bdrv_fill_options(&options, &filename, &flags, &local_err);
1450 /* Find the right image format driver */
1451 drvname = qdict_get_try_str(options, "driver");
1453 drv = bdrv_find_format(drvname);
1454 qdict_del(options, "driver");
1456 error_setg(errp, "Unknown driver: '%s'", drvname);
1462 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1464 backing = qdict_get_try_str(options, "backing");
1465 if (backing && *backing == '\0') {
1466 flags |= BDRV_O_NO_BACKING;
1467 qdict_del(options, "backing");
1470 bs->open_flags = flags;
1471 bs->options = options;
1472 options = qdict_clone_shallow(options);
1474 /* Open image file without format layer */
1475 if ((flags & BDRV_O_PROTOCOL) == 0) {
1476 if (flags & BDRV_O_RDWR) {
1477 flags |= BDRV_O_ALLOW_RDWR;
1479 if (flags & BDRV_O_SNAPSHOT) {
1480 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1481 flags = bdrv_backing_flags(flags);
1484 bs->open_flags = flags;
1486 file = bdrv_open_child(filename, options, "file", bs,
1487 &child_file, true, &local_err);
1494 /* Image format probing */
1497 ret = find_image_format(file->bs, filename, &drv, &local_err);
1502 error_setg(errp, "Must specify either driver or file");
1507 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1508 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1509 /* file must be NULL if a protocol BDS is about to be created
1510 * (the inverse results in an error message from bdrv_open_common()) */
1511 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1513 /* Open the image */
1514 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1519 if (file && (bs->file != file)) {
1520 bdrv_unref_child(bs, file);
1524 /* If there is a backing file, use it */
1525 if ((flags & BDRV_O_NO_BACKING) == 0) {
1526 QDict *backing_options;
1528 qdict_extract_subqdict(options, &backing_options, "backing.");
1529 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1531 goto close_and_fail;
1535 bdrv_refresh_filename(bs);
1537 /* Check if any unknown options were used */
1538 if (options && (qdict_size(options) != 0)) {
1539 const QDictEntry *entry = qdict_first(options);
1540 if (flags & BDRV_O_PROTOCOL) {
1541 error_setg(errp, "Block protocol '%s' doesn't support the option "
1542 "'%s'", drv->format_name, entry->key);
1544 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1545 "support the option '%s'", drv->format_name,
1546 bdrv_get_device_name(bs), entry->key);
1550 goto close_and_fail;
1553 if (!bdrv_key_required(bs)) {
1555 blk_dev_change_media_cb(bs->blk, true);
1557 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1558 && !runstate_check(RUN_STATE_INMIGRATE)
1559 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1561 "Guest must be stopped for opening of encrypted image");
1563 goto close_and_fail;
1569 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1570 * temporary snapshot afterwards. */
1571 if (snapshot_flags) {
1572 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1574 goto close_and_fail;
1582 bdrv_unref_child(bs, file);
1584 QDECREF(bs->options);
1588 /* If *pbs is NULL, a new BDS has been created in this function and
1589 needs to be freed now. Otherwise, it does not need to be closed,
1590 since it has not really been opened yet. */
1594 error_propagate(errp, local_err);
1599 /* See fail path, but now the BDS has to be always closed */
1607 error_propagate(errp, local_err);
1612 int bdrv_open(BlockDriverState **pbs, const char *filename,
1613 const char *reference, QDict *options, int flags, Error **errp)
1615 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1619 typedef struct BlockReopenQueueEntry {
1621 BDRVReopenState state;
1622 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1623 } BlockReopenQueueEntry;
1626 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1627 * reopen of multiple devices.
1629 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1630 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1631 * be created and initialized. This newly created BlockReopenQueue should be
1632 * passed back in for subsequent calls that are intended to be of the same
1635 * bs is the BlockDriverState to add to the reopen queue.
1637 * options contains the changed options for the associated bs
1638 * (the BlockReopenQueue takes ownership)
1640 * flags contains the open flags for the associated bs
1642 * returns a pointer to bs_queue, which is either the newly allocated
1643 * bs_queue, or the existing bs_queue being used.
1646 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1647 BlockDriverState *bs,
1648 QDict *options, int flags)
1652 BlockReopenQueueEntry *bs_entry;
1656 if (bs_queue == NULL) {
1657 bs_queue = g_new0(BlockReopenQueue, 1);
1658 QSIMPLEQ_INIT(bs_queue);
1662 options = qdict_new();
1665 old_options = qdict_clone_shallow(bs->options);
1666 qdict_join(options, old_options, false);
1667 QDECREF(old_options);
1669 /* bdrv_open() masks this flag out */
1670 flags &= ~BDRV_O_PROTOCOL;
1672 QLIST_FOREACH(child, &bs->children, next) {
1675 if (child->bs->inherits_from != bs) {
1679 child_flags = child->role->inherit_flags(flags);
1680 /* TODO Pass down child flags (backing.*, extents.*, ...) */
1681 bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
1684 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1685 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1687 bs_entry->state.bs = bs;
1688 bs_entry->state.options = options;
1689 bs_entry->state.flags = flags;
1695 * Reopen multiple BlockDriverStates atomically & transactionally.
1697 * The queue passed in (bs_queue) must have been built up previous
1698 * via bdrv_reopen_queue().
1700 * Reopens all BDS specified in the queue, with the appropriate
1701 * flags. All devices are prepared for reopen, and failure of any
1702 * device will cause all device changes to be abandonded, and intermediate
1705 * If all devices prepare successfully, then the changes are committed
1709 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1712 BlockReopenQueueEntry *bs_entry, *next;
1713 Error *local_err = NULL;
1715 assert(bs_queue != NULL);
1719 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1720 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1721 error_propagate(errp, local_err);
1724 bs_entry->prepared = true;
1727 /* If we reach this point, we have success and just need to apply the
1730 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1731 bdrv_reopen_commit(&bs_entry->state);
1737 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1738 if (ret && bs_entry->prepared) {
1739 bdrv_reopen_abort(&bs_entry->state);
1741 QDECREF(bs_entry->state.options);
1749 /* Reopen a single BlockDriverState with the specified flags. */
1750 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1753 Error *local_err = NULL;
1754 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1756 ret = bdrv_reopen_multiple(queue, &local_err);
1757 if (local_err != NULL) {
1758 error_propagate(errp, local_err);
1765 * Prepares a BlockDriverState for reopen. All changes are staged in the
1766 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1767 * the block driver layer .bdrv_reopen_prepare()
1769 * bs is the BlockDriverState to reopen
1770 * flags are the new open flags
1771 * queue is the reopen queue
1773 * Returns 0 on success, non-zero on error. On error errp will be set
1776 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1777 * It is the responsibility of the caller to then call the abort() or
1778 * commit() for any other BDS that have been left in a prepare() state
1781 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1785 Error *local_err = NULL;
1788 assert(reopen_state != NULL);
1789 assert(reopen_state->bs->drv != NULL);
1790 drv = reopen_state->bs->drv;
1792 /* if we are to stay read-only, do not allow permission change
1794 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1795 reopen_state->flags & BDRV_O_RDWR) {
1796 error_setg(errp, "Node '%s' is read only",
1797 bdrv_get_device_or_node_name(reopen_state->bs));
1802 ret = bdrv_flush(reopen_state->bs);
1804 error_setg_errno(errp, -ret, "Error flushing drive");
1808 if (drv->bdrv_reopen_prepare) {
1809 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1811 if (local_err != NULL) {
1812 error_propagate(errp, local_err);
1814 error_setg(errp, "failed while preparing to reopen image '%s'",
1815 reopen_state->bs->filename);
1820 /* It is currently mandatory to have a bdrv_reopen_prepare()
1821 * handler for each supported drv. */
1822 error_setg(errp, "Block format '%s' used by node '%s' "
1823 "does not support reopening files", drv->format_name,
1824 bdrv_get_device_or_node_name(reopen_state->bs));
1829 /* Options that are not handled are only okay if they are unchanged
1830 * compared to the old state. It is expected that some options are only
1831 * used for the initial open, but not reopen (e.g. filename) */
1832 if (qdict_size(reopen_state->options)) {
1833 const QDictEntry *entry = qdict_first(reopen_state->options);
1836 QString *new_obj = qobject_to_qstring(entry->value);
1837 const char *new = qstring_get_str(new_obj);
1838 const char *old = qdict_get_try_str(reopen_state->bs->options,
1841 if (!old || strcmp(new, old)) {
1842 error_setg(errp, "Cannot change the option '%s'", entry->key);
1846 } while ((entry = qdict_next(reopen_state->options, entry)));
1856 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1857 * makes them final by swapping the staging BlockDriverState contents into
1858 * the active BlockDriverState contents.
1860 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1864 assert(reopen_state != NULL);
1865 drv = reopen_state->bs->drv;
1866 assert(drv != NULL);
1868 /* If there are any driver level actions to take */
1869 if (drv->bdrv_reopen_commit) {
1870 drv->bdrv_reopen_commit(reopen_state);
1873 /* set BDS specific flags now */
1874 reopen_state->bs->open_flags = reopen_state->flags;
1875 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1877 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1879 bdrv_refresh_limits(reopen_state->bs, NULL);
1883 * Abort the reopen, and delete and free the staged changes in
1886 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1890 assert(reopen_state != NULL);
1891 drv = reopen_state->bs->drv;
1892 assert(drv != NULL);
1894 if (drv->bdrv_reopen_abort) {
1895 drv->bdrv_reopen_abort(reopen_state);
1900 void bdrv_close(BlockDriverState *bs)
1902 BdrvAioNotifier *ban, *ban_next;
1905 block_job_cancel_sync(bs->job);
1908 /* Disable I/O limits and drain all pending throttled requests */
1909 if (bs->throttle_state) {
1910 bdrv_io_limits_disable(bs);
1913 bdrv_drain(bs); /* complete I/O */
1915 bdrv_drain(bs); /* in case flush left pending I/O */
1916 notifier_list_notify(&bs->close_notifiers, bs);
1919 blk_dev_change_media_cb(bs->blk, false);
1923 BdrvChild *child, *next;
1925 bs->drv->bdrv_close(bs);
1928 bdrv_set_backing_hd(bs, NULL);
1930 if (bs->file != NULL) {
1931 bdrv_unref_child(bs, bs->file);
1935 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1936 /* TODO Remove bdrv_unref() from drivers' close function and use
1937 * bdrv_unref_child() here */
1938 if (child->bs->inherits_from == bs) {
1939 child->bs->inherits_from = NULL;
1941 bdrv_detach_child(child);
1946 bs->copy_on_read = 0;
1947 bs->backing_file[0] = '\0';
1948 bs->backing_format[0] = '\0';
1949 bs->total_sectors = 0;
1953 bs->zero_beyond_eof = false;
1954 QDECREF(bs->options);
1956 QDECREF(bs->full_open_options);
1957 bs->full_open_options = NULL;
1960 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1963 QLIST_INIT(&bs->aio_notifiers);
1966 void bdrv_close_all(void)
1968 BlockDriverState *bs;
1970 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1971 AioContext *aio_context = bdrv_get_aio_context(bs);
1973 aio_context_acquire(aio_context);
1975 aio_context_release(aio_context);
1979 /* make a BlockDriverState anonymous by removing from bdrv_state and
1980 * graph_bdrv_state list.
1981 Also, NULL terminate the device_name to prevent double remove */
1982 void bdrv_make_anon(BlockDriverState *bs)
1985 * Take care to remove bs from bdrv_states only when it's actually
1986 * in it. Note that bs->device_list.tqe_prev is initially null,
1987 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1988 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1989 * resetting it to null on remove.
1991 if (bs->device_list.tqe_prev) {
1992 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1993 bs->device_list.tqe_prev = NULL;
1995 if (bs->node_name[0] != '\0') {
1996 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1998 bs->node_name[0] = '\0';
2001 /* Fields that need to stay with the top-level BDS */
2002 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2003 BlockDriverState *bs_src)
2005 /* move some fields that need to stay attached to the device */
2008 bs_dest->copy_on_read = bs_src->copy_on_read;
2010 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2013 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2016 static void change_parent_backing_link(BlockDriverState *from,
2017 BlockDriverState *to)
2019 BdrvChild *c, *next;
2021 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2022 assert(c->role != &child_backing);
2024 QLIST_REMOVE(c, next_parent);
2025 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2030 blk_set_bs(from->blk, to);
2031 if (!to->device_list.tqe_prev) {
2032 QTAILQ_INSERT_BEFORE(from, to, device_list);
2034 QTAILQ_REMOVE(&bdrv_states, from, device_list);
2038 static void swap_feature_fields(BlockDriverState *bs_top,
2039 BlockDriverState *bs_new)
2041 BlockDriverState tmp;
2043 bdrv_move_feature_fields(&tmp, bs_top);
2044 bdrv_move_feature_fields(bs_top, bs_new);
2045 bdrv_move_feature_fields(bs_new, &tmp);
2047 assert(!bs_new->throttle_state);
2048 if (bs_top->throttle_state) {
2049 assert(bs_top->io_limits_enabled);
2050 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2051 bdrv_io_limits_disable(bs_top);
2056 * Add new bs contents at the top of an image chain while the chain is
2057 * live, while keeping required fields on the top layer.
2059 * This will modify the BlockDriverState fields, and swap contents
2060 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2062 * bs_new must not be attached to a BlockBackend.
2064 * This function does not create any image files.
2066 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2067 * that's what the callers commonly need. bs_new will be referenced by the old
2068 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2069 * reference of its own, it must call bdrv_ref().
2071 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2073 assert(!bdrv_requests_pending(bs_top));
2074 assert(!bdrv_requests_pending(bs_new));
2077 change_parent_backing_link(bs_top, bs_new);
2079 /* Some fields always stay on top of the backing file chain */
2080 swap_feature_fields(bs_top, bs_new);
2082 bdrv_set_backing_hd(bs_new, bs_top);
2085 /* bs_new is now referenced by its new parents, we don't need the
2086 * additional reference any more. */
2090 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2092 assert(!bdrv_requests_pending(old));
2093 assert(!bdrv_requests_pending(new));
2098 /* As long as these fields aren't in BlockBackend, but in the top-level
2099 * BlockDriverState, it's not possible for a BDS to have two BBs.
2101 * We really want to copy the fields from old to new, but we go for a
2102 * swap instead so that pointers aren't duplicated and cause trouble.
2103 * (Also, bdrv_swap() used to do the same.) */
2105 swap_feature_fields(old, new);
2107 change_parent_backing_link(old, new);
2109 /* Change backing files if a previously independent node is added to the
2110 * chain. For active commit, we replace top by its own (indirect) backing
2111 * file and don't do anything here so we don't build a loop. */
2112 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2113 bdrv_set_backing_hd(new, backing_bs(old));
2114 bdrv_set_backing_hd(old, NULL);
2120 static void bdrv_delete(BlockDriverState *bs)
2123 assert(bdrv_op_blocker_is_empty(bs));
2124 assert(!bs->refcnt);
2125 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2131 /* remove from list, if necessary */
2138 * Run consistency checks on an image
2140 * Returns 0 if the check could be completed (it doesn't mean that the image is
2141 * free of errors) or -errno when an internal error occurred. The results of the
2142 * check are stored in res.
2144 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2146 if (bs->drv == NULL) {
2149 if (bs->drv->bdrv_check == NULL) {
2153 memset(res, 0, sizeof(*res));
2154 return bs->drv->bdrv_check(bs, res, fix);
2157 #define COMMIT_BUF_SECTORS 2048
2159 /* commit COW file into the raw image */
2160 int bdrv_commit(BlockDriverState *bs)
2162 BlockDriver *drv = bs->drv;
2163 int64_t sector, total_sectors, length, backing_length;
2164 int n, ro, open_flags;
2166 uint8_t *buf = NULL;
2175 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2176 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2180 ro = bs->backing->bs->read_only;
2181 open_flags = bs->backing->bs->open_flags;
2184 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2189 length = bdrv_getlength(bs);
2195 backing_length = bdrv_getlength(bs->backing->bs);
2196 if (backing_length < 0) {
2197 ret = backing_length;
2201 /* If our top snapshot is larger than the backing file image,
2202 * grow the backing file image if possible. If not possible,
2203 * we must return an error */
2204 if (length > backing_length) {
2205 ret = bdrv_truncate(bs->backing->bs, length);
2211 total_sectors = length >> BDRV_SECTOR_BITS;
2213 /* qemu_try_blockalign() for bs will choose an alignment that works for
2214 * bs->backing->bs as well, so no need to compare the alignment manually. */
2215 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2221 for (sector = 0; sector < total_sectors; sector += n) {
2222 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2227 ret = bdrv_read(bs, sector, buf, n);
2232 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2239 if (drv->bdrv_make_empty) {
2240 ret = drv->bdrv_make_empty(bs);
2248 * Make sure all data we wrote to the backing device is actually
2252 bdrv_flush(bs->backing->bs);
2260 /* ignoring error return here */
2261 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2267 int bdrv_commit_all(void)
2269 BlockDriverState *bs;
2271 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2272 AioContext *aio_context = bdrv_get_aio_context(bs);
2274 aio_context_acquire(aio_context);
2275 if (bs->drv && bs->backing) {
2276 int ret = bdrv_commit(bs);
2278 aio_context_release(aio_context);
2282 aio_context_release(aio_context);
2290 * -EINVAL - backing format specified, but no file
2291 * -ENOSPC - can't update the backing file because no space is left in the
2293 * -ENOTSUP - format driver doesn't support changing the backing file
2295 int bdrv_change_backing_file(BlockDriverState *bs,
2296 const char *backing_file, const char *backing_fmt)
2298 BlockDriver *drv = bs->drv;
2301 /* Backing file format doesn't make sense without a backing file */
2302 if (backing_fmt && !backing_file) {
2306 if (drv->bdrv_change_backing_file != NULL) {
2307 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2313 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2314 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2320 * Finds the image layer in the chain that has 'bs' as its backing file.
2322 * active is the current topmost image.
2324 * Returns NULL if bs is not found in active's image chain,
2325 * or if active == bs.
2327 * Returns the bottommost base image if bs == NULL.
2329 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2330 BlockDriverState *bs)
2332 while (active && bs != backing_bs(active)) {
2333 active = backing_bs(active);
2339 /* Given a BDS, searches for the base layer. */
2340 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2342 return bdrv_find_overlay(bs, NULL);
2346 * Drops images above 'base' up to and including 'top', and sets the image
2347 * above 'top' to have base as its backing file.
2349 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2350 * information in 'bs' can be properly updated.
2352 * E.g., this will convert the following chain:
2353 * bottom <- base <- intermediate <- top <- active
2357 * bottom <- base <- active
2359 * It is allowed for bottom==base, in which case it converts:
2361 * base <- intermediate <- top <- active
2367 * If backing_file_str is non-NULL, it will be used when modifying top's
2368 * overlay image metadata.
2371 * if active == top, that is considered an error
2374 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2375 BlockDriverState *base, const char *backing_file_str)
2377 BlockDriverState *new_top_bs = NULL;
2380 if (!top->drv || !base->drv) {
2384 new_top_bs = bdrv_find_overlay(active, top);
2386 if (new_top_bs == NULL) {
2387 /* we could not find the image above 'top', this is an error */
2391 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2392 * to do, no intermediate images */
2393 if (backing_bs(new_top_bs) == base) {
2398 /* Make sure that base is in the backing chain of top */
2399 if (!bdrv_chain_contains(top, base)) {
2403 /* success - we can delete the intermediate states, and link top->base */
2404 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2405 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2406 base->drv ? base->drv->format_name : "");
2410 bdrv_set_backing_hd(new_top_bs, base);
2418 * Truncate file to 'offset' bytes (needed only for file protocols)
2420 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2422 BlockDriver *drv = bs->drv;
2426 if (!drv->bdrv_truncate)
2431 ret = drv->bdrv_truncate(bs, offset);
2433 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2434 bdrv_dirty_bitmap_truncate(bs);
2436 blk_dev_resize_cb(bs->blk);
2443 * Length of a allocated file in bytes. Sparse files are counted by actual
2444 * allocated space. Return < 0 if error or unknown.
2446 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2448 BlockDriver *drv = bs->drv;
2452 if (drv->bdrv_get_allocated_file_size) {
2453 return drv->bdrv_get_allocated_file_size(bs);
2456 return bdrv_get_allocated_file_size(bs->file->bs);
2462 * Return number of sectors on success, -errno on error.
2464 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2466 BlockDriver *drv = bs->drv;
2471 if (drv->has_variable_length) {
2472 int ret = refresh_total_sectors(bs, bs->total_sectors);
2477 return bs->total_sectors;
2481 * Return length in bytes on success, -errno on error.
2482 * The length is always a multiple of BDRV_SECTOR_SIZE.
2484 int64_t bdrv_getlength(BlockDriverState *bs)
2486 int64_t ret = bdrv_nb_sectors(bs);
2488 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2489 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2492 /* return 0 as number of sectors if no device present or error */
2493 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2495 int64_t nb_sectors = bdrv_nb_sectors(bs);
2497 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2500 int bdrv_is_read_only(BlockDriverState *bs)
2502 return bs->read_only;
2505 int bdrv_is_sg(BlockDriverState *bs)
2510 int bdrv_enable_write_cache(BlockDriverState *bs)
2512 return bs->enable_write_cache;
2515 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2517 bs->enable_write_cache = wce;
2519 /* so a reopen() will preserve wce */
2521 bs->open_flags |= BDRV_O_CACHE_WB;
2523 bs->open_flags &= ~BDRV_O_CACHE_WB;
2527 int bdrv_is_encrypted(BlockDriverState *bs)
2529 if (bs->backing && bs->backing->bs->encrypted) {
2532 return bs->encrypted;
2535 int bdrv_key_required(BlockDriverState *bs)
2537 BdrvChild *backing = bs->backing;
2539 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2542 return (bs->encrypted && !bs->valid_key);
2545 int bdrv_set_key(BlockDriverState *bs, const char *key)
2548 if (bs->backing && bs->backing->bs->encrypted) {
2549 ret = bdrv_set_key(bs->backing->bs, key);
2555 if (!bs->encrypted) {
2557 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2560 ret = bs->drv->bdrv_set_key(bs, key);
2563 } else if (!bs->valid_key) {
2566 /* call the change callback now, we skipped it on open */
2567 blk_dev_change_media_cb(bs->blk, true);
2574 * Provide an encryption key for @bs.
2575 * If @key is non-null:
2576 * If @bs is not encrypted, fail.
2577 * Else if the key is invalid, fail.
2578 * Else set @bs's key to @key, replacing the existing key, if any.
2580 * If @bs is encrypted and still lacks a key, fail.
2582 * On failure, store an error object through @errp if non-null.
2584 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2587 if (!bdrv_is_encrypted(bs)) {
2588 error_setg(errp, "Node '%s' is not encrypted",
2589 bdrv_get_device_or_node_name(bs));
2590 } else if (bdrv_set_key(bs, key) < 0) {
2591 error_setg(errp, QERR_INVALID_PASSWORD);
2594 if (bdrv_key_required(bs)) {
2595 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2596 "'%s' (%s) is encrypted",
2597 bdrv_get_device_or_node_name(bs),
2598 bdrv_get_encrypted_filename(bs));
2603 const char *bdrv_get_format_name(BlockDriverState *bs)
2605 return bs->drv ? bs->drv->format_name : NULL;
2608 static int qsort_strcmp(const void *a, const void *b)
2610 return strcmp(a, b);
2613 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2619 const char **formats = NULL;
2621 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2622 if (drv->format_name) {
2625 while (formats && i && !found) {
2626 found = !strcmp(formats[--i], drv->format_name);
2630 formats = g_renew(const char *, formats, count + 1);
2631 formats[count++] = drv->format_name;
2636 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2638 for (i = 0; i < count; i++) {
2639 it(opaque, formats[i]);
2645 /* This function is to find a node in the bs graph */
2646 BlockDriverState *bdrv_find_node(const char *node_name)
2648 BlockDriverState *bs;
2652 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2653 if (!strcmp(node_name, bs->node_name)) {
2660 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2661 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2663 BlockDeviceInfoList *list, *entry;
2664 BlockDriverState *bs;
2667 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2668 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2670 qapi_free_BlockDeviceInfoList(list);
2673 entry = g_malloc0(sizeof(*entry));
2674 entry->value = info;
2682 BlockDriverState *bdrv_lookup_bs(const char *device,
2683 const char *node_name,
2687 BlockDriverState *bs;
2690 blk = blk_by_name(device);
2695 error_setg(errp, "Device '%s' has no medium", device);
2703 bs = bdrv_find_node(node_name);
2710 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2711 device ? device : "",
2712 node_name ? node_name : "");
2716 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2717 * return false. If either argument is NULL, return false. */
2718 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2720 while (top && top != base) {
2721 top = backing_bs(top);
2727 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2730 return QTAILQ_FIRST(&graph_bdrv_states);
2732 return QTAILQ_NEXT(bs, node_list);
2735 BlockDriverState *bdrv_next(BlockDriverState *bs)
2738 return QTAILQ_FIRST(&bdrv_states);
2740 return QTAILQ_NEXT(bs, device_list);
2743 const char *bdrv_get_node_name(const BlockDriverState *bs)
2745 return bs->node_name;
2748 /* TODO check what callers really want: bs->node_name or blk_name() */
2749 const char *bdrv_get_device_name(const BlockDriverState *bs)
2751 return bs->blk ? blk_name(bs->blk) : "";
2754 /* This can be used to identify nodes that might not have a device
2755 * name associated. Since node and device names live in the same
2756 * namespace, the result is unambiguous. The exception is if both are
2757 * absent, then this returns an empty (non-null) string. */
2758 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2760 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2763 int bdrv_get_flags(BlockDriverState *bs)
2765 return bs->open_flags;
2768 int bdrv_has_zero_init_1(BlockDriverState *bs)
2773 int bdrv_has_zero_init(BlockDriverState *bs)
2777 /* If BS is a copy on write image, it is initialized to
2778 the contents of the base image, which may not be zeroes. */
2782 if (bs->drv->bdrv_has_zero_init) {
2783 return bs->drv->bdrv_has_zero_init(bs);
2790 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2792 BlockDriverInfo bdi;
2798 if (bdrv_get_info(bs, &bdi) == 0) {
2799 return bdi.unallocated_blocks_are_zero;
2805 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2807 BlockDriverInfo bdi;
2809 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
2813 if (bdrv_get_info(bs, &bdi) == 0) {
2814 return bdi.can_write_zeroes_with_unmap;
2820 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2822 if (bs->backing && bs->backing->bs->encrypted)
2823 return bs->backing_file;
2824 else if (bs->encrypted)
2825 return bs->filename;
2830 void bdrv_get_backing_filename(BlockDriverState *bs,
2831 char *filename, int filename_size)
2833 pstrcpy(filename, filename_size, bs->backing_file);
2836 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2838 BlockDriver *drv = bs->drv;
2841 if (!drv->bdrv_get_info)
2843 memset(bdi, 0, sizeof(*bdi));
2844 return drv->bdrv_get_info(bs, bdi);
2847 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2849 BlockDriver *drv = bs->drv;
2850 if (drv && drv->bdrv_get_specific_info) {
2851 return drv->bdrv_get_specific_info(bs);
2856 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2858 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2862 bs->drv->bdrv_debug_event(bs, event);
2865 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
2868 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
2869 bs = bs->file ? bs->file->bs : NULL;
2872 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
2873 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
2879 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
2881 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
2882 bs = bs->file ? bs->file->bs : NULL;
2885 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
2886 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
2892 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
2894 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
2895 bs = bs->file ? bs->file->bs : NULL;
2898 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
2899 return bs->drv->bdrv_debug_resume(bs, tag);
2905 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
2907 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
2908 bs = bs->file ? bs->file->bs : NULL;
2911 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
2912 return bs->drv->bdrv_debug_is_suspended(bs, tag);
2918 int bdrv_is_snapshot(BlockDriverState *bs)
2920 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
2923 /* backing_file can either be relative, or absolute, or a protocol. If it is
2924 * relative, it must be relative to the chain. So, passing in bs->filename
2925 * from a BDS as backing_file should not be done, as that may be relative to
2926 * the CWD rather than the chain. */
2927 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
2928 const char *backing_file)
2930 char *filename_full = NULL;
2931 char *backing_file_full = NULL;
2932 char *filename_tmp = NULL;
2933 int is_protocol = 0;
2934 BlockDriverState *curr_bs = NULL;
2935 BlockDriverState *retval = NULL;
2937 if (!bs || !bs->drv || !backing_file) {
2941 filename_full = g_malloc(PATH_MAX);
2942 backing_file_full = g_malloc(PATH_MAX);
2943 filename_tmp = g_malloc(PATH_MAX);
2945 is_protocol = path_has_protocol(backing_file);
2947 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
2949 /* If either of the filename paths is actually a protocol, then
2950 * compare unmodified paths; otherwise make paths relative */
2951 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
2952 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
2953 retval = curr_bs->backing->bs;
2957 /* If not an absolute filename path, make it relative to the current
2958 * image's filename path */
2959 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
2962 /* We are going to compare absolute pathnames */
2963 if (!realpath(filename_tmp, filename_full)) {
2967 /* We need to make sure the backing filename we are comparing against
2968 * is relative to the current image filename (or absolute) */
2969 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
2970 curr_bs->backing_file);
2972 if (!realpath(filename_tmp, backing_file_full)) {
2976 if (strcmp(backing_file_full, filename_full) == 0) {
2977 retval = curr_bs->backing->bs;
2983 g_free(filename_full);
2984 g_free(backing_file_full);
2985 g_free(filename_tmp);
2989 int bdrv_get_backing_file_depth(BlockDriverState *bs)
2999 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3002 void bdrv_init(void)
3004 module_call_init(MODULE_INIT_BLOCK);
3007 void bdrv_init_with_whitelist(void)
3009 use_bdrv_whitelist = 1;
3013 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3015 Error *local_err = NULL;
3022 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3025 bs->open_flags &= ~BDRV_O_INCOMING;
3027 if (bs->drv->bdrv_invalidate_cache) {
3028 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3029 } else if (bs->file) {
3030 bdrv_invalidate_cache(bs->file->bs, &local_err);
3033 error_propagate(errp, local_err);
3037 ret = refresh_total_sectors(bs, bs->total_sectors);
3039 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3044 void bdrv_invalidate_cache_all(Error **errp)
3046 BlockDriverState *bs;
3047 Error *local_err = NULL;
3049 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3050 AioContext *aio_context = bdrv_get_aio_context(bs);
3052 aio_context_acquire(aio_context);
3053 bdrv_invalidate_cache(bs, &local_err);
3054 aio_context_release(aio_context);
3056 error_propagate(errp, local_err);
3062 /**************************************************************/
3063 /* removable device support */
3066 * Return TRUE if the media is present
3068 bool bdrv_is_inserted(BlockDriverState *bs)
3070 BlockDriver *drv = bs->drv;
3076 if (drv->bdrv_is_inserted) {
3077 return drv->bdrv_is_inserted(bs);
3079 QLIST_FOREACH(child, &bs->children, next) {
3080 if (!bdrv_is_inserted(child->bs)) {
3088 * Return whether the media changed since the last call to this
3089 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3091 int bdrv_media_changed(BlockDriverState *bs)
3093 BlockDriver *drv = bs->drv;
3095 if (drv && drv->bdrv_media_changed) {
3096 return drv->bdrv_media_changed(bs);
3102 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3104 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3106 BlockDriver *drv = bs->drv;
3107 const char *device_name;
3109 if (drv && drv->bdrv_eject) {
3110 drv->bdrv_eject(bs, eject_flag);
3113 device_name = bdrv_get_device_name(bs);
3114 if (device_name[0] != '\0') {
3115 qapi_event_send_device_tray_moved(device_name,
3116 eject_flag, &error_abort);
3121 * Lock or unlock the media (if it is locked, the user won't be able
3122 * to eject it manually).
3124 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3126 BlockDriver *drv = bs->drv;
3128 trace_bdrv_lock_medium(bs, locked);
3130 if (drv && drv->bdrv_lock_medium) {
3131 drv->bdrv_lock_medium(bs, locked);
3135 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3137 BdrvDirtyBitmap *bm;
3140 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3141 if (bm->name && !strcmp(name, bm->name)) {
3148 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3150 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3151 g_free(bitmap->name);
3152 bitmap->name = NULL;
3155 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3156 uint32_t granularity,
3160 int64_t bitmap_size;
3161 BdrvDirtyBitmap *bitmap;
3162 uint32_t sector_granularity;
3164 assert((granularity & (granularity - 1)) == 0);
3166 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3167 error_setg(errp, "Bitmap already exists: %s", name);
3170 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3171 assert(sector_granularity);
3172 bitmap_size = bdrv_nb_sectors(bs);
3173 if (bitmap_size < 0) {
3174 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3175 errno = -bitmap_size;
3178 bitmap = g_new0(BdrvDirtyBitmap, 1);
3179 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3180 bitmap->size = bitmap_size;
3181 bitmap->name = g_strdup(name);
3182 bitmap->disabled = false;
3183 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3187 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3189 return bitmap->successor;
3192 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3194 return !(bitmap->disabled || bitmap->successor);
3197 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3199 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3200 return DIRTY_BITMAP_STATUS_FROZEN;
3201 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3202 return DIRTY_BITMAP_STATUS_DISABLED;
3204 return DIRTY_BITMAP_STATUS_ACTIVE;
3209 * Create a successor bitmap destined to replace this bitmap after an operation.
3210 * Requires that the bitmap is not frozen and has no successor.
3212 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3213 BdrvDirtyBitmap *bitmap, Error **errp)
3215 uint64_t granularity;
3216 BdrvDirtyBitmap *child;
3218 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3219 error_setg(errp, "Cannot create a successor for a bitmap that is "
3220 "currently frozen");
3223 assert(!bitmap->successor);
3225 /* Create an anonymous successor */
3226 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3227 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3232 /* Successor will be on or off based on our current state. */
3233 child->disabled = bitmap->disabled;
3235 /* Install the successor and freeze the parent */
3236 bitmap->successor = child;
3241 * For a bitmap with a successor, yield our name to the successor,
3242 * delete the old bitmap, and return a handle to the new bitmap.
3244 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3245 BdrvDirtyBitmap *bitmap,
3249 BdrvDirtyBitmap *successor = bitmap->successor;
3251 if (successor == NULL) {
3252 error_setg(errp, "Cannot relinquish control if "
3253 "there's no successor present");
3257 name = bitmap->name;
3258 bitmap->name = NULL;
3259 successor->name = name;
3260 bitmap->successor = NULL;
3261 bdrv_release_dirty_bitmap(bs, bitmap);
3267 * In cases of failure where we can no longer safely delete the parent,
3268 * we may wish to re-join the parent and child/successor.
3269 * The merged parent will be un-frozen, but not explicitly re-enabled.
3271 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3272 BdrvDirtyBitmap *parent,
3275 BdrvDirtyBitmap *successor = parent->successor;
3278 error_setg(errp, "Cannot reclaim a successor when none is present");
3282 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3283 error_setg(errp, "Merging of parent and successor bitmap failed");
3286 bdrv_release_dirty_bitmap(bs, successor);
3287 parent->successor = NULL;
3293 * Truncates _all_ bitmaps attached to a BDS.
3295 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3297 BdrvDirtyBitmap *bitmap;
3298 uint64_t size = bdrv_nb_sectors(bs);
3300 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3301 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3302 hbitmap_truncate(bitmap->bitmap, size);
3303 bitmap->size = size;
3307 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3309 BdrvDirtyBitmap *bm, *next;
3310 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3312 assert(!bdrv_dirty_bitmap_frozen(bm));
3313 QLIST_REMOVE(bitmap, list);
3314 hbitmap_free(bitmap->bitmap);
3315 g_free(bitmap->name);
3322 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3324 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3325 bitmap->disabled = true;
3328 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3330 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3331 bitmap->disabled = false;
3334 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3336 BdrvDirtyBitmap *bm;
3337 BlockDirtyInfoList *list = NULL;
3338 BlockDirtyInfoList **plist = &list;
3340 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3341 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3342 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3343 info->count = bdrv_get_dirty_count(bm);
3344 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3345 info->has_name = !!bm->name;
3346 info->name = g_strdup(bm->name);
3347 info->status = bdrv_dirty_bitmap_status(bm);
3348 entry->value = info;
3350 plist = &entry->next;
3356 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3359 return hbitmap_get(bitmap->bitmap, sector);
3366 * Chooses a default granularity based on the existing cluster size,
3367 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3368 * is no cluster size information available.
3370 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3372 BlockDriverInfo bdi;
3373 uint32_t granularity;
3375 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3376 granularity = MAX(4096, bdi.cluster_size);
3377 granularity = MIN(65536, granularity);
3379 granularity = 65536;
3385 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3387 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3390 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3392 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3395 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3396 int64_t cur_sector, int nr_sectors)
3398 assert(bdrv_dirty_bitmap_enabled(bitmap));
3399 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3402 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3403 int64_t cur_sector, int nr_sectors)
3405 assert(bdrv_dirty_bitmap_enabled(bitmap));
3406 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3409 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
3411 assert(bdrv_dirty_bitmap_enabled(bitmap));
3413 hbitmap_reset_all(bitmap->bitmap);
3415 HBitmap *backup = bitmap->bitmap;
3416 bitmap->bitmap = hbitmap_alloc(bitmap->size,
3417 hbitmap_granularity(backup));
3422 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
3424 HBitmap *tmp = bitmap->bitmap;
3425 assert(bdrv_dirty_bitmap_enabled(bitmap));
3426 bitmap->bitmap = in;
3430 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3433 BdrvDirtyBitmap *bitmap;
3434 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3435 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3438 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3443 * Advance an HBitmapIter to an arbitrary offset.
3445 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3448 hbitmap_iter_init(hbi, hbi->hb, offset);
3451 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3453 return hbitmap_count(bitmap->bitmap);
3456 /* Get a reference to bs */
3457 void bdrv_ref(BlockDriverState *bs)
3462 /* Release a previously grabbed reference to bs.
3463 * If after releasing, reference count is zero, the BlockDriverState is
3465 void bdrv_unref(BlockDriverState *bs)
3470 assert(bs->refcnt > 0);
3471 if (--bs->refcnt == 0) {
3476 struct BdrvOpBlocker {
3478 QLIST_ENTRY(BdrvOpBlocker) list;
3481 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3483 BdrvOpBlocker *blocker;
3484 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3485 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3486 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3488 error_setg(errp, "Node '%s' is busy: %s",
3489 bdrv_get_device_or_node_name(bs),
3490 error_get_pretty(blocker->reason));
3497 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3499 BdrvOpBlocker *blocker;
3500 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3502 blocker = g_new0(BdrvOpBlocker, 1);
3503 blocker->reason = reason;
3504 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3507 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3509 BdrvOpBlocker *blocker, *next;
3510 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3511 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3512 if (blocker->reason == reason) {
3513 QLIST_REMOVE(blocker, list);
3519 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3522 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3523 bdrv_op_block(bs, i, reason);
3527 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3530 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3531 bdrv_op_unblock(bs, i, reason);
3535 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3539 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3540 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3547 void bdrv_img_create(const char *filename, const char *fmt,
3548 const char *base_filename, const char *base_fmt,
3549 char *options, uint64_t img_size, int flags,
3550 Error **errp, bool quiet)
3552 QemuOptsList *create_opts = NULL;
3553 QemuOpts *opts = NULL;
3554 const char *backing_fmt, *backing_file;
3556 BlockDriver *drv, *proto_drv;
3557 Error *local_err = NULL;
3560 /* Find driver and parse its options */
3561 drv = bdrv_find_format(fmt);
3563 error_setg(errp, "Unknown file format '%s'", fmt);
3567 proto_drv = bdrv_find_protocol(filename, true, errp);
3572 if (!drv->create_opts) {
3573 error_setg(errp, "Format driver '%s' does not support image creation",
3578 if (!proto_drv->create_opts) {
3579 error_setg(errp, "Protocol driver '%s' does not support image creation",
3580 proto_drv->format_name);
3584 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3585 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3587 /* Create parameter list with default values */
3588 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3589 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3591 /* Parse -o options */
3593 qemu_opts_do_parse(opts, options, NULL, &local_err);
3595 error_report_err(local_err);
3597 error_setg(errp, "Invalid options for file format '%s'", fmt);
3602 if (base_filename) {
3603 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3605 error_setg(errp, "Backing file not supported for file format '%s'",
3612 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3614 error_setg(errp, "Backing file format not supported for file "
3615 "format '%s'", fmt);
3620 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3622 if (!strcmp(filename, backing_file)) {
3623 error_setg(errp, "Error: Trying to create an image with the "
3624 "same filename as the backing file");
3629 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3631 // The size for the image must always be specified, with one exception:
3632 // If we are using a backing file, we can obtain the size from there
3633 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3636 BlockDriverState *bs;
3637 char *full_backing = g_new0(char, PATH_MAX);
3640 QDict *backing_options = NULL;
3642 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3643 full_backing, PATH_MAX,
3646 g_free(full_backing);
3650 /* backing files always opened read-only */
3652 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3655 backing_options = qdict_new();
3656 qdict_put(backing_options, "driver",
3657 qstring_from_str(backing_fmt));
3661 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3662 back_flags, &local_err);
3663 g_free(full_backing);
3667 size = bdrv_getlength(bs);
3669 error_setg_errno(errp, -size, "Could not get size of '%s'",
3675 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3679 error_setg(errp, "Image creation needs a size parameter");
3685 printf("Formatting '%s', fmt=%s ", filename, fmt);
3686 qemu_opts_print(opts, " ");
3690 ret = bdrv_create(drv, filename, opts, &local_err);
3692 if (ret == -EFBIG) {
3693 /* This is generally a better message than whatever the driver would
3694 * deliver (especially because of the cluster_size_hint), since that
3695 * is most probably not much different from "image too large". */
3696 const char *cluster_size_hint = "";
3697 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3698 cluster_size_hint = " (try using a larger cluster size)";
3700 error_setg(errp, "The image size is too large for file format '%s'"
3701 "%s", fmt, cluster_size_hint);
3702 error_free(local_err);
3707 qemu_opts_del(opts);
3708 qemu_opts_free(create_opts);
3710 error_propagate(errp, local_err);
3714 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3716 return bs->aio_context;
3719 void bdrv_detach_aio_context(BlockDriverState *bs)
3721 BdrvAioNotifier *baf;
3727 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3728 baf->detach_aio_context(baf->opaque);
3731 if (bs->throttle_state) {
3732 throttle_timers_detach_aio_context(&bs->throttle_timers);
3734 if (bs->drv->bdrv_detach_aio_context) {
3735 bs->drv->bdrv_detach_aio_context(bs);
3738 bdrv_detach_aio_context(bs->file->bs);
3741 bdrv_detach_aio_context(bs->backing->bs);
3744 bs->aio_context = NULL;
3747 void bdrv_attach_aio_context(BlockDriverState *bs,
3748 AioContext *new_context)
3750 BdrvAioNotifier *ban;
3756 bs->aio_context = new_context;
3759 bdrv_attach_aio_context(bs->backing->bs, new_context);
3762 bdrv_attach_aio_context(bs->file->bs, new_context);
3764 if (bs->drv->bdrv_attach_aio_context) {
3765 bs->drv->bdrv_attach_aio_context(bs, new_context);
3767 if (bs->throttle_state) {
3768 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3771 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3772 ban->attached_aio_context(new_context, ban->opaque);
3776 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3778 bdrv_drain(bs); /* ensure there are no in-flight requests */
3780 bdrv_detach_aio_context(bs);
3782 /* This function executes in the old AioContext so acquire the new one in
3783 * case it runs in a different thread.
3785 aio_context_acquire(new_context);
3786 bdrv_attach_aio_context(bs, new_context);
3787 aio_context_release(new_context);
3790 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3791 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3792 void (*detach_aio_context)(void *opaque), void *opaque)
3794 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3795 *ban = (BdrvAioNotifier){
3796 .attached_aio_context = attached_aio_context,
3797 .detach_aio_context = detach_aio_context,
3801 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3804 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3805 void (*attached_aio_context)(AioContext *,
3807 void (*detach_aio_context)(void *),
3810 BdrvAioNotifier *ban, *ban_next;
3812 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3813 if (ban->attached_aio_context == attached_aio_context &&
3814 ban->detach_aio_context == detach_aio_context &&
3815 ban->opaque == opaque)
3817 QLIST_REMOVE(ban, list);
3827 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3828 BlockDriverAmendStatusCB *status_cb)
3830 if (!bs->drv->bdrv_amend_options) {
3833 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
3836 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3837 * of block filter and by bdrv_is_first_non_filter.
3838 * It is used to test if the given bs is the candidate or recurse more in the
3841 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3842 BlockDriverState *candidate)
3844 /* return false if basic checks fails */
3845 if (!bs || !bs->drv) {
3849 /* the code reached a non block filter driver -> check if the bs is
3850 * the same as the candidate. It's the recursion termination condition.
3852 if (!bs->drv->is_filter) {
3853 return bs == candidate;
3855 /* Down this path the driver is a block filter driver */
3857 /* If the block filter recursion method is defined use it to recurse down
3860 if (bs->drv->bdrv_recurse_is_first_non_filter) {
3861 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3864 /* the driver is a block filter but don't allow to recurse -> return false
3869 /* This function checks if the candidate is the first non filter bs down it's
3870 * bs chain. Since we don't have pointers to parents it explore all bs chains
3871 * from the top. Some filters can choose not to pass down the recursion.
3873 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
3875 BlockDriverState *bs;
3877 /* walk down the bs forest recursively */
3878 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3881 /* try to recurse in this top level bs */
3882 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
3884 /* candidate is the first non filter */
3893 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3894 const char *node_name, Error **errp)
3896 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
3897 AioContext *aio_context;
3899 if (!to_replace_bs) {
3900 error_setg(errp, "Node name '%s' not found", node_name);
3904 aio_context = bdrv_get_aio_context(to_replace_bs);
3905 aio_context_acquire(aio_context);
3907 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
3908 to_replace_bs = NULL;
3912 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3913 * most non filter in order to prevent data corruption.
3914 * Another benefit is that this tests exclude backing files which are
3915 * blocked by the backing blockers.
3917 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
3918 error_setg(errp, "Only top most non filter can be replaced");
3919 to_replace_bs = NULL;
3924 aio_context_release(aio_context);
3925 return to_replace_bs;
3928 static bool append_open_options(QDict *d, BlockDriverState *bs)
3930 const QDictEntry *entry;
3931 bool found_any = false;
3933 for (entry = qdict_first(bs->options); entry;
3934 entry = qdict_next(bs->options, entry))
3936 /* Only take options for this level and exclude all non-driver-specific
3938 if (!strchr(qdict_entry_key(entry), '.') &&
3939 strcmp(qdict_entry_key(entry), "node-name"))
3941 qobject_incref(qdict_entry_value(entry));
3942 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3950 /* Updates the following BDS fields:
3951 * - exact_filename: A filename which may be used for opening a block device
3952 * which (mostly) equals the given BDS (even without any
3953 * other options; so reading and writing must return the same
3954 * results, but caching etc. may be different)
3955 * - full_open_options: Options which, when given when opening a block device
3956 * (without a filename), result in a BDS (mostly)
3957 * equalling the given one
3958 * - filename: If exact_filename is set, it is copied here. Otherwise,
3959 * full_open_options is converted to a JSON object, prefixed with
3960 * "json:" (for use through the JSON pseudo protocol) and put here.
3962 void bdrv_refresh_filename(BlockDriverState *bs)
3964 BlockDriver *drv = bs->drv;
3971 /* This BDS's file name will most probably depend on its file's name, so
3972 * refresh that first */
3974 bdrv_refresh_filename(bs->file->bs);
3977 if (drv->bdrv_refresh_filename) {
3978 /* Obsolete information is of no use here, so drop the old file name
3979 * information before refreshing it */
3980 bs->exact_filename[0] = '\0';
3981 if (bs->full_open_options) {
3982 QDECREF(bs->full_open_options);
3983 bs->full_open_options = NULL;
3986 drv->bdrv_refresh_filename(bs);
3987 } else if (bs->file) {
3988 /* Try to reconstruct valid information from the underlying file */
3989 bool has_open_options;
3991 bs->exact_filename[0] = '\0';
3992 if (bs->full_open_options) {
3993 QDECREF(bs->full_open_options);
3994 bs->full_open_options = NULL;
3998 has_open_options = append_open_options(opts, bs);
4000 /* If no specific options have been given for this BDS, the filename of
4001 * the underlying file should suffice for this one as well */
4002 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4003 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4005 /* Reconstructing the full options QDict is simple for most format block
4006 * drivers, as long as the full options are known for the underlying
4007 * file BDS. The full options QDict of that file BDS should somehow
4008 * contain a representation of the filename, therefore the following
4009 * suffices without querying the (exact_)filename of this BDS. */
4010 if (bs->file->bs->full_open_options) {
4011 qdict_put_obj(opts, "driver",
4012 QOBJECT(qstring_from_str(drv->format_name)));
4013 QINCREF(bs->file->bs->full_open_options);
4014 qdict_put_obj(opts, "file",
4015 QOBJECT(bs->file->bs->full_open_options));
4017 bs->full_open_options = opts;
4021 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4022 /* There is no underlying file BDS (at least referenced by BDS.file),
4023 * so the full options QDict should be equal to the options given
4024 * specifically for this block device when it was opened (plus the
4025 * driver specification).
4026 * Because those options don't change, there is no need to update
4027 * full_open_options when it's already set. */
4030 append_open_options(opts, bs);
4031 qdict_put_obj(opts, "driver",
4032 QOBJECT(qstring_from_str(drv->format_name)));
4034 if (bs->exact_filename[0]) {
4035 /* This may not work for all block protocol drivers (some may
4036 * require this filename to be parsed), but we have to find some
4037 * default solution here, so just include it. If some block driver
4038 * does not support pure options without any filename at all or
4039 * needs some special format of the options QDict, it needs to
4040 * implement the driver-specific bdrv_refresh_filename() function.
4042 qdict_put_obj(opts, "filename",
4043 QOBJECT(qstring_from_str(bs->exact_filename)));
4046 bs->full_open_options = opts;
4049 if (bs->exact_filename[0]) {
4050 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4051 } else if (bs->full_open_options) {
4052 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4053 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4054 qstring_get_str(json));