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 "block/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 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
77 QTAILQ_HEAD_INITIALIZER(bdrv_states);
79 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
82 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
83 QLIST_HEAD_INITIALIZER(bdrv_drivers);
85 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
86 const char *reference, QDict *options, int flags,
87 BlockDriverState *parent,
88 const BdrvChildRole *child_role, Error **errp);
90 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
91 /* If non-zero, use only whitelisted block drivers */
92 static int use_bdrv_whitelist;
95 static int is_windows_drive_prefix(const char *filename)
97 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
98 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
102 int is_windows_drive(const char *filename)
104 if (is_windows_drive_prefix(filename) &&
107 if (strstart(filename, "\\\\.\\", NULL) ||
108 strstart(filename, "//./", NULL))
114 size_t bdrv_opt_mem_align(BlockDriverState *bs)
116 if (!bs || !bs->drv) {
117 /* page size or 4k (hdd sector size) should be on the safe side */
118 return MAX(4096, getpagesize());
121 return bs->bl.opt_mem_alignment;
124 size_t bdrv_min_mem_align(BlockDriverState *bs)
126 if (!bs || !bs->drv) {
127 /* page size or 4k (hdd sector size) should be on the safe side */
128 return MAX(4096, getpagesize());
131 return bs->bl.min_mem_alignment;
134 /* check if the path starts with "<protocol>:" */
135 int path_has_protocol(const char *path)
140 if (is_windows_drive(path) ||
141 is_windows_drive_prefix(path)) {
144 p = path + strcspn(path, ":/\\");
146 p = path + strcspn(path, ":/");
152 int path_is_absolute(const char *path)
155 /* specific case for names like: "\\.\d:" */
156 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
159 return (*path == '/' || *path == '\\');
161 return (*path == '/');
165 /* if filename is absolute, just copy it to dest. Otherwise, build a
166 path to it by considering it is relative to base_path. URL are
168 void path_combine(char *dest, int dest_size,
169 const char *base_path,
170 const char *filename)
177 if (path_is_absolute(filename)) {
178 pstrcpy(dest, dest_size, filename);
180 p = strchr(base_path, ':');
185 p1 = strrchr(base_path, '/');
189 p2 = strrchr(base_path, '\\');
201 if (len > dest_size - 1)
203 memcpy(dest, base_path, len);
205 pstrcat(dest, dest_size, filename);
209 void bdrv_get_full_backing_filename_from_filename(const char *backed,
211 char *dest, size_t sz,
214 if (backing[0] == '\0' || path_has_protocol(backing) ||
215 path_is_absolute(backing))
217 pstrcpy(dest, sz, backing);
218 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
219 error_setg(errp, "Cannot use relative backing file names for '%s'",
222 path_combine(dest, sz, backed, backing);
226 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
229 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
231 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
235 void bdrv_register(BlockDriver *bdrv)
237 bdrv_setup_io_funcs(bdrv);
239 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
242 BlockDriverState *bdrv_new_root(void)
244 BlockDriverState *bs = bdrv_new();
246 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
250 BlockDriverState *bdrv_new(void)
252 BlockDriverState *bs;
255 bs = g_new0(BlockDriverState, 1);
256 QLIST_INIT(&bs->dirty_bitmaps);
257 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
258 QLIST_INIT(&bs->op_blockers[i]);
260 bdrv_iostatus_disable(bs);
261 notifier_list_init(&bs->close_notifiers);
262 notifier_with_return_list_init(&bs->before_write_notifiers);
263 qemu_co_queue_init(&bs->throttled_reqs[0]);
264 qemu_co_queue_init(&bs->throttled_reqs[1]);
266 bs->aio_context = qemu_get_aio_context();
271 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
273 notifier_list_add(&bs->close_notifiers, notify);
276 BlockDriver *bdrv_find_format(const char *format_name)
279 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
280 if (!strcmp(drv1->format_name, format_name)) {
287 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
289 static const char *whitelist_rw[] = {
290 CONFIG_BDRV_RW_WHITELIST
292 static const char *whitelist_ro[] = {
293 CONFIG_BDRV_RO_WHITELIST
297 if (!whitelist_rw[0] && !whitelist_ro[0]) {
298 return 1; /* no whitelist, anything goes */
301 for (p = whitelist_rw; *p; p++) {
302 if (!strcmp(drv->format_name, *p)) {
307 for (p = whitelist_ro; *p; p++) {
308 if (!strcmp(drv->format_name, *p)) {
316 typedef struct CreateCo {
324 static void coroutine_fn bdrv_create_co_entry(void *opaque)
326 Error *local_err = NULL;
329 CreateCo *cco = opaque;
332 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
334 error_propagate(&cco->err, local_err);
339 int bdrv_create(BlockDriver *drv, const char* filename,
340 QemuOpts *opts, Error **errp)
347 .filename = g_strdup(filename),
353 if (!drv->bdrv_create) {
354 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
359 if (qemu_in_coroutine()) {
360 /* Fast-path if already in coroutine context */
361 bdrv_create_co_entry(&cco);
363 co = qemu_coroutine_create(bdrv_create_co_entry);
364 qemu_coroutine_enter(co, &cco);
365 while (cco.ret == NOT_DONE) {
366 aio_poll(qemu_get_aio_context(), true);
373 error_propagate(errp, cco.err);
375 error_setg_errno(errp, -ret, "Could not create image");
380 g_free(cco.filename);
384 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
387 Error *local_err = NULL;
390 drv = bdrv_find_protocol(filename, true, errp);
395 ret = bdrv_create(drv, filename, opts, &local_err);
397 error_propagate(errp, local_err);
403 * Try to get @bs's logical and physical block size.
404 * On success, store them in @bsz struct and return 0.
405 * On failure return -errno.
406 * @bs must not be empty.
408 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
410 BlockDriver *drv = bs->drv;
412 if (drv && drv->bdrv_probe_blocksizes) {
413 return drv->bdrv_probe_blocksizes(bs, bsz);
420 * Try to get @bs's geometry (cyls, heads, sectors).
421 * On success, store them in @geo struct and return 0.
422 * On failure return -errno.
423 * @bs must not be empty.
425 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
427 BlockDriver *drv = bs->drv;
429 if (drv && drv->bdrv_probe_geometry) {
430 return drv->bdrv_probe_geometry(bs, geo);
437 * Create a uniquely-named empty temporary file.
438 * Return 0 upon success, otherwise a negative errno value.
440 int get_tmp_filename(char *filename, int size)
443 char temp_dir[MAX_PATH];
444 /* GetTempFileName requires that its output buffer (4th param)
445 have length MAX_PATH or greater. */
446 assert(size >= MAX_PATH);
447 return (GetTempPath(MAX_PATH, temp_dir)
448 && GetTempFileName(temp_dir, "qem", 0, filename)
449 ? 0 : -GetLastError());
453 tmpdir = getenv("TMPDIR");
457 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
460 fd = mkstemp(filename);
464 if (close(fd) != 0) {
473 * Detect host devices. By convention, /dev/cdrom[N] is always
474 * recognized as a host CDROM.
476 static BlockDriver *find_hdev_driver(const char *filename)
478 int score_max = 0, score;
479 BlockDriver *drv = NULL, *d;
481 QLIST_FOREACH(d, &bdrv_drivers, list) {
482 if (d->bdrv_probe_device) {
483 score = d->bdrv_probe_device(filename);
484 if (score > score_max) {
494 BlockDriver *bdrv_find_protocol(const char *filename,
495 bool allow_protocol_prefix,
503 /* TODO Drivers without bdrv_file_open must be specified explicitly */
506 * XXX(hch): we really should not let host device detection
507 * override an explicit protocol specification, but moving this
508 * later breaks access to device names with colons in them.
509 * Thanks to the brain-dead persistent naming schemes on udev-
510 * based Linux systems those actually are quite common.
512 drv1 = find_hdev_driver(filename);
517 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
521 p = strchr(filename, ':');
524 if (len > sizeof(protocol) - 1)
525 len = sizeof(protocol) - 1;
526 memcpy(protocol, filename, len);
527 protocol[len] = '\0';
528 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
529 if (drv1->protocol_name &&
530 !strcmp(drv1->protocol_name, protocol)) {
535 error_setg(errp, "Unknown protocol '%s'", protocol);
540 * Guess image format by probing its contents.
541 * This is not a good idea when your image is raw (CVE-2008-2004), but
542 * we do it anyway for backward compatibility.
544 * @buf contains the image's first @buf_size bytes.
545 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
546 * but can be smaller if the image file is smaller)
547 * @filename is its filename.
549 * For all block drivers, call the bdrv_probe() method to get its
551 * Return the first block driver with the highest probing score.
553 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
554 const char *filename)
556 int score_max = 0, score;
557 BlockDriver *drv = NULL, *d;
559 QLIST_FOREACH(d, &bdrv_drivers, list) {
561 score = d->bdrv_probe(buf, buf_size, filename);
562 if (score > score_max) {
572 static int find_image_format(BlockDriverState *bs, const char *filename,
573 BlockDriver **pdrv, Error **errp)
576 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
579 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
580 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
585 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
587 error_setg_errno(errp, -ret, "Could not read image for determining its "
593 drv = bdrv_probe_all(buf, ret, filename);
595 error_setg(errp, "Could not determine image format: No compatible "
604 * Set the current 'total_sectors' value
605 * Return 0 on success, -errno on error.
607 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
609 BlockDriver *drv = bs->drv;
611 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
615 /* query actual device if possible, otherwise just trust the hint */
616 if (drv->bdrv_getlength) {
617 int64_t length = drv->bdrv_getlength(bs);
621 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
624 bs->total_sectors = hint;
629 * Set open flags for a given discard mode
631 * Return 0 on success, -1 if the discard mode was invalid.
633 int bdrv_parse_discard_flags(const char *mode, int *flags)
635 *flags &= ~BDRV_O_UNMAP;
637 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
639 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
640 *flags |= BDRV_O_UNMAP;
649 * Set open flags for a given cache mode
651 * Return 0 on success, -1 if the cache mode was invalid.
653 int bdrv_parse_cache_flags(const char *mode, int *flags)
655 *flags &= ~BDRV_O_CACHE_MASK;
657 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
658 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
659 } else if (!strcmp(mode, "directsync")) {
660 *flags |= BDRV_O_NOCACHE;
661 } else if (!strcmp(mode, "writeback")) {
662 *flags |= BDRV_O_CACHE_WB;
663 } else if (!strcmp(mode, "unsafe")) {
664 *flags |= BDRV_O_CACHE_WB;
665 *flags |= BDRV_O_NO_FLUSH;
666 } else if (!strcmp(mode, "writethrough")) {
667 /* this is the default */
676 * Returns the flags that a temporary snapshot should get, based on the
677 * originally requested flags (the originally requested image will have flags
678 * like a backing file)
680 static int bdrv_temp_snapshot_flags(int flags)
682 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
686 * Returns the flags that bs->file should get if a protocol driver is expected,
687 * based on the given flags for the parent BDS
689 static int bdrv_inherited_flags(int flags)
691 /* Enable protocol handling, disable format probing for bs->file */
692 flags |= BDRV_O_PROTOCOL;
694 /* Our block drivers take care to send flushes and respect unmap policy,
695 * so we can enable both unconditionally on lower layers. */
696 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
698 /* Clear flags that only apply to the top layer */
699 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
704 const BdrvChildRole child_file = {
705 .inherit_flags = bdrv_inherited_flags,
709 * Returns the flags that bs->file should get if the use of formats (and not
710 * only protocols) is permitted for it, based on the given flags for the parent
713 static int bdrv_inherited_fmt_flags(int parent_flags)
715 int flags = child_file.inherit_flags(parent_flags);
716 return flags & ~BDRV_O_PROTOCOL;
719 const BdrvChildRole child_format = {
720 .inherit_flags = bdrv_inherited_fmt_flags,
724 * Returns the flags that bs->backing should get, based on the given flags
727 static int bdrv_backing_flags(int flags)
729 /* backing files always opened read-only */
730 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
732 /* snapshot=on is handled on the top layer */
733 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
738 static const BdrvChildRole child_backing = {
739 .inherit_flags = bdrv_backing_flags,
742 static int bdrv_open_flags(BlockDriverState *bs, int flags)
744 int open_flags = flags | BDRV_O_CACHE_WB;
747 * Clear flags that are internal to the block layer before opening the
750 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
753 * Snapshots should be writable.
755 if (flags & BDRV_O_TEMPORARY) {
756 open_flags |= BDRV_O_RDWR;
762 static void bdrv_assign_node_name(BlockDriverState *bs,
763 const char *node_name,
770 /* Check for empty string or invalid characters */
771 if (!id_wellformed(node_name)) {
772 error_setg(errp, "Invalid node name");
776 /* takes care of avoiding namespaces collisions */
777 if (blk_by_name(node_name)) {
778 error_setg(errp, "node-name=%s is conflicting with a device id",
783 /* takes care of avoiding duplicates node names */
784 if (bdrv_find_node(node_name)) {
785 error_setg(errp, "Duplicate node name");
789 /* copy node name into the bs and insert it into the graph list */
790 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
791 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
794 static QemuOptsList bdrv_runtime_opts = {
795 .name = "bdrv_common",
796 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
800 .type = QEMU_OPT_STRING,
801 .help = "Node name of the block device node",
803 { /* end of list */ }
808 * Common part for opening disk images and files
810 * Removes all processed options from *options.
812 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
813 QDict *options, int flags, BlockDriver *drv, Error **errp)
816 const char *filename;
817 const char *node_name = NULL;
819 Error *local_err = NULL;
822 assert(bs->file == NULL);
823 assert(options != NULL && bs->options != options);
826 filename = file->bs->filename;
828 filename = qdict_get_try_str(options, "filename");
831 if (drv->bdrv_needs_filename && !filename) {
832 error_setg(errp, "The '%s' block driver requires a file name",
837 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
839 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
840 qemu_opts_absorb_qdict(opts, options, &local_err);
842 error_propagate(errp, local_err);
847 node_name = qemu_opt_get(opts, "node-name");
848 bdrv_assign_node_name(bs, node_name, &local_err);
850 error_propagate(errp, local_err);
855 bs->guest_block_size = 512;
856 bs->request_alignment = 512;
857 bs->zero_beyond_eof = true;
858 open_flags = bdrv_open_flags(bs, flags);
859 bs->read_only = !(open_flags & BDRV_O_RDWR);
861 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
863 !bs->read_only && bdrv_is_whitelisted(drv, true)
864 ? "Driver '%s' can only be used for read-only devices"
865 : "Driver '%s' is not whitelisted",
871 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
872 if (flags & BDRV_O_COPY_ON_READ) {
873 if (!bs->read_only) {
874 bdrv_enable_copy_on_read(bs);
876 error_setg(errp, "Can't use copy-on-read on read-only device");
882 if (filename != NULL) {
883 pstrcpy(bs->filename, sizeof(bs->filename), filename);
885 bs->filename[0] = '\0';
887 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
890 bs->opaque = g_malloc0(drv->instance_size);
892 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
894 /* Open the image, either directly or using a protocol */
895 if (drv->bdrv_file_open) {
896 assert(file == NULL);
897 assert(!drv->bdrv_needs_filename || filename != NULL);
898 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
901 error_setg(errp, "Can't use '%s' as a block driver for the "
902 "protocol level", drv->format_name);
907 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
912 error_propagate(errp, local_err);
913 } else if (bs->filename[0]) {
914 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
916 error_setg_errno(errp, -ret, "Could not open image");
922 error_report("Encrypted images are deprecated");
923 error_printf("Support for them will be removed in a future release.\n"
924 "You can use 'qemu-img convert' to convert your image"
925 " to an unencrypted one.\n");
928 ret = refresh_total_sectors(bs, bs->total_sectors);
930 error_setg_errno(errp, -ret, "Could not refresh total sector count");
934 bdrv_refresh_limits(bs, &local_err);
936 error_propagate(errp, local_err);
941 assert(bdrv_opt_mem_align(bs) != 0);
942 assert(bdrv_min_mem_align(bs) != 0);
943 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
958 static QDict *parse_json_filename(const char *filename, Error **errp)
960 QObject *options_obj;
964 ret = strstart(filename, "json:", &filename);
967 options_obj = qobject_from_json(filename);
969 error_setg(errp, "Could not parse the JSON options");
973 if (qobject_type(options_obj) != QTYPE_QDICT) {
974 qobject_decref(options_obj);
975 error_setg(errp, "Invalid JSON object given");
979 options = qobject_to_qdict(options_obj);
980 qdict_flatten(options);
986 * Fills in default options for opening images and converts the legacy
987 * filename/flags pair to option QDict entries.
988 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
989 * block driver has been specified explicitly.
991 static int bdrv_fill_options(QDict **options, const char **pfilename,
992 int *flags, Error **errp)
994 const char *filename = *pfilename;
996 bool protocol = *flags & BDRV_O_PROTOCOL;
997 bool parse_filename = false;
998 BlockDriver *drv = NULL;
999 Error *local_err = NULL;
1001 /* Parse json: pseudo-protocol */
1002 if (filename && g_str_has_prefix(filename, "json:")) {
1003 QDict *json_options = parse_json_filename(filename, &local_err);
1005 error_propagate(errp, local_err);
1009 /* Options given in the filename have lower priority than options
1010 * specified directly */
1011 qdict_join(*options, json_options, false);
1012 QDECREF(json_options);
1013 *pfilename = filename = NULL;
1016 drvname = qdict_get_try_str(*options, "driver");
1018 drv = bdrv_find_format(drvname);
1020 error_setg(errp, "Unknown driver '%s'", drvname);
1023 /* If the user has explicitly specified the driver, this choice should
1024 * override the BDRV_O_PROTOCOL flag */
1025 protocol = drv->bdrv_file_open;
1029 *flags |= BDRV_O_PROTOCOL;
1031 *flags &= ~BDRV_O_PROTOCOL;
1034 /* Fetch the file name from the options QDict if necessary */
1035 if (protocol && filename) {
1036 if (!qdict_haskey(*options, "filename")) {
1037 qdict_put(*options, "filename", qstring_from_str(filename));
1038 parse_filename = true;
1040 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1046 /* Find the right block driver */
1047 filename = qdict_get_try_str(*options, "filename");
1049 if (!drvname && protocol) {
1051 drv = bdrv_find_protocol(filename, parse_filename, errp);
1056 drvname = drv->format_name;
1057 qdict_put(*options, "driver", qstring_from_str(drvname));
1059 error_setg(errp, "Must specify either driver or file");
1064 assert(drv || !protocol);
1066 /* Driver-specific filename parsing */
1067 if (drv && drv->bdrv_parse_filename && parse_filename) {
1068 drv->bdrv_parse_filename(filename, *options, &local_err);
1070 error_propagate(errp, local_err);
1074 if (!drv->bdrv_needs_filename) {
1075 qdict_del(*options, "filename");
1082 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1083 BlockDriverState *child_bs,
1084 const BdrvChildRole *child_role)
1086 BdrvChild *child = g_new(BdrvChild, 1);
1087 *child = (BdrvChild) {
1092 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1093 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1098 static void bdrv_detach_child(BdrvChild *child)
1100 QLIST_REMOVE(child, next);
1101 QLIST_REMOVE(child, next_parent);
1105 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1107 BlockDriverState *child_bs = child->bs;
1109 if (child->bs->inherits_from == parent) {
1110 child->bs->inherits_from = NULL;
1113 bdrv_detach_child(child);
1114 bdrv_unref(child_bs);
1118 * Sets the backing file link of a BDS. A new reference is created; callers
1119 * which don't need their own reference any more must call bdrv_unref().
1121 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1124 bdrv_ref(backing_hd);
1128 assert(bs->backing_blocker);
1129 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1130 bdrv_unref_child(bs, bs->backing);
1131 } else if (backing_hd) {
1132 error_setg(&bs->backing_blocker,
1133 "node is used as backing hd of '%s'",
1134 bdrv_get_device_or_node_name(bs));
1138 error_free(bs->backing_blocker);
1139 bs->backing_blocker = NULL;
1143 bs->backing = bdrv_attach_child(bs, backing_hd, &child_backing);
1144 bs->open_flags &= ~BDRV_O_NO_BACKING;
1145 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1146 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1147 backing_hd->drv ? backing_hd->drv->format_name : "");
1149 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1150 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1151 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1152 bs->backing_blocker);
1154 bdrv_refresh_limits(bs, NULL);
1158 * Opens the backing file for a BlockDriverState if not yet open
1160 * options is a QDict of options to pass to the block drivers, or NULL for an
1161 * empty set of options. The reference to the QDict is transferred to this
1162 * function (even on failure), so if the caller intends to reuse the dictionary,
1163 * it needs to use QINCREF() before calling bdrv_file_open.
1165 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1167 char *backing_filename = g_malloc0(PATH_MAX);
1169 BlockDriverState *backing_hd;
1170 Error *local_err = NULL;
1172 if (bs->backing != NULL) {
1177 /* NULL means an empty set of options */
1178 if (options == NULL) {
1179 options = qdict_new();
1182 bs->open_flags &= ~BDRV_O_NO_BACKING;
1183 if (qdict_haskey(options, "file.filename")) {
1184 backing_filename[0] = '\0';
1185 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1189 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1193 error_propagate(errp, local_err);
1199 if (!bs->drv || !bs->drv->supports_backing) {
1201 error_setg(errp, "Driver doesn't support backing files");
1206 backing_hd = bdrv_new();
1208 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1209 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1212 assert(bs->backing == NULL);
1213 ret = bdrv_open_inherit(&backing_hd,
1214 *backing_filename ? backing_filename : NULL,
1215 NULL, options, 0, bs, &child_backing, &local_err);
1217 bdrv_unref(backing_hd);
1219 bs->open_flags |= BDRV_O_NO_BACKING;
1220 error_setg(errp, "Could not open backing file: %s",
1221 error_get_pretty(local_err));
1222 error_free(local_err);
1226 /* Hook up the backing file link; drop our reference, bs owns the
1227 * backing_hd reference now */
1228 bdrv_set_backing_hd(bs, backing_hd);
1229 bdrv_unref(backing_hd);
1232 g_free(backing_filename);
1237 * Opens a disk image whose options are given as BlockdevRef in another block
1240 * If allow_none is true, no image will be opened if filename is false and no
1241 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1243 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1244 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1245 * itself, all options starting with "${bdref_key}." are considered part of the
1248 * The BlockdevRef will be removed from the options QDict.
1250 BdrvChild *bdrv_open_child(const char *filename,
1251 QDict *options, const char *bdref_key,
1252 BlockDriverState* parent,
1253 const BdrvChildRole *child_role,
1254 bool allow_none, Error **errp)
1256 BdrvChild *c = NULL;
1257 BlockDriverState *bs;
1258 QDict *image_options;
1260 char *bdref_key_dot;
1261 const char *reference;
1263 assert(child_role != NULL);
1265 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1266 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1267 g_free(bdref_key_dot);
1269 reference = qdict_get_try_str(options, bdref_key);
1270 if (!filename && !reference && !qdict_size(image_options)) {
1272 error_setg(errp, "A block device must be specified for \"%s\"",
1275 QDECREF(image_options);
1280 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1281 parent, child_role, errp);
1286 c = bdrv_attach_child(parent, bs, child_role);
1289 qdict_del(options, bdref_key);
1293 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1295 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1296 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1298 QemuOpts *opts = NULL;
1299 QDict *snapshot_options;
1300 BlockDriverState *bs_snapshot;
1301 Error *local_err = NULL;
1304 /* if snapshot, we create a temporary backing file and open it
1305 instead of opening 'filename' directly */
1307 /* Get the required size from the image */
1308 total_size = bdrv_getlength(bs);
1309 if (total_size < 0) {
1311 error_setg_errno(errp, -total_size, "Could not get image size");
1315 /* Create the temporary image */
1316 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1318 error_setg_errno(errp, -ret, "Could not get temporary filename");
1322 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1324 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1325 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1326 qemu_opts_del(opts);
1328 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1329 "'%s': %s", tmp_filename,
1330 error_get_pretty(local_err));
1331 error_free(local_err);
1335 /* Prepare a new options QDict for the temporary file */
1336 snapshot_options = qdict_new();
1337 qdict_put(snapshot_options, "file.driver",
1338 qstring_from_str("file"));
1339 qdict_put(snapshot_options, "file.filename",
1340 qstring_from_str(tmp_filename));
1341 qdict_put(snapshot_options, "driver",
1342 qstring_from_str("qcow2"));
1344 bs_snapshot = bdrv_new();
1346 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1349 error_propagate(errp, local_err);
1353 bdrv_append(bs_snapshot, bs);
1356 g_free(tmp_filename);
1361 * Opens a disk image (raw, qcow2, vmdk, ...)
1363 * options is a QDict of options to pass to the block drivers, or NULL for an
1364 * empty set of options. The reference to the QDict belongs to the block layer
1365 * after the call (even on failure), so if the caller intends to reuse the
1366 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1368 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1369 * If it is not NULL, the referenced BDS will be reused.
1371 * The reference parameter may be used to specify an existing block device which
1372 * should be opened. If specified, neither options nor a filename may be given,
1373 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1375 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1376 const char *reference, QDict *options, int flags,
1377 BlockDriverState *parent,
1378 const BdrvChildRole *child_role, Error **errp)
1381 BdrvChild *file = NULL;
1382 BlockDriverState *bs;
1383 BlockDriver *drv = NULL;
1384 const char *drvname;
1385 Error *local_err = NULL;
1386 int snapshot_flags = 0;
1389 assert(!child_role || !flags);
1390 assert(!child_role == !parent);
1393 bool options_non_empty = options ? qdict_size(options) : false;
1397 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1398 "another block device");
1402 if (filename || options_non_empty) {
1403 error_setg(errp, "Cannot reference an existing block device with "
1404 "additional options or a new filename");
1408 bs = bdrv_lookup_bs(reference, reference, errp);
1423 /* NULL means an empty set of options */
1424 if (options == NULL) {
1425 options = qdict_new();
1429 bs->inherits_from = parent;
1430 flags = child_role->inherit_flags(parent->open_flags);
1433 ret = bdrv_fill_options(&options, &filename, &flags, &local_err);
1438 /* Find the right image format driver */
1439 drvname = qdict_get_try_str(options, "driver");
1441 drv = bdrv_find_format(drvname);
1442 qdict_del(options, "driver");
1444 error_setg(errp, "Unknown driver: '%s'", drvname);
1450 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1452 bs->open_flags = flags;
1453 bs->options = options;
1454 options = qdict_clone_shallow(options);
1456 /* Open image file without format layer */
1457 if ((flags & BDRV_O_PROTOCOL) == 0) {
1458 if (flags & BDRV_O_RDWR) {
1459 flags |= BDRV_O_ALLOW_RDWR;
1461 if (flags & BDRV_O_SNAPSHOT) {
1462 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1463 flags = bdrv_backing_flags(flags);
1466 bs->open_flags = flags;
1468 file = bdrv_open_child(filename, options, "file", bs,
1469 &child_file, true, &local_err);
1476 /* Image format probing */
1479 ret = find_image_format(file->bs, filename, &drv, &local_err);
1484 error_setg(errp, "Must specify either driver or file");
1489 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1490 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1491 /* file must be NULL if a protocol BDS is about to be created
1492 * (the inverse results in an error message from bdrv_open_common()) */
1493 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1495 /* Open the image */
1496 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1501 if (file && (bs->file != file)) {
1502 bdrv_unref_child(bs, file);
1506 /* If there is a backing file, use it */
1507 if ((flags & BDRV_O_NO_BACKING) == 0) {
1508 QDict *backing_options;
1510 qdict_extract_subqdict(options, &backing_options, "backing.");
1511 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1513 goto close_and_fail;
1517 bdrv_refresh_filename(bs);
1519 /* Check if any unknown options were used */
1520 if (options && (qdict_size(options) != 0)) {
1521 const QDictEntry *entry = qdict_first(options);
1522 if (flags & BDRV_O_PROTOCOL) {
1523 error_setg(errp, "Block protocol '%s' doesn't support the option "
1524 "'%s'", drv->format_name, entry->key);
1526 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1527 "support the option '%s'", drv->format_name,
1528 bdrv_get_device_name(bs), entry->key);
1532 goto close_and_fail;
1535 if (!bdrv_key_required(bs)) {
1537 blk_dev_change_media_cb(bs->blk, true);
1539 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1540 && !runstate_check(RUN_STATE_INMIGRATE)
1541 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1543 "Guest must be stopped for opening of encrypted image");
1545 goto close_and_fail;
1551 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1552 * temporary snapshot afterwards. */
1553 if (snapshot_flags) {
1554 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1556 goto close_and_fail;
1564 bdrv_unref_child(bs, file);
1566 QDECREF(bs->options);
1570 /* If *pbs is NULL, a new BDS has been created in this function and
1571 needs to be freed now. Otherwise, it does not need to be closed,
1572 since it has not really been opened yet. */
1576 error_propagate(errp, local_err);
1581 /* See fail path, but now the BDS has to be always closed */
1589 error_propagate(errp, local_err);
1594 int bdrv_open(BlockDriverState **pbs, const char *filename,
1595 const char *reference, QDict *options, int flags, Error **errp)
1597 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1601 typedef struct BlockReopenQueueEntry {
1603 BDRVReopenState state;
1604 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1605 } BlockReopenQueueEntry;
1608 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1609 * reopen of multiple devices.
1611 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1612 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1613 * be created and initialized. This newly created BlockReopenQueue should be
1614 * passed back in for subsequent calls that are intended to be of the same
1617 * bs is the BlockDriverState to add to the reopen queue.
1619 * options contains the changed options for the associated bs
1620 * (the BlockReopenQueue takes ownership)
1622 * flags contains the open flags for the associated bs
1624 * returns a pointer to bs_queue, which is either the newly allocated
1625 * bs_queue, or the existing bs_queue being used.
1628 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1629 BlockDriverState *bs,
1630 QDict *options, int flags)
1634 BlockReopenQueueEntry *bs_entry;
1638 if (bs_queue == NULL) {
1639 bs_queue = g_new0(BlockReopenQueue, 1);
1640 QSIMPLEQ_INIT(bs_queue);
1644 options = qdict_new();
1647 old_options = qdict_clone_shallow(bs->options);
1648 qdict_join(options, old_options, false);
1649 QDECREF(old_options);
1651 /* bdrv_open() masks this flag out */
1652 flags &= ~BDRV_O_PROTOCOL;
1654 QLIST_FOREACH(child, &bs->children, next) {
1657 if (child->bs->inherits_from != bs) {
1661 child_flags = child->role->inherit_flags(flags);
1662 /* TODO Pass down child flags (backing.*, extents.*, ...) */
1663 bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
1666 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1667 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1669 bs_entry->state.bs = bs;
1670 bs_entry->state.options = options;
1671 bs_entry->state.flags = flags;
1677 * Reopen multiple BlockDriverStates atomically & transactionally.
1679 * The queue passed in (bs_queue) must have been built up previous
1680 * via bdrv_reopen_queue().
1682 * Reopens all BDS specified in the queue, with the appropriate
1683 * flags. All devices are prepared for reopen, and failure of any
1684 * device will cause all device changes to be abandonded, and intermediate
1687 * If all devices prepare successfully, then the changes are committed
1691 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1694 BlockReopenQueueEntry *bs_entry, *next;
1695 Error *local_err = NULL;
1697 assert(bs_queue != NULL);
1701 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1702 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1703 error_propagate(errp, local_err);
1706 bs_entry->prepared = true;
1709 /* If we reach this point, we have success and just need to apply the
1712 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1713 bdrv_reopen_commit(&bs_entry->state);
1719 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1720 if (ret && bs_entry->prepared) {
1721 bdrv_reopen_abort(&bs_entry->state);
1723 QDECREF(bs_entry->state.options);
1731 /* Reopen a single BlockDriverState with the specified flags. */
1732 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1735 Error *local_err = NULL;
1736 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1738 ret = bdrv_reopen_multiple(queue, &local_err);
1739 if (local_err != NULL) {
1740 error_propagate(errp, local_err);
1747 * Prepares a BlockDriverState for reopen. All changes are staged in the
1748 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1749 * the block driver layer .bdrv_reopen_prepare()
1751 * bs is the BlockDriverState to reopen
1752 * flags are the new open flags
1753 * queue is the reopen queue
1755 * Returns 0 on success, non-zero on error. On error errp will be set
1758 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1759 * It is the responsibility of the caller to then call the abort() or
1760 * commit() for any other BDS that have been left in a prepare() state
1763 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1767 Error *local_err = NULL;
1770 assert(reopen_state != NULL);
1771 assert(reopen_state->bs->drv != NULL);
1772 drv = reopen_state->bs->drv;
1774 /* if we are to stay read-only, do not allow permission change
1776 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1777 reopen_state->flags & BDRV_O_RDWR) {
1778 error_setg(errp, "Node '%s' is read only",
1779 bdrv_get_device_or_node_name(reopen_state->bs));
1784 ret = bdrv_flush(reopen_state->bs);
1786 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1791 if (drv->bdrv_reopen_prepare) {
1792 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1794 if (local_err != NULL) {
1795 error_propagate(errp, local_err);
1797 error_setg(errp, "failed while preparing to reopen image '%s'",
1798 reopen_state->bs->filename);
1803 /* It is currently mandatory to have a bdrv_reopen_prepare()
1804 * handler for each supported drv. */
1805 error_setg(errp, "Block format '%s' used by node '%s' "
1806 "does not support reopening files", drv->format_name,
1807 bdrv_get_device_or_node_name(reopen_state->bs));
1812 /* Options that are not handled are only okay if they are unchanged
1813 * compared to the old state. It is expected that some options are only
1814 * used for the initial open, but not reopen (e.g. filename) */
1815 if (qdict_size(reopen_state->options)) {
1816 const QDictEntry *entry = qdict_first(reopen_state->options);
1819 QString *new_obj = qobject_to_qstring(entry->value);
1820 const char *new = qstring_get_str(new_obj);
1821 const char *old = qdict_get_try_str(reopen_state->bs->options,
1824 if (!old || strcmp(new, old)) {
1825 error_setg(errp, "Cannot change the option '%s'", entry->key);
1829 } while ((entry = qdict_next(reopen_state->options, entry)));
1839 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1840 * makes them final by swapping the staging BlockDriverState contents into
1841 * the active BlockDriverState contents.
1843 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1847 assert(reopen_state != NULL);
1848 drv = reopen_state->bs->drv;
1849 assert(drv != NULL);
1851 /* If there are any driver level actions to take */
1852 if (drv->bdrv_reopen_commit) {
1853 drv->bdrv_reopen_commit(reopen_state);
1856 /* set BDS specific flags now */
1857 reopen_state->bs->open_flags = reopen_state->flags;
1858 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1860 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1862 bdrv_refresh_limits(reopen_state->bs, NULL);
1866 * Abort the reopen, and delete and free the staged changes in
1869 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1873 assert(reopen_state != NULL);
1874 drv = reopen_state->bs->drv;
1875 assert(drv != NULL);
1877 if (drv->bdrv_reopen_abort) {
1878 drv->bdrv_reopen_abort(reopen_state);
1883 void bdrv_close(BlockDriverState *bs)
1885 BdrvAioNotifier *ban, *ban_next;
1888 block_job_cancel_sync(bs->job);
1891 /* Disable I/O limits and drain all pending throttled requests */
1892 if (bs->io_limits_enabled) {
1893 bdrv_io_limits_disable(bs);
1896 bdrv_drain(bs); /* complete I/O */
1898 bdrv_drain(bs); /* in case flush left pending I/O */
1899 notifier_list_notify(&bs->close_notifiers, bs);
1902 BdrvChild *child, *next;
1904 bs->drv->bdrv_close(bs);
1907 bdrv_set_backing_hd(bs, NULL);
1909 if (bs->file != NULL) {
1910 bdrv_unref_child(bs, bs->file);
1914 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1915 /* TODO Remove bdrv_unref() from drivers' close function and use
1916 * bdrv_unref_child() here */
1917 if (child->bs->inherits_from == bs) {
1918 child->bs->inherits_from = NULL;
1920 bdrv_detach_child(child);
1925 bs->copy_on_read = 0;
1926 bs->backing_file[0] = '\0';
1927 bs->backing_format[0] = '\0';
1928 bs->total_sectors = 0;
1932 bs->zero_beyond_eof = false;
1933 QDECREF(bs->options);
1935 QDECREF(bs->full_open_options);
1936 bs->full_open_options = NULL;
1940 blk_dev_change_media_cb(bs->blk, false);
1943 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1946 QLIST_INIT(&bs->aio_notifiers);
1949 void bdrv_close_all(void)
1951 BlockDriverState *bs;
1953 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1954 AioContext *aio_context = bdrv_get_aio_context(bs);
1956 aio_context_acquire(aio_context);
1958 aio_context_release(aio_context);
1962 /* make a BlockDriverState anonymous by removing from bdrv_state and
1963 * graph_bdrv_state list.
1964 Also, NULL terminate the device_name to prevent double remove */
1965 void bdrv_make_anon(BlockDriverState *bs)
1968 * Take care to remove bs from bdrv_states only when it's actually
1969 * in it. Note that bs->device_list.tqe_prev is initially null,
1970 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1971 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1972 * resetting it to null on remove.
1974 if (bs->device_list.tqe_prev) {
1975 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1976 bs->device_list.tqe_prev = NULL;
1978 if (bs->node_name[0] != '\0') {
1979 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1981 bs->node_name[0] = '\0';
1984 static void bdrv_rebind(BlockDriverState *bs)
1986 if (bs->drv && bs->drv->bdrv_rebind) {
1987 bs->drv->bdrv_rebind(bs);
1991 /* Fields that need to stay with the top-level BDS, no matter whether the
1992 * address of the top-level BDS stays the same or not. */
1993 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1994 BlockDriverState *bs_src)
1996 /* move some fields that need to stay attached to the device */
1999 bs_dest->guest_block_size = bs_src->guest_block_size;
2000 bs_dest->copy_on_read = bs_src->copy_on_read;
2002 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2005 bs_dest->on_read_error = bs_src->on_read_error;
2006 bs_dest->on_write_error = bs_src->on_write_error;
2009 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
2010 bs_dest->iostatus = bs_src->iostatus;
2013 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2016 /* Fields that only need to be swapped if the contents of BDSes is swapped
2017 * rather than pointers being changed in the parents, and throttling fields
2018 * because only bdrv_swap() messes with internals of throttling. */
2019 static void bdrv_move_reference_fields(BlockDriverState *bs_dest,
2020 BlockDriverState *bs_src)
2022 /* i/o throttled req */
2023 bs_dest->throttle_state = bs_src->throttle_state,
2024 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
2025 bs_dest->pending_reqs[0] = bs_src->pending_reqs[0];
2026 bs_dest->pending_reqs[1] = bs_src->pending_reqs[1];
2027 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
2028 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
2029 memcpy(&bs_dest->round_robin,
2030 &bs_src->round_robin,
2031 sizeof(bs_dest->round_robin));
2032 memcpy(&bs_dest->throttle_timers,
2033 &bs_src->throttle_timers,
2034 sizeof(ThrottleTimers));
2036 /* reference count */
2037 bs_dest->refcnt = bs_src->refcnt;
2040 bs_dest->job = bs_src->job;
2042 /* keep the same entry in bdrv_states */
2043 bs_dest->device_list = bs_src->device_list;
2044 bs_dest->blk = bs_src->blk;
2045 bs_dest->parents = bs_src->parents;
2047 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2048 sizeof(bs_dest->op_blockers));
2052 * Swap bs contents for two image chains while they are live,
2053 * while keeping required fields on the BlockDriverState that is
2054 * actually attached to a device.
2056 * This will modify the BlockDriverState fields, and swap contents
2057 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2059 * bs_new must not be attached to a BlockBackend.
2061 * This function does not create any image files.
2063 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2065 BlockDriverState tmp;
2071 /* The code needs to swap the node_name but simply swapping node_list won't
2072 * work so first remove the nodes from the graph list, do the swap then
2073 * insert them back if needed.
2075 if (bs_new->node_name[0] != '\0') {
2076 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2078 if (bs_old->node_name[0] != '\0') {
2079 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2082 /* If the BlockDriverState is part of a throttling group acquire
2083 * its lock since we're going to mess with the protected fields.
2084 * Otherwise there's no need to worry since no one else can touch
2086 if (bs_old->throttle_state) {
2087 throttle_group_lock(bs_old);
2090 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2091 assert(!bs_new->blk);
2092 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2093 assert(bs_new->job == NULL);
2094 assert(bs_new->io_limits_enabled == false);
2095 assert(bs_new->throttle_state == NULL);
2096 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2102 /* there are some fields that should not be swapped, move them back */
2103 bdrv_move_feature_fields(&tmp, bs_old);
2104 bdrv_move_feature_fields(bs_old, bs_new);
2105 bdrv_move_feature_fields(bs_new, &tmp);
2107 bdrv_move_reference_fields(&tmp, bs_old);
2108 bdrv_move_reference_fields(bs_old, bs_new);
2109 bdrv_move_reference_fields(bs_new, &tmp);
2111 /* bs_new must remain unattached */
2112 assert(!bs_new->blk);
2114 /* Check a few fields that should remain attached to the device */
2115 assert(bs_new->job == NULL);
2116 assert(bs_new->io_limits_enabled == false);
2117 assert(bs_new->throttle_state == NULL);
2118 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2120 /* Release the ThrottleGroup lock */
2121 if (bs_old->throttle_state) {
2122 throttle_group_unlock(bs_old);
2125 /* insert the nodes back into the graph node list if needed */
2126 if (bs_new->node_name[0] != '\0') {
2127 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2129 if (bs_old->node_name[0] != '\0') {
2130 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2134 * Update lh_first.le_prev for non-empty lists.
2136 * The head of the op blocker list doesn't change because it is moved back
2137 * in bdrv_move_feature_fields().
2139 assert(QLIST_EMPTY(&bs_old->tracked_requests));
2140 assert(QLIST_EMPTY(&bs_new->tracked_requests));
2142 QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2143 QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2145 /* Update references in bs->opaque and children */
2146 QLIST_FOREACH(child, &bs_old->children, next) {
2147 if (child->bs->inherits_from == bs_new) {
2148 child->bs->inherits_from = bs_old;
2151 QLIST_FOREACH(child, &bs_new->children, next) {
2152 if (child->bs->inherits_from == bs_old) {
2153 child->bs->inherits_from = bs_new;
2157 bdrv_rebind(bs_new);
2158 bdrv_rebind(bs_old);
2161 static void change_parent_backing_link(BlockDriverState *from,
2162 BlockDriverState *to)
2164 BdrvChild *c, *next;
2166 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2167 assert(c->role != &child_backing);
2169 QLIST_REMOVE(c, next_parent);
2170 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2175 blk_set_bs(from->blk, to);
2176 if (!to->device_list.tqe_prev) {
2177 QTAILQ_INSERT_BEFORE(from, to, device_list);
2179 QTAILQ_REMOVE(&bdrv_states, from, device_list);
2183 static void swap_feature_fields(BlockDriverState *bs_top,
2184 BlockDriverState *bs_new)
2186 BlockDriverState tmp;
2188 bdrv_move_feature_fields(&tmp, bs_top);
2189 bdrv_move_feature_fields(bs_top, bs_new);
2190 bdrv_move_feature_fields(bs_new, &tmp);
2192 assert(!bs_new->throttle_state);
2193 if (bs_top->throttle_state) {
2194 assert(bs_top->io_limits_enabled);
2195 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2196 bdrv_io_limits_disable(bs_top);
2201 * Add new bs contents at the top of an image chain while the chain is
2202 * live, while keeping required fields on the top layer.
2204 * This will modify the BlockDriverState fields, and swap contents
2205 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2207 * bs_new must not be attached to a BlockBackend.
2209 * This function does not create any image files.
2211 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2212 * that's what the callers commonly need. bs_new will be referenced by the old
2213 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2214 * reference of its own, it must call bdrv_ref().
2216 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2218 assert(!bdrv_requests_pending(bs_top));
2219 assert(!bdrv_requests_pending(bs_new));
2222 change_parent_backing_link(bs_top, bs_new);
2224 /* Some fields always stay on top of the backing file chain */
2225 swap_feature_fields(bs_top, bs_new);
2227 bdrv_set_backing_hd(bs_new, bs_top);
2230 /* bs_new is now referenced by its new parents, we don't need the
2231 * additional reference any more. */
2235 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2237 assert(!bdrv_requests_pending(old));
2238 assert(!bdrv_requests_pending(new));
2243 /* As long as these fields aren't in BlockBackend, but in the top-level
2244 * BlockDriverState, it's not possible for a BDS to have two BBs.
2246 * We really want to copy the fields from old to new, but we go for a
2247 * swap instead so that pointers aren't duplicated and cause trouble.
2248 * (Also, bdrv_swap() used to do the same.) */
2250 swap_feature_fields(old, new);
2252 change_parent_backing_link(old, new);
2254 /* Change backing files if a previously independent node is added to the
2255 * chain. For active commit, we replace top by its own (indirect) backing
2256 * file and don't do anything here so we don't build a loop. */
2257 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2258 bdrv_set_backing_hd(new, backing_bs(old));
2259 bdrv_set_backing_hd(old, NULL);
2265 static void bdrv_delete(BlockDriverState *bs)
2268 assert(bdrv_op_blocker_is_empty(bs));
2269 assert(!bs->refcnt);
2270 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2274 /* remove from list, if necessary */
2281 * Run consistency checks on an image
2283 * Returns 0 if the check could be completed (it doesn't mean that the image is
2284 * free of errors) or -errno when an internal error occurred. The results of the
2285 * check are stored in res.
2287 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2289 if (bs->drv == NULL) {
2292 if (bs->drv->bdrv_check == NULL) {
2296 memset(res, 0, sizeof(*res));
2297 return bs->drv->bdrv_check(bs, res, fix);
2300 #define COMMIT_BUF_SECTORS 2048
2302 /* commit COW file into the raw image */
2303 int bdrv_commit(BlockDriverState *bs)
2305 BlockDriver *drv = bs->drv;
2306 int64_t sector, total_sectors, length, backing_length;
2307 int n, ro, open_flags;
2309 uint8_t *buf = NULL;
2318 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2319 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2323 ro = bs->backing->bs->read_only;
2324 open_flags = bs->backing->bs->open_flags;
2327 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2332 length = bdrv_getlength(bs);
2338 backing_length = bdrv_getlength(bs->backing->bs);
2339 if (backing_length < 0) {
2340 ret = backing_length;
2344 /* If our top snapshot is larger than the backing file image,
2345 * grow the backing file image if possible. If not possible,
2346 * we must return an error */
2347 if (length > backing_length) {
2348 ret = bdrv_truncate(bs->backing->bs, length);
2354 total_sectors = length >> BDRV_SECTOR_BITS;
2356 /* qemu_try_blockalign() for bs will choose an alignment that works for
2357 * bs->backing->bs as well, so no need to compare the alignment manually. */
2358 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2364 for (sector = 0; sector < total_sectors; sector += n) {
2365 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2370 ret = bdrv_read(bs, sector, buf, n);
2375 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2382 if (drv->bdrv_make_empty) {
2383 ret = drv->bdrv_make_empty(bs);
2391 * Make sure all data we wrote to the backing device is actually
2395 bdrv_flush(bs->backing->bs);
2403 /* ignoring error return here */
2404 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2410 int bdrv_commit_all(void)
2412 BlockDriverState *bs;
2414 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2415 AioContext *aio_context = bdrv_get_aio_context(bs);
2417 aio_context_acquire(aio_context);
2418 if (bs->drv && bs->backing) {
2419 int ret = bdrv_commit(bs);
2421 aio_context_release(aio_context);
2425 aio_context_release(aio_context);
2433 * -EINVAL - backing format specified, but no file
2434 * -ENOSPC - can't update the backing file because no space is left in the
2436 * -ENOTSUP - format driver doesn't support changing the backing file
2438 int bdrv_change_backing_file(BlockDriverState *bs,
2439 const char *backing_file, const char *backing_fmt)
2441 BlockDriver *drv = bs->drv;
2444 /* Backing file format doesn't make sense without a backing file */
2445 if (backing_fmt && !backing_file) {
2449 if (drv->bdrv_change_backing_file != NULL) {
2450 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2456 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2457 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2463 * Finds the image layer in the chain that has 'bs' as its backing file.
2465 * active is the current topmost image.
2467 * Returns NULL if bs is not found in active's image chain,
2468 * or if active == bs.
2470 * Returns the bottommost base image if bs == NULL.
2472 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2473 BlockDriverState *bs)
2475 while (active && bs != backing_bs(active)) {
2476 active = backing_bs(active);
2482 /* Given a BDS, searches for the base layer. */
2483 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2485 return bdrv_find_overlay(bs, NULL);
2489 * Drops images above 'base' up to and including 'top', and sets the image
2490 * above 'top' to have base as its backing file.
2492 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2493 * information in 'bs' can be properly updated.
2495 * E.g., this will convert the following chain:
2496 * bottom <- base <- intermediate <- top <- active
2500 * bottom <- base <- active
2502 * It is allowed for bottom==base, in which case it converts:
2504 * base <- intermediate <- top <- active
2510 * If backing_file_str is non-NULL, it will be used when modifying top's
2511 * overlay image metadata.
2514 * if active == top, that is considered an error
2517 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2518 BlockDriverState *base, const char *backing_file_str)
2520 BlockDriverState *new_top_bs = NULL;
2523 if (!top->drv || !base->drv) {
2527 new_top_bs = bdrv_find_overlay(active, top);
2529 if (new_top_bs == NULL) {
2530 /* we could not find the image above 'top', this is an error */
2534 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2535 * to do, no intermediate images */
2536 if (backing_bs(new_top_bs) == base) {
2541 /* Make sure that base is in the backing chain of top */
2542 if (!bdrv_chain_contains(top, base)) {
2546 /* success - we can delete the intermediate states, and link top->base */
2547 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2548 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2549 base->drv ? base->drv->format_name : "");
2553 bdrv_set_backing_hd(new_top_bs, base);
2561 * Truncate file to 'offset' bytes (needed only for file protocols)
2563 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2565 BlockDriver *drv = bs->drv;
2569 if (!drv->bdrv_truncate)
2574 ret = drv->bdrv_truncate(bs, offset);
2576 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2577 bdrv_dirty_bitmap_truncate(bs);
2579 blk_dev_resize_cb(bs->blk);
2586 * Length of a allocated file in bytes. Sparse files are counted by actual
2587 * allocated space. Return < 0 if error or unknown.
2589 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2591 BlockDriver *drv = bs->drv;
2595 if (drv->bdrv_get_allocated_file_size) {
2596 return drv->bdrv_get_allocated_file_size(bs);
2599 return bdrv_get_allocated_file_size(bs->file->bs);
2605 * Return number of sectors on success, -errno on error.
2607 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2609 BlockDriver *drv = bs->drv;
2614 if (drv->has_variable_length) {
2615 int ret = refresh_total_sectors(bs, bs->total_sectors);
2620 return bs->total_sectors;
2624 * Return length in bytes on success, -errno on error.
2625 * The length is always a multiple of BDRV_SECTOR_SIZE.
2627 int64_t bdrv_getlength(BlockDriverState *bs)
2629 int64_t ret = bdrv_nb_sectors(bs);
2631 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2632 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2635 /* return 0 as number of sectors if no device present or error */
2636 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2638 int64_t nb_sectors = bdrv_nb_sectors(bs);
2640 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2643 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2644 BlockdevOnError on_write_error)
2646 bs->on_read_error = on_read_error;
2647 bs->on_write_error = on_write_error;
2650 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2652 return is_read ? bs->on_read_error : bs->on_write_error;
2655 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2657 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2660 case BLOCKDEV_ON_ERROR_ENOSPC:
2661 return (error == ENOSPC) ?
2662 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2663 case BLOCKDEV_ON_ERROR_STOP:
2664 return BLOCK_ERROR_ACTION_STOP;
2665 case BLOCKDEV_ON_ERROR_REPORT:
2666 return BLOCK_ERROR_ACTION_REPORT;
2667 case BLOCKDEV_ON_ERROR_IGNORE:
2668 return BLOCK_ERROR_ACTION_IGNORE;
2674 static void send_qmp_error_event(BlockDriverState *bs,
2675 BlockErrorAction action,
2676 bool is_read, int error)
2678 IoOperationType optype;
2680 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2681 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2682 bdrv_iostatus_is_enabled(bs),
2683 error == ENOSPC, strerror(error),
2687 /* This is done by device models because, while the block layer knows
2688 * about the error, it does not know whether an operation comes from
2689 * the device or the block layer (from a job, for example).
2691 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2692 bool is_read, int error)
2696 if (action == BLOCK_ERROR_ACTION_STOP) {
2697 /* First set the iostatus, so that "info block" returns an iostatus
2698 * that matches the events raised so far (an additional error iostatus
2699 * is fine, but not a lost one).
2701 bdrv_iostatus_set_err(bs, error);
2703 /* Then raise the request to stop the VM and the event.
2704 * qemu_system_vmstop_request_prepare has two effects. First,
2705 * it ensures that the STOP event always comes after the
2706 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2707 * can observe the STOP event and do a "cont" before the STOP
2708 * event is issued, the VM will not stop. In this case, vm_start()
2709 * also ensures that the STOP/RESUME pair of events is emitted.
2711 qemu_system_vmstop_request_prepare();
2712 send_qmp_error_event(bs, action, is_read, error);
2713 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2715 send_qmp_error_event(bs, action, is_read, error);
2719 int bdrv_is_read_only(BlockDriverState *bs)
2721 return bs->read_only;
2724 int bdrv_is_sg(BlockDriverState *bs)
2729 int bdrv_enable_write_cache(BlockDriverState *bs)
2731 return bs->enable_write_cache;
2734 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2736 bs->enable_write_cache = wce;
2738 /* so a reopen() will preserve wce */
2740 bs->open_flags |= BDRV_O_CACHE_WB;
2742 bs->open_flags &= ~BDRV_O_CACHE_WB;
2746 int bdrv_is_encrypted(BlockDriverState *bs)
2748 if (bs->backing && bs->backing->bs->encrypted) {
2751 return bs->encrypted;
2754 int bdrv_key_required(BlockDriverState *bs)
2756 BdrvChild *backing = bs->backing;
2758 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2761 return (bs->encrypted && !bs->valid_key);
2764 int bdrv_set_key(BlockDriverState *bs, const char *key)
2767 if (bs->backing && bs->backing->bs->encrypted) {
2768 ret = bdrv_set_key(bs->backing->bs, key);
2774 if (!bs->encrypted) {
2776 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2779 ret = bs->drv->bdrv_set_key(bs, key);
2782 } else if (!bs->valid_key) {
2785 /* call the change callback now, we skipped it on open */
2786 blk_dev_change_media_cb(bs->blk, true);
2793 * Provide an encryption key for @bs.
2794 * If @key is non-null:
2795 * If @bs is not encrypted, fail.
2796 * Else if the key is invalid, fail.
2797 * Else set @bs's key to @key, replacing the existing key, if any.
2799 * If @bs is encrypted and still lacks a key, fail.
2801 * On failure, store an error object through @errp if non-null.
2803 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2806 if (!bdrv_is_encrypted(bs)) {
2807 error_setg(errp, "Node '%s' is not encrypted",
2808 bdrv_get_device_or_node_name(bs));
2809 } else if (bdrv_set_key(bs, key) < 0) {
2810 error_setg(errp, QERR_INVALID_PASSWORD);
2813 if (bdrv_key_required(bs)) {
2814 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2815 "'%s' (%s) is encrypted",
2816 bdrv_get_device_or_node_name(bs),
2817 bdrv_get_encrypted_filename(bs));
2822 const char *bdrv_get_format_name(BlockDriverState *bs)
2824 return bs->drv ? bs->drv->format_name : NULL;
2827 static int qsort_strcmp(const void *a, const void *b)
2829 return strcmp(a, b);
2832 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2838 const char **formats = NULL;
2840 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2841 if (drv->format_name) {
2844 while (formats && i && !found) {
2845 found = !strcmp(formats[--i], drv->format_name);
2849 formats = g_renew(const char *, formats, count + 1);
2850 formats[count++] = drv->format_name;
2855 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2857 for (i = 0; i < count; i++) {
2858 it(opaque, formats[i]);
2864 /* This function is to find a node in the bs graph */
2865 BlockDriverState *bdrv_find_node(const char *node_name)
2867 BlockDriverState *bs;
2871 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2872 if (!strcmp(node_name, bs->node_name)) {
2879 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2880 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2882 BlockDeviceInfoList *list, *entry;
2883 BlockDriverState *bs;
2886 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2887 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2889 qapi_free_BlockDeviceInfoList(list);
2892 entry = g_malloc0(sizeof(*entry));
2893 entry->value = info;
2901 BlockDriverState *bdrv_lookup_bs(const char *device,
2902 const char *node_name,
2906 BlockDriverState *bs;
2909 blk = blk_by_name(device);
2917 bs = bdrv_find_node(node_name);
2924 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2925 device ? device : "",
2926 node_name ? node_name : "");
2930 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2931 * return false. If either argument is NULL, return false. */
2932 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2934 while (top && top != base) {
2935 top = backing_bs(top);
2941 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2944 return QTAILQ_FIRST(&graph_bdrv_states);
2946 return QTAILQ_NEXT(bs, node_list);
2949 BlockDriverState *bdrv_next(BlockDriverState *bs)
2952 return QTAILQ_FIRST(&bdrv_states);
2954 return QTAILQ_NEXT(bs, device_list);
2957 const char *bdrv_get_node_name(const BlockDriverState *bs)
2959 return bs->node_name;
2962 /* TODO check what callers really want: bs->node_name or blk_name() */
2963 const char *bdrv_get_device_name(const BlockDriverState *bs)
2965 return bs->blk ? blk_name(bs->blk) : "";
2968 /* This can be used to identify nodes that might not have a device
2969 * name associated. Since node and device names live in the same
2970 * namespace, the result is unambiguous. The exception is if both are
2971 * absent, then this returns an empty (non-null) string. */
2972 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2974 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2977 int bdrv_get_flags(BlockDriverState *bs)
2979 return bs->open_flags;
2982 int bdrv_has_zero_init_1(BlockDriverState *bs)
2987 int bdrv_has_zero_init(BlockDriverState *bs)
2991 /* If BS is a copy on write image, it is initialized to
2992 the contents of the base image, which may not be zeroes. */
2996 if (bs->drv->bdrv_has_zero_init) {
2997 return bs->drv->bdrv_has_zero_init(bs);
3004 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3006 BlockDriverInfo bdi;
3012 if (bdrv_get_info(bs, &bdi) == 0) {
3013 return bdi.unallocated_blocks_are_zero;
3019 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3021 BlockDriverInfo bdi;
3023 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
3027 if (bdrv_get_info(bs, &bdi) == 0) {
3028 return bdi.can_write_zeroes_with_unmap;
3034 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3036 if (bs->backing && bs->backing->bs->encrypted)
3037 return bs->backing_file;
3038 else if (bs->encrypted)
3039 return bs->filename;
3044 void bdrv_get_backing_filename(BlockDriverState *bs,
3045 char *filename, int filename_size)
3047 pstrcpy(filename, filename_size, bs->backing_file);
3050 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3052 BlockDriver *drv = bs->drv;
3055 if (!drv->bdrv_get_info)
3057 memset(bdi, 0, sizeof(*bdi));
3058 return drv->bdrv_get_info(bs, bdi);
3061 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3063 BlockDriver *drv = bs->drv;
3064 if (drv && drv->bdrv_get_specific_info) {
3065 return drv->bdrv_get_specific_info(bs);
3070 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3072 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3076 bs->drv->bdrv_debug_event(bs, event);
3079 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3082 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3083 bs = bs->file ? bs->file->bs : NULL;
3086 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3087 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3093 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3095 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3096 bs = bs->file ? bs->file->bs : NULL;
3099 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3100 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3106 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3108 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3109 bs = bs->file ? bs->file->bs : NULL;
3112 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3113 return bs->drv->bdrv_debug_resume(bs, tag);
3119 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3121 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3122 bs = bs->file ? bs->file->bs : NULL;
3125 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3126 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3132 int bdrv_is_snapshot(BlockDriverState *bs)
3134 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3137 /* backing_file can either be relative, or absolute, or a protocol. If it is
3138 * relative, it must be relative to the chain. So, passing in bs->filename
3139 * from a BDS as backing_file should not be done, as that may be relative to
3140 * the CWD rather than the chain. */
3141 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3142 const char *backing_file)
3144 char *filename_full = NULL;
3145 char *backing_file_full = NULL;
3146 char *filename_tmp = NULL;
3147 int is_protocol = 0;
3148 BlockDriverState *curr_bs = NULL;
3149 BlockDriverState *retval = NULL;
3151 if (!bs || !bs->drv || !backing_file) {
3155 filename_full = g_malloc(PATH_MAX);
3156 backing_file_full = g_malloc(PATH_MAX);
3157 filename_tmp = g_malloc(PATH_MAX);
3159 is_protocol = path_has_protocol(backing_file);
3161 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3163 /* If either of the filename paths is actually a protocol, then
3164 * compare unmodified paths; otherwise make paths relative */
3165 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3166 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3167 retval = curr_bs->backing->bs;
3171 /* If not an absolute filename path, make it relative to the current
3172 * image's filename path */
3173 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3176 /* We are going to compare absolute pathnames */
3177 if (!realpath(filename_tmp, filename_full)) {
3181 /* We need to make sure the backing filename we are comparing against
3182 * is relative to the current image filename (or absolute) */
3183 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3184 curr_bs->backing_file);
3186 if (!realpath(filename_tmp, backing_file_full)) {
3190 if (strcmp(backing_file_full, filename_full) == 0) {
3191 retval = curr_bs->backing->bs;
3197 g_free(filename_full);
3198 g_free(backing_file_full);
3199 g_free(filename_tmp);
3203 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3213 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3216 void bdrv_init(void)
3218 module_call_init(MODULE_INIT_BLOCK);
3221 void bdrv_init_with_whitelist(void)
3223 use_bdrv_whitelist = 1;
3227 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3229 Error *local_err = NULL;
3236 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3239 bs->open_flags &= ~BDRV_O_INCOMING;
3241 if (bs->drv->bdrv_invalidate_cache) {
3242 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3243 } else if (bs->file) {
3244 bdrv_invalidate_cache(bs->file->bs, &local_err);
3247 error_propagate(errp, local_err);
3251 ret = refresh_total_sectors(bs, bs->total_sectors);
3253 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3258 void bdrv_invalidate_cache_all(Error **errp)
3260 BlockDriverState *bs;
3261 Error *local_err = NULL;
3263 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3264 AioContext *aio_context = bdrv_get_aio_context(bs);
3266 aio_context_acquire(aio_context);
3267 bdrv_invalidate_cache(bs, &local_err);
3268 aio_context_release(aio_context);
3270 error_propagate(errp, local_err);
3276 /**************************************************************/
3277 /* removable device support */
3280 * Return TRUE if the media is present
3282 int bdrv_is_inserted(BlockDriverState *bs)
3284 BlockDriver *drv = bs->drv;
3288 if (!drv->bdrv_is_inserted)
3290 return drv->bdrv_is_inserted(bs);
3294 * Return whether the media changed since the last call to this
3295 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3297 int bdrv_media_changed(BlockDriverState *bs)
3299 BlockDriver *drv = bs->drv;
3301 if (drv && drv->bdrv_media_changed) {
3302 return drv->bdrv_media_changed(bs);
3308 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3310 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3312 BlockDriver *drv = bs->drv;
3313 const char *device_name;
3315 if (drv && drv->bdrv_eject) {
3316 drv->bdrv_eject(bs, eject_flag);
3319 device_name = bdrv_get_device_name(bs);
3320 if (device_name[0] != '\0') {
3321 qapi_event_send_device_tray_moved(device_name,
3322 eject_flag, &error_abort);
3327 * Lock or unlock the media (if it is locked, the user won't be able
3328 * to eject it manually).
3330 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3332 BlockDriver *drv = bs->drv;
3334 trace_bdrv_lock_medium(bs, locked);
3336 if (drv && drv->bdrv_lock_medium) {
3337 drv->bdrv_lock_medium(bs, locked);
3341 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3343 bs->guest_block_size = align;
3346 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3348 BdrvDirtyBitmap *bm;
3351 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3352 if (bm->name && !strcmp(name, bm->name)) {
3359 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3361 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3362 g_free(bitmap->name);
3363 bitmap->name = NULL;
3366 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3367 uint32_t granularity,
3371 int64_t bitmap_size;
3372 BdrvDirtyBitmap *bitmap;
3373 uint32_t sector_granularity;
3375 assert((granularity & (granularity - 1)) == 0);
3377 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3378 error_setg(errp, "Bitmap already exists: %s", name);
3381 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3382 assert(sector_granularity);
3383 bitmap_size = bdrv_nb_sectors(bs);
3384 if (bitmap_size < 0) {
3385 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3386 errno = -bitmap_size;
3389 bitmap = g_new0(BdrvDirtyBitmap, 1);
3390 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3391 bitmap->size = bitmap_size;
3392 bitmap->name = g_strdup(name);
3393 bitmap->disabled = false;
3394 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3398 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3400 return bitmap->successor;
3403 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3405 return !(bitmap->disabled || bitmap->successor);
3408 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3410 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3411 return DIRTY_BITMAP_STATUS_FROZEN;
3412 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3413 return DIRTY_BITMAP_STATUS_DISABLED;
3415 return DIRTY_BITMAP_STATUS_ACTIVE;
3420 * Create a successor bitmap destined to replace this bitmap after an operation.
3421 * Requires that the bitmap is not frozen and has no successor.
3423 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3424 BdrvDirtyBitmap *bitmap, Error **errp)
3426 uint64_t granularity;
3427 BdrvDirtyBitmap *child;
3429 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3430 error_setg(errp, "Cannot create a successor for a bitmap that is "
3431 "currently frozen");
3434 assert(!bitmap->successor);
3436 /* Create an anonymous successor */
3437 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3438 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3443 /* Successor will be on or off based on our current state. */
3444 child->disabled = bitmap->disabled;
3446 /* Install the successor and freeze the parent */
3447 bitmap->successor = child;
3452 * For a bitmap with a successor, yield our name to the successor,
3453 * delete the old bitmap, and return a handle to the new bitmap.
3455 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3456 BdrvDirtyBitmap *bitmap,
3460 BdrvDirtyBitmap *successor = bitmap->successor;
3462 if (successor == NULL) {
3463 error_setg(errp, "Cannot relinquish control if "
3464 "there's no successor present");
3468 name = bitmap->name;
3469 bitmap->name = NULL;
3470 successor->name = name;
3471 bitmap->successor = NULL;
3472 bdrv_release_dirty_bitmap(bs, bitmap);
3478 * In cases of failure where we can no longer safely delete the parent,
3479 * we may wish to re-join the parent and child/successor.
3480 * The merged parent will be un-frozen, but not explicitly re-enabled.
3482 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3483 BdrvDirtyBitmap *parent,
3486 BdrvDirtyBitmap *successor = parent->successor;
3489 error_setg(errp, "Cannot reclaim a successor when none is present");
3493 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3494 error_setg(errp, "Merging of parent and successor bitmap failed");
3497 bdrv_release_dirty_bitmap(bs, successor);
3498 parent->successor = NULL;
3504 * Truncates _all_ bitmaps attached to a BDS.
3506 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3508 BdrvDirtyBitmap *bitmap;
3509 uint64_t size = bdrv_nb_sectors(bs);
3511 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3512 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3513 hbitmap_truncate(bitmap->bitmap, size);
3514 bitmap->size = size;
3518 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3520 BdrvDirtyBitmap *bm, *next;
3521 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3523 assert(!bdrv_dirty_bitmap_frozen(bm));
3524 QLIST_REMOVE(bitmap, list);
3525 hbitmap_free(bitmap->bitmap);
3526 g_free(bitmap->name);
3533 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3535 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3536 bitmap->disabled = true;
3539 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3541 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3542 bitmap->disabled = false;
3545 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3547 BdrvDirtyBitmap *bm;
3548 BlockDirtyInfoList *list = NULL;
3549 BlockDirtyInfoList **plist = &list;
3551 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3552 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3553 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3554 info->count = bdrv_get_dirty_count(bm);
3555 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3556 info->has_name = !!bm->name;
3557 info->name = g_strdup(bm->name);
3558 info->status = bdrv_dirty_bitmap_status(bm);
3559 entry->value = info;
3561 plist = &entry->next;
3567 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3570 return hbitmap_get(bitmap->bitmap, sector);
3577 * Chooses a default granularity based on the existing cluster size,
3578 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3579 * is no cluster size information available.
3581 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3583 BlockDriverInfo bdi;
3584 uint32_t granularity;
3586 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3587 granularity = MAX(4096, bdi.cluster_size);
3588 granularity = MIN(65536, granularity);
3590 granularity = 65536;
3596 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3598 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3601 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3603 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3606 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3607 int64_t cur_sector, int nr_sectors)
3609 assert(bdrv_dirty_bitmap_enabled(bitmap));
3610 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3613 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3614 int64_t cur_sector, int nr_sectors)
3616 assert(bdrv_dirty_bitmap_enabled(bitmap));
3617 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3620 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3622 assert(bdrv_dirty_bitmap_enabled(bitmap));
3623 hbitmap_reset_all(bitmap->bitmap);
3626 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3629 BdrvDirtyBitmap *bitmap;
3630 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3631 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3634 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3639 * Advance an HBitmapIter to an arbitrary offset.
3641 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3644 hbitmap_iter_init(hbi, hbi->hb, offset);
3647 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3649 return hbitmap_count(bitmap->bitmap);
3652 /* Get a reference to bs */
3653 void bdrv_ref(BlockDriverState *bs)
3658 /* Release a previously grabbed reference to bs.
3659 * If after releasing, reference count is zero, the BlockDriverState is
3661 void bdrv_unref(BlockDriverState *bs)
3666 assert(bs->refcnt > 0);
3667 if (--bs->refcnt == 0) {
3672 struct BdrvOpBlocker {
3674 QLIST_ENTRY(BdrvOpBlocker) list;
3677 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3679 BdrvOpBlocker *blocker;
3680 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3681 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3682 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3684 error_setg(errp, "Node '%s' is busy: %s",
3685 bdrv_get_device_or_node_name(bs),
3686 error_get_pretty(blocker->reason));
3693 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3695 BdrvOpBlocker *blocker;
3696 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3698 blocker = g_new0(BdrvOpBlocker, 1);
3699 blocker->reason = reason;
3700 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3703 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3705 BdrvOpBlocker *blocker, *next;
3706 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3707 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3708 if (blocker->reason == reason) {
3709 QLIST_REMOVE(blocker, list);
3715 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3718 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3719 bdrv_op_block(bs, i, reason);
3723 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3726 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3727 bdrv_op_unblock(bs, i, reason);
3731 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3735 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3736 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3743 void bdrv_iostatus_enable(BlockDriverState *bs)
3745 bs->iostatus_enabled = true;
3746 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3749 /* The I/O status is only enabled if the drive explicitly
3750 * enables it _and_ the VM is configured to stop on errors */
3751 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3753 return (bs->iostatus_enabled &&
3754 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3755 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
3756 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3759 void bdrv_iostatus_disable(BlockDriverState *bs)
3761 bs->iostatus_enabled = false;
3764 void bdrv_iostatus_reset(BlockDriverState *bs)
3766 if (bdrv_iostatus_is_enabled(bs)) {
3767 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3769 block_job_iostatus_reset(bs->job);
3774 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3776 assert(bdrv_iostatus_is_enabled(bs));
3777 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3778 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3779 BLOCK_DEVICE_IO_STATUS_FAILED;
3783 void bdrv_img_create(const char *filename, const char *fmt,
3784 const char *base_filename, const char *base_fmt,
3785 char *options, uint64_t img_size, int flags,
3786 Error **errp, bool quiet)
3788 QemuOptsList *create_opts = NULL;
3789 QemuOpts *opts = NULL;
3790 const char *backing_fmt, *backing_file;
3792 BlockDriver *drv, *proto_drv;
3793 Error *local_err = NULL;
3796 /* Find driver and parse its options */
3797 drv = bdrv_find_format(fmt);
3799 error_setg(errp, "Unknown file format '%s'", fmt);
3803 proto_drv = bdrv_find_protocol(filename, true, errp);
3808 if (!drv->create_opts) {
3809 error_setg(errp, "Format driver '%s' does not support image creation",
3814 if (!proto_drv->create_opts) {
3815 error_setg(errp, "Protocol driver '%s' does not support image creation",
3816 proto_drv->format_name);
3820 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3821 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3823 /* Create parameter list with default values */
3824 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3825 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3827 /* Parse -o options */
3829 qemu_opts_do_parse(opts, options, NULL, &local_err);
3831 error_report_err(local_err);
3833 error_setg(errp, "Invalid options for file format '%s'", fmt);
3838 if (base_filename) {
3839 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3841 error_setg(errp, "Backing file not supported for file format '%s'",
3848 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3850 error_setg(errp, "Backing file format not supported for file "
3851 "format '%s'", fmt);
3856 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3858 if (!strcmp(filename, backing_file)) {
3859 error_setg(errp, "Error: Trying to create an image with the "
3860 "same filename as the backing file");
3865 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3867 // The size for the image must always be specified, with one exception:
3868 // If we are using a backing file, we can obtain the size from there
3869 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3872 BlockDriverState *bs;
3873 char *full_backing = g_new0(char, PATH_MAX);
3876 QDict *backing_options = NULL;
3878 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3879 full_backing, PATH_MAX,
3882 g_free(full_backing);
3886 /* backing files always opened read-only */
3888 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3891 backing_options = qdict_new();
3892 qdict_put(backing_options, "driver",
3893 qstring_from_str(backing_fmt));
3897 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3898 back_flags, &local_err);
3899 g_free(full_backing);
3903 size = bdrv_getlength(bs);
3905 error_setg_errno(errp, -size, "Could not get size of '%s'",
3911 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3915 error_setg(errp, "Image creation needs a size parameter");
3921 printf("Formatting '%s', fmt=%s ", filename, fmt);
3922 qemu_opts_print(opts, " ");
3926 ret = bdrv_create(drv, filename, opts, &local_err);
3928 if (ret == -EFBIG) {
3929 /* This is generally a better message than whatever the driver would
3930 * deliver (especially because of the cluster_size_hint), since that
3931 * is most probably not much different from "image too large". */
3932 const char *cluster_size_hint = "";
3933 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3934 cluster_size_hint = " (try using a larger cluster size)";
3936 error_setg(errp, "The image size is too large for file format '%s'"
3937 "%s", fmt, cluster_size_hint);
3938 error_free(local_err);
3943 qemu_opts_del(opts);
3944 qemu_opts_free(create_opts);
3946 error_propagate(errp, local_err);
3950 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3952 return bs->aio_context;
3955 void bdrv_detach_aio_context(BlockDriverState *bs)
3957 BdrvAioNotifier *baf;
3963 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3964 baf->detach_aio_context(baf->opaque);
3967 if (bs->io_limits_enabled) {
3968 throttle_timers_detach_aio_context(&bs->throttle_timers);
3970 if (bs->drv->bdrv_detach_aio_context) {
3971 bs->drv->bdrv_detach_aio_context(bs);
3974 bdrv_detach_aio_context(bs->file->bs);
3977 bdrv_detach_aio_context(bs->backing->bs);
3980 bs->aio_context = NULL;
3983 void bdrv_attach_aio_context(BlockDriverState *bs,
3984 AioContext *new_context)
3986 BdrvAioNotifier *ban;
3992 bs->aio_context = new_context;
3995 bdrv_attach_aio_context(bs->backing->bs, new_context);
3998 bdrv_attach_aio_context(bs->file->bs, new_context);
4000 if (bs->drv->bdrv_attach_aio_context) {
4001 bs->drv->bdrv_attach_aio_context(bs, new_context);
4003 if (bs->io_limits_enabled) {
4004 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
4007 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
4008 ban->attached_aio_context(new_context, ban->opaque);
4012 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4014 bdrv_drain(bs); /* ensure there are no in-flight requests */
4016 bdrv_detach_aio_context(bs);
4018 /* This function executes in the old AioContext so acquire the new one in
4019 * case it runs in a different thread.
4021 aio_context_acquire(new_context);
4022 bdrv_attach_aio_context(bs, new_context);
4023 aio_context_release(new_context);
4026 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4027 void (*attached_aio_context)(AioContext *new_context, void *opaque),
4028 void (*detach_aio_context)(void *opaque), void *opaque)
4030 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4031 *ban = (BdrvAioNotifier){
4032 .attached_aio_context = attached_aio_context,
4033 .detach_aio_context = detach_aio_context,
4037 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4040 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4041 void (*attached_aio_context)(AioContext *,
4043 void (*detach_aio_context)(void *),
4046 BdrvAioNotifier *ban, *ban_next;
4048 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4049 if (ban->attached_aio_context == attached_aio_context &&
4050 ban->detach_aio_context == detach_aio_context &&
4051 ban->opaque == opaque)
4053 QLIST_REMOVE(ban, list);
4063 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4064 BlockDriverAmendStatusCB *status_cb)
4066 if (!bs->drv->bdrv_amend_options) {
4069 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
4072 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4073 * of block filter and by bdrv_is_first_non_filter.
4074 * It is used to test if the given bs is the candidate or recurse more in the
4077 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4078 BlockDriverState *candidate)
4080 /* return false if basic checks fails */
4081 if (!bs || !bs->drv) {
4085 /* the code reached a non block filter driver -> check if the bs is
4086 * the same as the candidate. It's the recursion termination condition.
4088 if (!bs->drv->is_filter) {
4089 return bs == candidate;
4091 /* Down this path the driver is a block filter driver */
4093 /* If the block filter recursion method is defined use it to recurse down
4096 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4097 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4100 /* the driver is a block filter but don't allow to recurse -> return false
4105 /* This function checks if the candidate is the first non filter bs down it's
4106 * bs chain. Since we don't have pointers to parents it explore all bs chains
4107 * from the top. Some filters can choose not to pass down the recursion.
4109 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4111 BlockDriverState *bs;
4113 /* walk down the bs forest recursively */
4114 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4117 /* try to recurse in this top level bs */
4118 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4120 /* candidate is the first non filter */
4129 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4130 const char *node_name, Error **errp)
4132 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4133 AioContext *aio_context;
4135 if (!to_replace_bs) {
4136 error_setg(errp, "Node name '%s' not found", node_name);
4140 aio_context = bdrv_get_aio_context(to_replace_bs);
4141 aio_context_acquire(aio_context);
4143 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4144 to_replace_bs = NULL;
4148 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4149 * most non filter in order to prevent data corruption.
4150 * Another benefit is that this tests exclude backing files which are
4151 * blocked by the backing blockers.
4153 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4154 error_setg(errp, "Only top most non filter can be replaced");
4155 to_replace_bs = NULL;
4160 aio_context_release(aio_context);
4161 return to_replace_bs;
4164 static bool append_open_options(QDict *d, BlockDriverState *bs)
4166 const QDictEntry *entry;
4167 bool found_any = false;
4169 for (entry = qdict_first(bs->options); entry;
4170 entry = qdict_next(bs->options, entry))
4172 /* Only take options for this level and exclude all non-driver-specific
4174 if (!strchr(qdict_entry_key(entry), '.') &&
4175 strcmp(qdict_entry_key(entry), "node-name"))
4177 qobject_incref(qdict_entry_value(entry));
4178 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4186 /* Updates the following BDS fields:
4187 * - exact_filename: A filename which may be used for opening a block device
4188 * which (mostly) equals the given BDS (even without any
4189 * other options; so reading and writing must return the same
4190 * results, but caching etc. may be different)
4191 * - full_open_options: Options which, when given when opening a block device
4192 * (without a filename), result in a BDS (mostly)
4193 * equalling the given one
4194 * - filename: If exact_filename is set, it is copied here. Otherwise,
4195 * full_open_options is converted to a JSON object, prefixed with
4196 * "json:" (for use through the JSON pseudo protocol) and put here.
4198 void bdrv_refresh_filename(BlockDriverState *bs)
4200 BlockDriver *drv = bs->drv;
4207 /* This BDS's file name will most probably depend on its file's name, so
4208 * refresh that first */
4210 bdrv_refresh_filename(bs->file->bs);
4213 if (drv->bdrv_refresh_filename) {
4214 /* Obsolete information is of no use here, so drop the old file name
4215 * information before refreshing it */
4216 bs->exact_filename[0] = '\0';
4217 if (bs->full_open_options) {
4218 QDECREF(bs->full_open_options);
4219 bs->full_open_options = NULL;
4222 drv->bdrv_refresh_filename(bs);
4223 } else if (bs->file) {
4224 /* Try to reconstruct valid information from the underlying file */
4225 bool has_open_options;
4227 bs->exact_filename[0] = '\0';
4228 if (bs->full_open_options) {
4229 QDECREF(bs->full_open_options);
4230 bs->full_open_options = NULL;
4234 has_open_options = append_open_options(opts, bs);
4236 /* If no specific options have been given for this BDS, the filename of
4237 * the underlying file should suffice for this one as well */
4238 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4239 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4241 /* Reconstructing the full options QDict is simple for most format block
4242 * drivers, as long as the full options are known for the underlying
4243 * file BDS. The full options QDict of that file BDS should somehow
4244 * contain a representation of the filename, therefore the following
4245 * suffices without querying the (exact_)filename of this BDS. */
4246 if (bs->file->bs->full_open_options) {
4247 qdict_put_obj(opts, "driver",
4248 QOBJECT(qstring_from_str(drv->format_name)));
4249 QINCREF(bs->file->bs->full_open_options);
4250 qdict_put_obj(opts, "file",
4251 QOBJECT(bs->file->bs->full_open_options));
4253 bs->full_open_options = opts;
4257 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4258 /* There is no underlying file BDS (at least referenced by BDS.file),
4259 * so the full options QDict should be equal to the options given
4260 * specifically for this block device when it was opened (plus the
4261 * driver specification).
4262 * Because those options don't change, there is no need to update
4263 * full_open_options when it's already set. */
4266 append_open_options(opts, bs);
4267 qdict_put_obj(opts, "driver",
4268 QOBJECT(qstring_from_str(drv->format_name)));
4270 if (bs->exact_filename[0]) {
4271 /* This may not work for all block protocol drivers (some may
4272 * require this filename to be parsed), but we have to find some
4273 * default solution here, so just include it. If some block driver
4274 * does not support pure options without any filename at all or
4275 * needs some special format of the options QDict, it needs to
4276 * implement the driver-specific bdrv_refresh_filename() function.
4278 qdict_put_obj(opts, "filename",
4279 QOBJECT(qstring_from_str(bs->exact_filename)));
4282 bs->full_open_options = opts;
4285 if (bs->exact_filename[0]) {
4286 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4287 } else if (bs->full_open_options) {
4288 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4289 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4290 qstring_get_str(json));
4295 /* This accessor function purpose is to allow the device models to access the
4296 * BlockAcctStats structure embedded inside a BlockDriverState without being
4297 * aware of the BlockDriverState structure layout.
4298 * It will go away when the BlockAcctStats structure will be moved inside
4299 * the device models.
4301 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)