block: Introduce parents list
[qemu.git] / block.c
blob980437f05613789123e847258dc150c14f309e24
1 /*
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
22 * THE SOFTWARE.
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.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"
43 #ifdef CONFIG_BSD
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
48 #ifndef __DragonFly__
49 #include <sys/disk.h>
50 #endif
51 #endif
53 #ifdef _WIN32
54 #include <windows.h>
55 #endif
57 /**
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;
94 #ifdef _WIN32
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')) &&
99 filename[1] == ':');
102 int is_windows_drive(const char *filename)
104 if (is_windows_drive_prefix(filename) &&
105 filename[2] == '\0')
106 return 1;
107 if (strstart(filename, "\\\\.\\", NULL) ||
108 strstart(filename, "//./", NULL))
109 return 1;
110 return 0;
112 #endif
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)
137 const char *p;
139 #ifdef _WIN32
140 if (is_windows_drive(path) ||
141 is_windows_drive_prefix(path)) {
142 return 0;
144 p = path + strcspn(path, ":/\\");
145 #else
146 p = path + strcspn(path, ":/");
147 #endif
149 return *p == ':';
152 int path_is_absolute(const char *path)
154 #ifdef _WIN32
155 /* specific case for names like: "\\.\d:" */
156 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
157 return 1;
159 return (*path == '/' || *path == '\\');
160 #else
161 return (*path == '/');
162 #endif
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
167 supported. */
168 void path_combine(char *dest, int dest_size,
169 const char *base_path,
170 const char *filename)
172 const char *p, *p1;
173 int len;
175 if (dest_size <= 0)
176 return;
177 if (path_is_absolute(filename)) {
178 pstrcpy(dest, dest_size, filename);
179 } else {
180 p = strchr(base_path, ':');
181 if (p)
182 p++;
183 else
184 p = base_path;
185 p1 = strrchr(base_path, '/');
186 #ifdef _WIN32
188 const char *p2;
189 p2 = strrchr(base_path, '\\');
190 if (!p1 || p2 > p1)
191 p1 = p2;
193 #endif
194 if (p1)
195 p1++;
196 else
197 p1 = base_path;
198 if (p1 > p)
199 p = p1;
200 len = p - base_path;
201 if (len > dest_size - 1)
202 len = dest_size - 1;
203 memcpy(dest, base_path, len);
204 dest[len] = '\0';
205 pstrcat(dest, dest_size, filename);
209 void bdrv_get_full_backing_filename_from_filename(const char *backed,
210 const char *backing,
211 char *dest, size_t sz,
212 Error **errp)
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'",
220 backed);
221 } else {
222 path_combine(dest, sz, backed, backing);
226 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
227 Error **errp)
229 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
231 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
232 dest, sz, errp);
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);
247 return bs;
250 BlockDriverState *bdrv_new(void)
252 BlockDriverState *bs;
253 int i;
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]);
265 bs->refcnt = 1;
266 bs->aio_context = qemu_get_aio_context();
268 return bs;
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)
278 BlockDriver *drv1;
279 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
280 if (!strcmp(drv1->format_name, format_name)) {
281 return drv1;
284 return NULL;
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
295 const char **p;
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)) {
303 return 1;
306 if (read_only) {
307 for (p = whitelist_ro; *p; p++) {
308 if (!strcmp(drv->format_name, *p)) {
309 return 1;
313 return 0;
316 typedef struct CreateCo {
317 BlockDriver *drv;
318 char *filename;
319 QemuOpts *opts;
320 int ret;
321 Error *err;
322 } CreateCo;
324 static void coroutine_fn bdrv_create_co_entry(void *opaque)
326 Error *local_err = NULL;
327 int ret;
329 CreateCo *cco = opaque;
330 assert(cco->drv);
332 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
333 if (local_err) {
334 error_propagate(&cco->err, local_err);
336 cco->ret = ret;
339 int bdrv_create(BlockDriver *drv, const char* filename,
340 QemuOpts *opts, Error **errp)
342 int ret;
344 Coroutine *co;
345 CreateCo cco = {
346 .drv = drv,
347 .filename = g_strdup(filename),
348 .opts = opts,
349 .ret = NOT_DONE,
350 .err = NULL,
353 if (!drv->bdrv_create) {
354 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
355 ret = -ENOTSUP;
356 goto out;
359 if (qemu_in_coroutine()) {
360 /* Fast-path if already in coroutine context */
361 bdrv_create_co_entry(&cco);
362 } else {
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);
370 ret = cco.ret;
371 if (ret < 0) {
372 if (cco.err) {
373 error_propagate(errp, cco.err);
374 } else {
375 error_setg_errno(errp, -ret, "Could not create image");
379 out:
380 g_free(cco.filename);
381 return ret;
384 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
386 BlockDriver *drv;
387 Error *local_err = NULL;
388 int ret;
390 drv = bdrv_find_protocol(filename, true, errp);
391 if (drv == NULL) {
392 return -ENOENT;
395 ret = bdrv_create(drv, filename, opts, &local_err);
396 if (local_err) {
397 error_propagate(errp, local_err);
399 return ret;
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);
416 return -ENOTSUP;
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);
433 return -ENOTSUP;
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)
442 #ifdef _WIN32
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());
450 #else
451 int fd;
452 const char *tmpdir;
453 tmpdir = getenv("TMPDIR");
454 if (!tmpdir) {
455 tmpdir = "/var/tmp";
457 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
458 return -EOVERFLOW;
460 fd = mkstemp(filename);
461 if (fd < 0) {
462 return -errno;
464 if (close(fd) != 0) {
465 unlink(filename);
466 return -errno;
468 return 0;
469 #endif
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) {
485 score_max = score;
486 drv = d;
491 return drv;
494 BlockDriver *bdrv_find_protocol(const char *filename,
495 bool allow_protocol_prefix,
496 Error **errp)
498 BlockDriver *drv1;
499 char protocol[128];
500 int len;
501 const char *p;
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);
513 if (drv1) {
514 return drv1;
517 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
518 return &bdrv_file;
521 p = strchr(filename, ':');
522 assert(p != NULL);
523 len = p - 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)) {
531 return drv1;
535 error_setg(errp, "Unknown protocol '%s'", protocol);
536 return NULL;
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
550 * probing score.
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) {
560 if (d->bdrv_probe) {
561 score = d->bdrv_probe(buf, buf_size, filename);
562 if (score > score_max) {
563 score_max = score;
564 drv = d;
569 return drv;
572 static int find_image_format(BlockDriverState *bs, const char *filename,
573 BlockDriver **pdrv, Error **errp)
575 BlockDriver *drv;
576 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
577 int ret = 0;
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) {
581 *pdrv = &bdrv_raw;
582 return ret;
585 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
586 if (ret < 0) {
587 error_setg_errno(errp, -ret, "Could not read image for determining its "
588 "format");
589 *pdrv = NULL;
590 return ret;
593 drv = bdrv_probe_all(buf, ret, filename);
594 if (!drv) {
595 error_setg(errp, "Could not determine image format: No compatible "
596 "driver found");
597 ret = -ENOENT;
599 *pdrv = drv;
600 return ret;
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 */
612 if (bdrv_is_sg(bs))
613 return 0;
615 /* query actual device if possible, otherwise just trust the hint */
616 if (drv->bdrv_getlength) {
617 int64_t length = drv->bdrv_getlength(bs);
618 if (length < 0) {
619 return length;
621 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
624 bs->total_sectors = hint;
625 return 0;
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")) {
638 /* do nothing */
639 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
640 *flags |= BDRV_O_UNMAP;
641 } else {
642 return -1;
645 return 0;
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 */
668 } else {
669 return -1;
672 return 0;
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);
701 return flags;
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
711 * BDS
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
725 * for the parent BDS
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);
735 return flags;
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
748 * image.
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;
759 return open_flags;
762 static void bdrv_assign_node_name(BlockDriverState *bs,
763 const char *node_name,
764 Error **errp)
766 if (!node_name) {
767 return;
770 /* Check for empty string or invalid characters */
771 if (!id_wellformed(node_name)) {
772 error_setg(errp, "Invalid node name");
773 return;
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",
779 node_name);
780 return;
783 /* takes care of avoiding duplicates node names */
784 if (bdrv_find_node(node_name)) {
785 error_setg(errp, "Duplicate node name");
786 return;
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),
797 .desc = {
799 .name = "node-name",
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)
815 int ret, open_flags;
816 const char *filename;
817 const char *node_name = NULL;
818 QemuOpts *opts;
819 Error *local_err = NULL;
821 assert(drv != NULL);
822 assert(bs->file == NULL);
823 assert(options != NULL && bs->options != options);
825 if (file != NULL) {
826 filename = file->bs->filename;
827 } else {
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",
833 drv->format_name);
834 return -EINVAL;
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);
841 if (local_err) {
842 error_propagate(errp, local_err);
843 ret = -EINVAL;
844 goto fail_opts;
847 node_name = qemu_opt_get(opts, "node-name");
848 bdrv_assign_node_name(bs, node_name, &local_err);
849 if (local_err) {
850 error_propagate(errp, local_err);
851 ret = -EINVAL;
852 goto fail_opts;
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)) {
862 error_setg(errp,
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",
866 drv->format_name);
867 ret = -ENOTSUP;
868 goto fail_opts;
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);
875 } else {
876 error_setg(errp, "Can't use copy-on-read on read-only device");
877 ret = -EINVAL;
878 goto fail_opts;
882 if (filename != NULL) {
883 pstrcpy(bs->filename, sizeof(bs->filename), filename);
884 } else {
885 bs->filename[0] = '\0';
887 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
889 bs->drv = drv;
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);
899 } else {
900 if (file == NULL) {
901 error_setg(errp, "Can't use '%s' as a block driver for the "
902 "protocol level", drv->format_name);
903 ret = -EINVAL;
904 goto free_and_fail;
906 bs->file = file;
907 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
910 if (ret < 0) {
911 if (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);
915 } else {
916 error_setg_errno(errp, -ret, "Could not open image");
918 goto free_and_fail;
921 if (bs->encrypted) {
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);
929 if (ret < 0) {
930 error_setg_errno(errp, -ret, "Could not refresh total sector count");
931 goto free_and_fail;
934 bdrv_refresh_limits(bs, &local_err);
935 if (local_err) {
936 error_propagate(errp, local_err);
937 ret = -EINVAL;
938 goto free_and_fail;
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));
945 qemu_opts_del(opts);
946 return 0;
948 free_and_fail:
949 bs->file = NULL;
950 g_free(bs->opaque);
951 bs->opaque = NULL;
952 bs->drv = NULL;
953 fail_opts:
954 qemu_opts_del(opts);
955 return ret;
958 static QDict *parse_json_filename(const char *filename, Error **errp)
960 QObject *options_obj;
961 QDict *options;
962 int ret;
964 ret = strstart(filename, "json:", &filename);
965 assert(ret);
967 options_obj = qobject_from_json(filename);
968 if (!options_obj) {
969 error_setg(errp, "Could not parse the JSON options");
970 return NULL;
973 if (qobject_type(options_obj) != QTYPE_QDICT) {
974 qobject_decref(options_obj);
975 error_setg(errp, "Invalid JSON object given");
976 return NULL;
979 options = qobject_to_qdict(options_obj);
980 qdict_flatten(options);
982 return 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;
995 const char *drvname;
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);
1004 if (local_err) {
1005 error_propagate(errp, local_err);
1006 return -EINVAL;
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");
1017 if (drvname) {
1018 drv = bdrv_find_format(drvname);
1019 if (!drv) {
1020 error_setg(errp, "Unknown driver '%s'", drvname);
1021 return -ENOENT;
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;
1028 if (protocol) {
1029 *flags |= BDRV_O_PROTOCOL;
1030 } else {
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;
1039 } else {
1040 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1041 "the same time");
1042 return -EINVAL;
1046 /* Find the right block driver */
1047 filename = qdict_get_try_str(*options, "filename");
1049 if (!drvname && protocol) {
1050 if (filename) {
1051 drv = bdrv_find_protocol(filename, parse_filename, errp);
1052 if (!drv) {
1053 return -EINVAL;
1056 drvname = drv->format_name;
1057 qdict_put(*options, "driver", qstring_from_str(drvname));
1058 } else {
1059 error_setg(errp, "Must specify either driver or file");
1060 return -EINVAL;
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);
1069 if (local_err) {
1070 error_propagate(errp, local_err);
1071 return -EINVAL;
1074 if (!drv->bdrv_needs_filename) {
1075 qdict_del(*options, "filename");
1079 return 0;
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) {
1088 .bs = child_bs,
1089 .role = child_role,
1092 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1093 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1095 return child;
1098 void bdrv_detach_child(BdrvChild *child)
1100 QLIST_REMOVE(child, next);
1101 QLIST_REMOVE(child, next_parent);
1102 g_free(child);
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)
1123 if (backing_hd) {
1124 bdrv_ref(backing_hd);
1127 if (bs->backing) {
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));
1137 if (!backing_hd) {
1138 error_free(bs->backing_blocker);
1139 bs->backing_blocker = NULL;
1140 bs->backing = NULL;
1141 goto out;
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);
1153 out:
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);
1168 int ret = 0;
1169 BlockDriverState *backing_hd;
1170 Error *local_err = NULL;
1172 if (bs->backing != NULL) {
1173 QDECREF(options);
1174 goto free_exit;
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) {
1186 QDECREF(options);
1187 goto free_exit;
1188 } else {
1189 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1190 &local_err);
1191 if (local_err) {
1192 ret = -EINVAL;
1193 error_propagate(errp, local_err);
1194 QDECREF(options);
1195 goto free_exit;
1199 if (!bs->drv || !bs->drv->supports_backing) {
1200 ret = -EINVAL;
1201 error_setg(errp, "Driver doesn't support backing files");
1202 QDECREF(options);
1203 goto free_exit;
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);
1216 if (ret < 0) {
1217 bdrv_unref(backing_hd);
1218 backing_hd = NULL;
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);
1223 goto free_exit;
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);
1231 free_exit:
1232 g_free(backing_filename);
1233 return ret;
1237 * Opens a disk image whose options are given as BlockdevRef in another block
1238 * device's options.
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
1246 * BlockdevRef.
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;
1259 int ret;
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)) {
1271 if (!allow_none) {
1272 error_setg(errp, "A block device must be specified for \"%s\"",
1273 bdref_key);
1275 QDECREF(image_options);
1276 goto done;
1279 bs = NULL;
1280 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1281 parent, child_role, errp);
1282 if (ret < 0) {
1283 goto done;
1286 c = bdrv_attach_child(parent, bs, child_role);
1288 done:
1289 qdict_del(options, bdref_key);
1290 return c;
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);
1297 int64_t total_size;
1298 QemuOpts *opts = NULL;
1299 QDict *snapshot_options;
1300 BlockDriverState *bs_snapshot;
1301 Error *local_err = NULL;
1302 int ret;
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) {
1310 ret = total_size;
1311 error_setg_errno(errp, -total_size, "Could not get image size");
1312 goto out;
1315 /* Create the temporary image */
1316 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1317 if (ret < 0) {
1318 error_setg_errno(errp, -ret, "Could not get temporary filename");
1319 goto out;
1322 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1323 &error_abort);
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);
1327 if (ret < 0) {
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);
1332 goto out;
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,
1347 flags, &local_err);
1348 if (ret < 0) {
1349 error_propagate(errp, local_err);
1350 goto out;
1353 bdrv_append(bs_snapshot, bs);
1355 out:
1356 g_free(tmp_filename);
1357 return ret;
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)
1380 int ret;
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;
1388 assert(pbs);
1389 assert(!child_role || !flags);
1390 assert(!child_role == !parent);
1392 if (reference) {
1393 bool options_non_empty = options ? qdict_size(options) : false;
1394 QDECREF(options);
1396 if (*pbs) {
1397 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1398 "another block device");
1399 return -EINVAL;
1402 if (filename || options_non_empty) {
1403 error_setg(errp, "Cannot reference an existing block device with "
1404 "additional options or a new filename");
1405 return -EINVAL;
1408 bs = bdrv_lookup_bs(reference, reference, errp);
1409 if (!bs) {
1410 return -ENODEV;
1412 bdrv_ref(bs);
1413 *pbs = bs;
1414 return 0;
1417 if (*pbs) {
1418 bs = *pbs;
1419 } else {
1420 bs = bdrv_new();
1423 /* NULL means an empty set of options */
1424 if (options == NULL) {
1425 options = qdict_new();
1428 if (child_role) {
1429 bs->inherits_from = parent;
1430 flags = child_role->inherit_flags(parent->open_flags);
1433 ret = bdrv_fill_options(&options, &filename, &flags, &local_err);
1434 if (local_err) {
1435 goto fail;
1438 /* Find the right image format driver */
1439 drvname = qdict_get_try_str(options, "driver");
1440 if (drvname) {
1441 drv = bdrv_find_format(drvname);
1442 qdict_del(options, "driver");
1443 if (!drv) {
1444 error_setg(errp, "Unknown driver: '%s'", drvname);
1445 ret = -EINVAL;
1446 goto fail;
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);
1470 if (local_err) {
1471 ret = -EINVAL;
1472 goto fail;
1476 /* Image format probing */
1477 bs->probed = !drv;
1478 if (!drv && file) {
1479 ret = find_image_format(file->bs, filename, &drv, &local_err);
1480 if (ret < 0) {
1481 goto fail;
1483 } else if (!drv) {
1484 error_setg(errp, "Must specify either driver or file");
1485 ret = -EINVAL;
1486 goto fail;
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);
1497 if (ret < 0) {
1498 goto fail;
1501 if (file && (bs->file != file)) {
1502 bdrv_unref_child(bs, file);
1503 file = NULL;
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);
1512 if (ret < 0) {
1513 goto close_and_fail;
1517 bdrv_refresh_filename(bs);
1519 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1520 * temporary snapshot afterwards. */
1521 if (snapshot_flags) {
1522 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1523 if (local_err) {
1524 goto close_and_fail;
1528 /* Check if any unknown options were used */
1529 if (options && (qdict_size(options) != 0)) {
1530 const QDictEntry *entry = qdict_first(options);
1531 if (flags & BDRV_O_PROTOCOL) {
1532 error_setg(errp, "Block protocol '%s' doesn't support the option "
1533 "'%s'", drv->format_name, entry->key);
1534 } else {
1535 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1536 "support the option '%s'", drv->format_name,
1537 bdrv_get_device_name(bs), entry->key);
1540 ret = -EINVAL;
1541 goto close_and_fail;
1544 if (!bdrv_key_required(bs)) {
1545 if (bs->blk) {
1546 blk_dev_change_media_cb(bs->blk, true);
1548 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1549 && !runstate_check(RUN_STATE_INMIGRATE)
1550 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1551 error_setg(errp,
1552 "Guest must be stopped for opening of encrypted image");
1553 ret = -EBUSY;
1554 goto close_and_fail;
1557 QDECREF(options);
1558 *pbs = bs;
1559 return 0;
1561 fail:
1562 if (file != NULL) {
1563 bdrv_unref_child(bs, file);
1565 QDECREF(bs->options);
1566 QDECREF(options);
1567 bs->options = NULL;
1568 if (!*pbs) {
1569 /* If *pbs is NULL, a new BDS has been created in this function and
1570 needs to be freed now. Otherwise, it does not need to be closed,
1571 since it has not really been opened yet. */
1572 bdrv_unref(bs);
1574 if (local_err) {
1575 error_propagate(errp, local_err);
1577 return ret;
1579 close_and_fail:
1580 /* See fail path, but now the BDS has to be always closed */
1581 if (*pbs) {
1582 bdrv_close(bs);
1583 } else {
1584 bdrv_unref(bs);
1586 QDECREF(options);
1587 if (local_err) {
1588 error_propagate(errp, local_err);
1590 return ret;
1593 int bdrv_open(BlockDriverState **pbs, const char *filename,
1594 const char *reference, QDict *options, int flags, Error **errp)
1596 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1597 NULL, errp);
1600 typedef struct BlockReopenQueueEntry {
1601 bool prepared;
1602 BDRVReopenState state;
1603 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1604 } BlockReopenQueueEntry;
1607 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1608 * reopen of multiple devices.
1610 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1611 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1612 * be created and initialized. This newly created BlockReopenQueue should be
1613 * passed back in for subsequent calls that are intended to be of the same
1614 * atomic 'set'.
1616 * bs is the BlockDriverState to add to the reopen queue.
1618 * options contains the changed options for the associated bs
1619 * (the BlockReopenQueue takes ownership)
1621 * flags contains the open flags for the associated bs
1623 * returns a pointer to bs_queue, which is either the newly allocated
1624 * bs_queue, or the existing bs_queue being used.
1627 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1628 BlockDriverState *bs,
1629 QDict *options, int flags)
1631 assert(bs != NULL);
1633 BlockReopenQueueEntry *bs_entry;
1634 BdrvChild *child;
1635 QDict *old_options;
1637 if (bs_queue == NULL) {
1638 bs_queue = g_new0(BlockReopenQueue, 1);
1639 QSIMPLEQ_INIT(bs_queue);
1642 if (!options) {
1643 options = qdict_new();
1646 old_options = qdict_clone_shallow(bs->options);
1647 qdict_join(options, old_options, false);
1648 QDECREF(old_options);
1650 /* bdrv_open() masks this flag out */
1651 flags &= ~BDRV_O_PROTOCOL;
1653 QLIST_FOREACH(child, &bs->children, next) {
1654 int child_flags;
1656 if (child->bs->inherits_from != bs) {
1657 continue;
1660 child_flags = child->role->inherit_flags(flags);
1661 /* TODO Pass down child flags (backing.*, extents.*, ...) */
1662 bdrv_reopen_queue(bs_queue, child->bs, NULL, child_flags);
1665 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1666 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1668 bs_entry->state.bs = bs;
1669 bs_entry->state.options = options;
1670 bs_entry->state.flags = flags;
1672 return bs_queue;
1676 * Reopen multiple BlockDriverStates atomically & transactionally.
1678 * The queue passed in (bs_queue) must have been built up previous
1679 * via bdrv_reopen_queue().
1681 * Reopens all BDS specified in the queue, with the appropriate
1682 * flags. All devices are prepared for reopen, and failure of any
1683 * device will cause all device changes to be abandonded, and intermediate
1684 * data cleaned up.
1686 * If all devices prepare successfully, then the changes are committed
1687 * to all devices.
1690 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1692 int ret = -1;
1693 BlockReopenQueueEntry *bs_entry, *next;
1694 Error *local_err = NULL;
1696 assert(bs_queue != NULL);
1698 bdrv_drain_all();
1700 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1701 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1702 error_propagate(errp, local_err);
1703 goto cleanup;
1705 bs_entry->prepared = true;
1708 /* If we reach this point, we have success and just need to apply the
1709 * changes
1711 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1712 bdrv_reopen_commit(&bs_entry->state);
1715 ret = 0;
1717 cleanup:
1718 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1719 if (ret && bs_entry->prepared) {
1720 bdrv_reopen_abort(&bs_entry->state);
1722 QDECREF(bs_entry->state.options);
1723 g_free(bs_entry);
1725 g_free(bs_queue);
1726 return ret;
1730 /* Reopen a single BlockDriverState with the specified flags. */
1731 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1733 int ret = -1;
1734 Error *local_err = NULL;
1735 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1737 ret = bdrv_reopen_multiple(queue, &local_err);
1738 if (local_err != NULL) {
1739 error_propagate(errp, local_err);
1741 return ret;
1746 * Prepares a BlockDriverState for reopen. All changes are staged in the
1747 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1748 * the block driver layer .bdrv_reopen_prepare()
1750 * bs is the BlockDriverState to reopen
1751 * flags are the new open flags
1752 * queue is the reopen queue
1754 * Returns 0 on success, non-zero on error. On error errp will be set
1755 * as well.
1757 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1758 * It is the responsibility of the caller to then call the abort() or
1759 * commit() for any other BDS that have been left in a prepare() state
1762 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1763 Error **errp)
1765 int ret = -1;
1766 Error *local_err = NULL;
1767 BlockDriver *drv;
1769 assert(reopen_state != NULL);
1770 assert(reopen_state->bs->drv != NULL);
1771 drv = reopen_state->bs->drv;
1773 /* if we are to stay read-only, do not allow permission change
1774 * to r/w */
1775 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1776 reopen_state->flags & BDRV_O_RDWR) {
1777 error_setg(errp, "Node '%s' is read only",
1778 bdrv_get_device_or_node_name(reopen_state->bs));
1779 goto error;
1783 ret = bdrv_flush(reopen_state->bs);
1784 if (ret) {
1785 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1786 strerror(-ret));
1787 goto error;
1790 if (drv->bdrv_reopen_prepare) {
1791 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1792 if (ret) {
1793 if (local_err != NULL) {
1794 error_propagate(errp, local_err);
1795 } else {
1796 error_setg(errp, "failed while preparing to reopen image '%s'",
1797 reopen_state->bs->filename);
1799 goto error;
1801 } else {
1802 /* It is currently mandatory to have a bdrv_reopen_prepare()
1803 * handler for each supported drv. */
1804 error_setg(errp, "Block format '%s' used by node '%s' "
1805 "does not support reopening files", drv->format_name,
1806 bdrv_get_device_or_node_name(reopen_state->bs));
1807 ret = -1;
1808 goto error;
1811 /* Options that are not handled are only okay if they are unchanged
1812 * compared to the old state. It is expected that some options are only
1813 * used for the initial open, but not reopen (e.g. filename) */
1814 if (qdict_size(reopen_state->options)) {
1815 const QDictEntry *entry = qdict_first(reopen_state->options);
1817 do {
1818 QString *new_obj = qobject_to_qstring(entry->value);
1819 const char *new = qstring_get_str(new_obj);
1820 const char *old = qdict_get_try_str(reopen_state->bs->options,
1821 entry->key);
1823 if (!old || strcmp(new, old)) {
1824 error_setg(errp, "Cannot change the option '%s'", entry->key);
1825 ret = -EINVAL;
1826 goto error;
1828 } while ((entry = qdict_next(reopen_state->options, entry)));
1831 ret = 0;
1833 error:
1834 return ret;
1838 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1839 * makes them final by swapping the staging BlockDriverState contents into
1840 * the active BlockDriverState contents.
1842 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1844 BlockDriver *drv;
1846 assert(reopen_state != NULL);
1847 drv = reopen_state->bs->drv;
1848 assert(drv != NULL);
1850 /* If there are any driver level actions to take */
1851 if (drv->bdrv_reopen_commit) {
1852 drv->bdrv_reopen_commit(reopen_state);
1855 /* set BDS specific flags now */
1856 reopen_state->bs->open_flags = reopen_state->flags;
1857 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1858 BDRV_O_CACHE_WB);
1859 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1861 bdrv_refresh_limits(reopen_state->bs, NULL);
1865 * Abort the reopen, and delete and free the staged changes in
1866 * reopen_state
1868 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1870 BlockDriver *drv;
1872 assert(reopen_state != NULL);
1873 drv = reopen_state->bs->drv;
1874 assert(drv != NULL);
1876 if (drv->bdrv_reopen_abort) {
1877 drv->bdrv_reopen_abort(reopen_state);
1882 void bdrv_close(BlockDriverState *bs)
1884 BdrvAioNotifier *ban, *ban_next;
1886 if (bs->job) {
1887 block_job_cancel_sync(bs->job);
1890 /* Disable I/O limits and drain all pending throttled requests */
1891 if (bs->io_limits_enabled) {
1892 bdrv_io_limits_disable(bs);
1895 bdrv_drain(bs); /* complete I/O */
1896 bdrv_flush(bs);
1897 bdrv_drain(bs); /* in case flush left pending I/O */
1898 notifier_list_notify(&bs->close_notifiers, bs);
1900 if (bs->drv) {
1901 BdrvChild *child, *next;
1903 bs->drv->bdrv_close(bs);
1904 bs->drv = NULL;
1906 bdrv_set_backing_hd(bs, NULL);
1908 if (bs->file != NULL) {
1909 bdrv_unref_child(bs, bs->file);
1910 bs->file = NULL;
1913 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1914 /* TODO Remove bdrv_unref() from drivers' close function and use
1915 * bdrv_unref_child() here */
1916 if (child->bs->inherits_from == bs) {
1917 child->bs->inherits_from = NULL;
1919 bdrv_detach_child(child);
1922 g_free(bs->opaque);
1923 bs->opaque = NULL;
1924 bs->copy_on_read = 0;
1925 bs->backing_file[0] = '\0';
1926 bs->backing_format[0] = '\0';
1927 bs->total_sectors = 0;
1928 bs->encrypted = 0;
1929 bs->valid_key = 0;
1930 bs->sg = 0;
1931 bs->zero_beyond_eof = false;
1932 QDECREF(bs->options);
1933 bs->options = NULL;
1934 QDECREF(bs->full_open_options);
1935 bs->full_open_options = NULL;
1938 if (bs->blk) {
1939 blk_dev_change_media_cb(bs->blk, false);
1942 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1943 g_free(ban);
1945 QLIST_INIT(&bs->aio_notifiers);
1948 void bdrv_close_all(void)
1950 BlockDriverState *bs;
1952 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1953 AioContext *aio_context = bdrv_get_aio_context(bs);
1955 aio_context_acquire(aio_context);
1956 bdrv_close(bs);
1957 aio_context_release(aio_context);
1961 /* make a BlockDriverState anonymous by removing from bdrv_state and
1962 * graph_bdrv_state list.
1963 Also, NULL terminate the device_name to prevent double remove */
1964 void bdrv_make_anon(BlockDriverState *bs)
1967 * Take care to remove bs from bdrv_states only when it's actually
1968 * in it. Note that bs->device_list.tqe_prev is initially null,
1969 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1970 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1971 * resetting it to null on remove.
1973 if (bs->device_list.tqe_prev) {
1974 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1975 bs->device_list.tqe_prev = NULL;
1977 if (bs->node_name[0] != '\0') {
1978 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1980 bs->node_name[0] = '\0';
1983 static void bdrv_rebind(BlockDriverState *bs)
1985 if (bs->drv && bs->drv->bdrv_rebind) {
1986 bs->drv->bdrv_rebind(bs);
1990 /* Fields that need to stay with the top-level BDS, no matter whether the
1991 * address of the top-level BDS stays the same or not. */
1992 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1993 BlockDriverState *bs_src)
1995 /* move some fields that need to stay attached to the device */
1997 /* dev info */
1998 bs_dest->guest_block_size = bs_src->guest_block_size;
1999 bs_dest->copy_on_read = bs_src->copy_on_read;
2001 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2003 /* i/o throttled req */
2004 bs_dest->throttle_state = bs_src->throttle_state,
2005 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
2006 bs_dest->pending_reqs[0] = bs_src->pending_reqs[0];
2007 bs_dest->pending_reqs[1] = bs_src->pending_reqs[1];
2008 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
2009 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
2010 memcpy(&bs_dest->round_robin,
2011 &bs_src->round_robin,
2012 sizeof(bs_dest->round_robin));
2013 memcpy(&bs_dest->throttle_timers,
2014 &bs_src->throttle_timers,
2015 sizeof(ThrottleTimers));
2017 /* r/w error */
2018 bs_dest->on_read_error = bs_src->on_read_error;
2019 bs_dest->on_write_error = bs_src->on_write_error;
2021 /* i/o status */
2022 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
2023 bs_dest->iostatus = bs_src->iostatus;
2025 /* dirty bitmap */
2026 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2029 /* Fields that only need to be swapped if the contents of BDSes is swapped
2030 * rather than pointers being changed in the parents. */
2031 static void bdrv_move_reference_fields(BlockDriverState *bs_dest,
2032 BlockDriverState *bs_src)
2034 /* reference count */
2035 bs_dest->refcnt = bs_src->refcnt;
2037 /* job */
2038 bs_dest->job = bs_src->job;
2040 /* keep the same entry in bdrv_states */
2041 bs_dest->device_list = bs_src->device_list;
2042 bs_dest->blk = bs_src->blk;
2043 bs_dest->parents = bs_src->parents;
2045 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2046 sizeof(bs_dest->op_blockers));
2050 * Swap bs contents for two image chains while they are live,
2051 * while keeping required fields on the BlockDriverState that is
2052 * actually attached to a device.
2054 * This will modify the BlockDriverState fields, and swap contents
2055 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2057 * bs_new must not be attached to a BlockBackend.
2059 * This function does not create any image files.
2061 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2063 BlockDriverState tmp;
2064 BdrvChild *child;
2066 bdrv_drain(bs_new);
2067 bdrv_drain(bs_old);
2069 /* The code needs to swap the node_name but simply swapping node_list won't
2070 * work so first remove the nodes from the graph list, do the swap then
2071 * insert them back if needed.
2073 if (bs_new->node_name[0] != '\0') {
2074 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2076 if (bs_old->node_name[0] != '\0') {
2077 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2080 /* If the BlockDriverState is part of a throttling group acquire
2081 * its lock since we're going to mess with the protected fields.
2082 * Otherwise there's no need to worry since no one else can touch
2083 * them. */
2084 if (bs_old->throttle_state) {
2085 throttle_group_lock(bs_old);
2088 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2089 assert(!bs_new->blk);
2090 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2091 assert(bs_new->job == NULL);
2092 assert(bs_new->io_limits_enabled == false);
2093 assert(bs_new->throttle_state == NULL);
2094 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2096 tmp = *bs_new;
2097 *bs_new = *bs_old;
2098 *bs_old = tmp;
2100 /* there are some fields that should not be swapped, move them back */
2101 bdrv_move_feature_fields(&tmp, bs_old);
2102 bdrv_move_feature_fields(bs_old, bs_new);
2103 bdrv_move_feature_fields(bs_new, &tmp);
2105 bdrv_move_reference_fields(&tmp, bs_old);
2106 bdrv_move_reference_fields(bs_old, bs_new);
2107 bdrv_move_reference_fields(bs_new, &tmp);
2109 /* bs_new must remain unattached */
2110 assert(!bs_new->blk);
2112 /* Check a few fields that should remain attached to the device */
2113 assert(bs_new->job == NULL);
2114 assert(bs_new->io_limits_enabled == false);
2115 assert(bs_new->throttle_state == NULL);
2116 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2118 /* Release the ThrottleGroup lock */
2119 if (bs_old->throttle_state) {
2120 throttle_group_unlock(bs_old);
2123 /* insert the nodes back into the graph node list if needed */
2124 if (bs_new->node_name[0] != '\0') {
2125 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2127 if (bs_old->node_name[0] != '\0') {
2128 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2132 * Update lh_first.le_prev for non-empty lists.
2134 * The head of the op blocker list doesn't change because it is moved back
2135 * in bdrv_move_feature_fields().
2137 assert(QLIST_EMPTY(&bs_old->tracked_requests));
2138 assert(QLIST_EMPTY(&bs_new->tracked_requests));
2140 QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2141 QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2143 /* Update references in bs->opaque and children */
2144 QLIST_FOREACH(child, &bs_old->children, next) {
2145 if (child->bs->inherits_from == bs_new) {
2146 child->bs->inherits_from = bs_old;
2149 QLIST_FOREACH(child, &bs_new->children, next) {
2150 if (child->bs->inherits_from == bs_old) {
2151 child->bs->inherits_from = bs_new;
2155 bdrv_rebind(bs_new);
2156 bdrv_rebind(bs_old);
2160 * Add new bs contents at the top of an image chain while the chain is
2161 * live, while keeping required fields on the top layer.
2163 * This will modify the BlockDriverState fields, and swap contents
2164 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2166 * bs_new must not be attached to a BlockBackend.
2168 * This function does not create any image files.
2170 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2172 bdrv_swap(bs_new, bs_top);
2174 /* The contents of 'tmp' will become bs_top, as we are
2175 * swapping bs_new and bs_top contents. */
2176 bdrv_set_backing_hd(bs_top, bs_new);
2179 static void bdrv_delete(BlockDriverState *bs)
2181 assert(!bs->job);
2182 assert(bdrv_op_blocker_is_empty(bs));
2183 assert(!bs->refcnt);
2184 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2186 bdrv_close(bs);
2188 /* remove from list, if necessary */
2189 bdrv_make_anon(bs);
2191 g_free(bs);
2195 * Run consistency checks on an image
2197 * Returns 0 if the check could be completed (it doesn't mean that the image is
2198 * free of errors) or -errno when an internal error occurred. The results of the
2199 * check are stored in res.
2201 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2203 if (bs->drv == NULL) {
2204 return -ENOMEDIUM;
2206 if (bs->drv->bdrv_check == NULL) {
2207 return -ENOTSUP;
2210 memset(res, 0, sizeof(*res));
2211 return bs->drv->bdrv_check(bs, res, fix);
2214 #define COMMIT_BUF_SECTORS 2048
2216 /* commit COW file into the raw image */
2217 int bdrv_commit(BlockDriverState *bs)
2219 BlockDriver *drv = bs->drv;
2220 int64_t sector, total_sectors, length, backing_length;
2221 int n, ro, open_flags;
2222 int ret = 0;
2223 uint8_t *buf = NULL;
2225 if (!drv)
2226 return -ENOMEDIUM;
2228 if (!bs->backing) {
2229 return -ENOTSUP;
2232 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2233 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2234 return -EBUSY;
2237 ro = bs->backing->bs->read_only;
2238 open_flags = bs->backing->bs->open_flags;
2240 if (ro) {
2241 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2242 return -EACCES;
2246 length = bdrv_getlength(bs);
2247 if (length < 0) {
2248 ret = length;
2249 goto ro_cleanup;
2252 backing_length = bdrv_getlength(bs->backing->bs);
2253 if (backing_length < 0) {
2254 ret = backing_length;
2255 goto ro_cleanup;
2258 /* If our top snapshot is larger than the backing file image,
2259 * grow the backing file image if possible. If not possible,
2260 * we must return an error */
2261 if (length > backing_length) {
2262 ret = bdrv_truncate(bs->backing->bs, length);
2263 if (ret < 0) {
2264 goto ro_cleanup;
2268 total_sectors = length >> BDRV_SECTOR_BITS;
2270 /* qemu_try_blockalign() for bs will choose an alignment that works for
2271 * bs->backing->bs as well, so no need to compare the alignment manually. */
2272 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2273 if (buf == NULL) {
2274 ret = -ENOMEM;
2275 goto ro_cleanup;
2278 for (sector = 0; sector < total_sectors; sector += n) {
2279 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2280 if (ret < 0) {
2281 goto ro_cleanup;
2283 if (ret) {
2284 ret = bdrv_read(bs, sector, buf, n);
2285 if (ret < 0) {
2286 goto ro_cleanup;
2289 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2290 if (ret < 0) {
2291 goto ro_cleanup;
2296 if (drv->bdrv_make_empty) {
2297 ret = drv->bdrv_make_empty(bs);
2298 if (ret < 0) {
2299 goto ro_cleanup;
2301 bdrv_flush(bs);
2305 * Make sure all data we wrote to the backing device is actually
2306 * stable on disk.
2308 if (bs->backing) {
2309 bdrv_flush(bs->backing->bs);
2312 ret = 0;
2313 ro_cleanup:
2314 qemu_vfree(buf);
2316 if (ro) {
2317 /* ignoring error return here */
2318 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2321 return ret;
2324 int bdrv_commit_all(void)
2326 BlockDriverState *bs;
2328 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2329 AioContext *aio_context = bdrv_get_aio_context(bs);
2331 aio_context_acquire(aio_context);
2332 if (bs->drv && bs->backing) {
2333 int ret = bdrv_commit(bs);
2334 if (ret < 0) {
2335 aio_context_release(aio_context);
2336 return ret;
2339 aio_context_release(aio_context);
2341 return 0;
2345 * Return values:
2346 * 0 - success
2347 * -EINVAL - backing format specified, but no file
2348 * -ENOSPC - can't update the backing file because no space is left in the
2349 * image file header
2350 * -ENOTSUP - format driver doesn't support changing the backing file
2352 int bdrv_change_backing_file(BlockDriverState *bs,
2353 const char *backing_file, const char *backing_fmt)
2355 BlockDriver *drv = bs->drv;
2356 int ret;
2358 /* Backing file format doesn't make sense without a backing file */
2359 if (backing_fmt && !backing_file) {
2360 return -EINVAL;
2363 if (drv->bdrv_change_backing_file != NULL) {
2364 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2365 } else {
2366 ret = -ENOTSUP;
2369 if (ret == 0) {
2370 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2371 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2373 return ret;
2377 * Finds the image layer in the chain that has 'bs' as its backing file.
2379 * active is the current topmost image.
2381 * Returns NULL if bs is not found in active's image chain,
2382 * or if active == bs.
2384 * Returns the bottommost base image if bs == NULL.
2386 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2387 BlockDriverState *bs)
2389 while (active && bs != backing_bs(active)) {
2390 active = backing_bs(active);
2393 return active;
2396 /* Given a BDS, searches for the base layer. */
2397 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2399 return bdrv_find_overlay(bs, NULL);
2403 * Drops images above 'base' up to and including 'top', and sets the image
2404 * above 'top' to have base as its backing file.
2406 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2407 * information in 'bs' can be properly updated.
2409 * E.g., this will convert the following chain:
2410 * bottom <- base <- intermediate <- top <- active
2412 * to
2414 * bottom <- base <- active
2416 * It is allowed for bottom==base, in which case it converts:
2418 * base <- intermediate <- top <- active
2420 * to
2422 * base <- active
2424 * If backing_file_str is non-NULL, it will be used when modifying top's
2425 * overlay image metadata.
2427 * Error conditions:
2428 * if active == top, that is considered an error
2431 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2432 BlockDriverState *base, const char *backing_file_str)
2434 BlockDriverState *new_top_bs = NULL;
2435 int ret = -EIO;
2437 if (!top->drv || !base->drv) {
2438 goto exit;
2441 new_top_bs = bdrv_find_overlay(active, top);
2443 if (new_top_bs == NULL) {
2444 /* we could not find the image above 'top', this is an error */
2445 goto exit;
2448 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2449 * to do, no intermediate images */
2450 if (backing_bs(new_top_bs) == base) {
2451 ret = 0;
2452 goto exit;
2455 /* Make sure that base is in the backing chain of top */
2456 if (!bdrv_chain_contains(top, base)) {
2457 goto exit;
2460 /* success - we can delete the intermediate states, and link top->base */
2461 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2462 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2463 base->drv ? base->drv->format_name : "");
2464 if (ret) {
2465 goto exit;
2467 bdrv_set_backing_hd(new_top_bs, base);
2469 ret = 0;
2470 exit:
2471 return ret;
2475 * Truncate file to 'offset' bytes (needed only for file protocols)
2477 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2479 BlockDriver *drv = bs->drv;
2480 int ret;
2481 if (!drv)
2482 return -ENOMEDIUM;
2483 if (!drv->bdrv_truncate)
2484 return -ENOTSUP;
2485 if (bs->read_only)
2486 return -EACCES;
2488 ret = drv->bdrv_truncate(bs, offset);
2489 if (ret == 0) {
2490 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2491 bdrv_dirty_bitmap_truncate(bs);
2492 if (bs->blk) {
2493 blk_dev_resize_cb(bs->blk);
2496 return ret;
2500 * Length of a allocated file in bytes. Sparse files are counted by actual
2501 * allocated space. Return < 0 if error or unknown.
2503 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2505 BlockDriver *drv = bs->drv;
2506 if (!drv) {
2507 return -ENOMEDIUM;
2509 if (drv->bdrv_get_allocated_file_size) {
2510 return drv->bdrv_get_allocated_file_size(bs);
2512 if (bs->file) {
2513 return bdrv_get_allocated_file_size(bs->file->bs);
2515 return -ENOTSUP;
2519 * Return number of sectors on success, -errno on error.
2521 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2523 BlockDriver *drv = bs->drv;
2525 if (!drv)
2526 return -ENOMEDIUM;
2528 if (drv->has_variable_length) {
2529 int ret = refresh_total_sectors(bs, bs->total_sectors);
2530 if (ret < 0) {
2531 return ret;
2534 return bs->total_sectors;
2538 * Return length in bytes on success, -errno on error.
2539 * The length is always a multiple of BDRV_SECTOR_SIZE.
2541 int64_t bdrv_getlength(BlockDriverState *bs)
2543 int64_t ret = bdrv_nb_sectors(bs);
2545 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2546 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2549 /* return 0 as number of sectors if no device present or error */
2550 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2552 int64_t nb_sectors = bdrv_nb_sectors(bs);
2554 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2557 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2558 BlockdevOnError on_write_error)
2560 bs->on_read_error = on_read_error;
2561 bs->on_write_error = on_write_error;
2564 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2566 return is_read ? bs->on_read_error : bs->on_write_error;
2569 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2571 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2573 switch (on_err) {
2574 case BLOCKDEV_ON_ERROR_ENOSPC:
2575 return (error == ENOSPC) ?
2576 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2577 case BLOCKDEV_ON_ERROR_STOP:
2578 return BLOCK_ERROR_ACTION_STOP;
2579 case BLOCKDEV_ON_ERROR_REPORT:
2580 return BLOCK_ERROR_ACTION_REPORT;
2581 case BLOCKDEV_ON_ERROR_IGNORE:
2582 return BLOCK_ERROR_ACTION_IGNORE;
2583 default:
2584 abort();
2588 static void send_qmp_error_event(BlockDriverState *bs,
2589 BlockErrorAction action,
2590 bool is_read, int error)
2592 IoOperationType optype;
2594 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2595 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2596 bdrv_iostatus_is_enabled(bs),
2597 error == ENOSPC, strerror(error),
2598 &error_abort);
2601 /* This is done by device models because, while the block layer knows
2602 * about the error, it does not know whether an operation comes from
2603 * the device or the block layer (from a job, for example).
2605 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2606 bool is_read, int error)
2608 assert(error >= 0);
2610 if (action == BLOCK_ERROR_ACTION_STOP) {
2611 /* First set the iostatus, so that "info block" returns an iostatus
2612 * that matches the events raised so far (an additional error iostatus
2613 * is fine, but not a lost one).
2615 bdrv_iostatus_set_err(bs, error);
2617 /* Then raise the request to stop the VM and the event.
2618 * qemu_system_vmstop_request_prepare has two effects. First,
2619 * it ensures that the STOP event always comes after the
2620 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2621 * can observe the STOP event and do a "cont" before the STOP
2622 * event is issued, the VM will not stop. In this case, vm_start()
2623 * also ensures that the STOP/RESUME pair of events is emitted.
2625 qemu_system_vmstop_request_prepare();
2626 send_qmp_error_event(bs, action, is_read, error);
2627 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2628 } else {
2629 send_qmp_error_event(bs, action, is_read, error);
2633 int bdrv_is_read_only(BlockDriverState *bs)
2635 return bs->read_only;
2638 int bdrv_is_sg(BlockDriverState *bs)
2640 return bs->sg;
2643 int bdrv_enable_write_cache(BlockDriverState *bs)
2645 return bs->enable_write_cache;
2648 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2650 bs->enable_write_cache = wce;
2652 /* so a reopen() will preserve wce */
2653 if (wce) {
2654 bs->open_flags |= BDRV_O_CACHE_WB;
2655 } else {
2656 bs->open_flags &= ~BDRV_O_CACHE_WB;
2660 int bdrv_is_encrypted(BlockDriverState *bs)
2662 if (bs->backing && bs->backing->bs->encrypted) {
2663 return 1;
2665 return bs->encrypted;
2668 int bdrv_key_required(BlockDriverState *bs)
2670 BdrvChild *backing = bs->backing;
2672 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2673 return 1;
2675 return (bs->encrypted && !bs->valid_key);
2678 int bdrv_set_key(BlockDriverState *bs, const char *key)
2680 int ret;
2681 if (bs->backing && bs->backing->bs->encrypted) {
2682 ret = bdrv_set_key(bs->backing->bs, key);
2683 if (ret < 0)
2684 return ret;
2685 if (!bs->encrypted)
2686 return 0;
2688 if (!bs->encrypted) {
2689 return -EINVAL;
2690 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2691 return -ENOMEDIUM;
2693 ret = bs->drv->bdrv_set_key(bs, key);
2694 if (ret < 0) {
2695 bs->valid_key = 0;
2696 } else if (!bs->valid_key) {
2697 bs->valid_key = 1;
2698 if (bs->blk) {
2699 /* call the change callback now, we skipped it on open */
2700 blk_dev_change_media_cb(bs->blk, true);
2703 return ret;
2707 * Provide an encryption key for @bs.
2708 * If @key is non-null:
2709 * If @bs is not encrypted, fail.
2710 * Else if the key is invalid, fail.
2711 * Else set @bs's key to @key, replacing the existing key, if any.
2712 * If @key is null:
2713 * If @bs is encrypted and still lacks a key, fail.
2714 * Else do nothing.
2715 * On failure, store an error object through @errp if non-null.
2717 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2719 if (key) {
2720 if (!bdrv_is_encrypted(bs)) {
2721 error_setg(errp, "Node '%s' is not encrypted",
2722 bdrv_get_device_or_node_name(bs));
2723 } else if (bdrv_set_key(bs, key) < 0) {
2724 error_setg(errp, QERR_INVALID_PASSWORD);
2726 } else {
2727 if (bdrv_key_required(bs)) {
2728 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2729 "'%s' (%s) is encrypted",
2730 bdrv_get_device_or_node_name(bs),
2731 bdrv_get_encrypted_filename(bs));
2736 const char *bdrv_get_format_name(BlockDriverState *bs)
2738 return bs->drv ? bs->drv->format_name : NULL;
2741 static int qsort_strcmp(const void *a, const void *b)
2743 return strcmp(a, b);
2746 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2747 void *opaque)
2749 BlockDriver *drv;
2750 int count = 0;
2751 int i;
2752 const char **formats = NULL;
2754 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2755 if (drv->format_name) {
2756 bool found = false;
2757 int i = count;
2758 while (formats && i && !found) {
2759 found = !strcmp(formats[--i], drv->format_name);
2762 if (!found) {
2763 formats = g_renew(const char *, formats, count + 1);
2764 formats[count++] = drv->format_name;
2769 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2771 for (i = 0; i < count; i++) {
2772 it(opaque, formats[i]);
2775 g_free(formats);
2778 /* This function is to find a node in the bs graph */
2779 BlockDriverState *bdrv_find_node(const char *node_name)
2781 BlockDriverState *bs;
2783 assert(node_name);
2785 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2786 if (!strcmp(node_name, bs->node_name)) {
2787 return bs;
2790 return NULL;
2793 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2794 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2796 BlockDeviceInfoList *list, *entry;
2797 BlockDriverState *bs;
2799 list = NULL;
2800 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2801 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2802 if (!info) {
2803 qapi_free_BlockDeviceInfoList(list);
2804 return NULL;
2806 entry = g_malloc0(sizeof(*entry));
2807 entry->value = info;
2808 entry->next = list;
2809 list = entry;
2812 return list;
2815 BlockDriverState *bdrv_lookup_bs(const char *device,
2816 const char *node_name,
2817 Error **errp)
2819 BlockBackend *blk;
2820 BlockDriverState *bs;
2822 if (device) {
2823 blk = blk_by_name(device);
2825 if (blk) {
2826 return blk_bs(blk);
2830 if (node_name) {
2831 bs = bdrv_find_node(node_name);
2833 if (bs) {
2834 return bs;
2838 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2839 device ? device : "",
2840 node_name ? node_name : "");
2841 return NULL;
2844 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2845 * return false. If either argument is NULL, return false. */
2846 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2848 while (top && top != base) {
2849 top = backing_bs(top);
2852 return top != NULL;
2855 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2857 if (!bs) {
2858 return QTAILQ_FIRST(&graph_bdrv_states);
2860 return QTAILQ_NEXT(bs, node_list);
2863 BlockDriverState *bdrv_next(BlockDriverState *bs)
2865 if (!bs) {
2866 return QTAILQ_FIRST(&bdrv_states);
2868 return QTAILQ_NEXT(bs, device_list);
2871 const char *bdrv_get_node_name(const BlockDriverState *bs)
2873 return bs->node_name;
2876 /* TODO check what callers really want: bs->node_name or blk_name() */
2877 const char *bdrv_get_device_name(const BlockDriverState *bs)
2879 return bs->blk ? blk_name(bs->blk) : "";
2882 /* This can be used to identify nodes that might not have a device
2883 * name associated. Since node and device names live in the same
2884 * namespace, the result is unambiguous. The exception is if both are
2885 * absent, then this returns an empty (non-null) string. */
2886 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2888 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2891 int bdrv_get_flags(BlockDriverState *bs)
2893 return bs->open_flags;
2896 int bdrv_has_zero_init_1(BlockDriverState *bs)
2898 return 1;
2901 int bdrv_has_zero_init(BlockDriverState *bs)
2903 assert(bs->drv);
2905 /* If BS is a copy on write image, it is initialized to
2906 the contents of the base image, which may not be zeroes. */
2907 if (bs->backing) {
2908 return 0;
2910 if (bs->drv->bdrv_has_zero_init) {
2911 return bs->drv->bdrv_has_zero_init(bs);
2914 /* safe default */
2915 return 0;
2918 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2920 BlockDriverInfo bdi;
2922 if (bs->backing) {
2923 return false;
2926 if (bdrv_get_info(bs, &bdi) == 0) {
2927 return bdi.unallocated_blocks_are_zero;
2930 return false;
2933 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2935 BlockDriverInfo bdi;
2937 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
2938 return false;
2941 if (bdrv_get_info(bs, &bdi) == 0) {
2942 return bdi.can_write_zeroes_with_unmap;
2945 return false;
2948 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2950 if (bs->backing && bs->backing->bs->encrypted)
2951 return bs->backing_file;
2952 else if (bs->encrypted)
2953 return bs->filename;
2954 else
2955 return NULL;
2958 void bdrv_get_backing_filename(BlockDriverState *bs,
2959 char *filename, int filename_size)
2961 pstrcpy(filename, filename_size, bs->backing_file);
2964 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2966 BlockDriver *drv = bs->drv;
2967 if (!drv)
2968 return -ENOMEDIUM;
2969 if (!drv->bdrv_get_info)
2970 return -ENOTSUP;
2971 memset(bdi, 0, sizeof(*bdi));
2972 return drv->bdrv_get_info(bs, bdi);
2975 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2977 BlockDriver *drv = bs->drv;
2978 if (drv && drv->bdrv_get_specific_info) {
2979 return drv->bdrv_get_specific_info(bs);
2981 return NULL;
2984 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2986 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2987 return;
2990 bs->drv->bdrv_debug_event(bs, event);
2993 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
2994 const char *tag)
2996 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
2997 bs = bs->file ? bs->file->bs : NULL;
3000 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3001 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3004 return -ENOTSUP;
3007 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3009 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3010 bs = bs->file ? bs->file->bs : NULL;
3013 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3014 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3017 return -ENOTSUP;
3020 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3022 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3023 bs = bs->file ? bs->file->bs : NULL;
3026 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3027 return bs->drv->bdrv_debug_resume(bs, tag);
3030 return -ENOTSUP;
3033 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3035 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3036 bs = bs->file ? bs->file->bs : NULL;
3039 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3040 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3043 return false;
3046 int bdrv_is_snapshot(BlockDriverState *bs)
3048 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3051 /* backing_file can either be relative, or absolute, or a protocol. If it is
3052 * relative, it must be relative to the chain. So, passing in bs->filename
3053 * from a BDS as backing_file should not be done, as that may be relative to
3054 * the CWD rather than the chain. */
3055 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3056 const char *backing_file)
3058 char *filename_full = NULL;
3059 char *backing_file_full = NULL;
3060 char *filename_tmp = NULL;
3061 int is_protocol = 0;
3062 BlockDriverState *curr_bs = NULL;
3063 BlockDriverState *retval = NULL;
3065 if (!bs || !bs->drv || !backing_file) {
3066 return NULL;
3069 filename_full = g_malloc(PATH_MAX);
3070 backing_file_full = g_malloc(PATH_MAX);
3071 filename_tmp = g_malloc(PATH_MAX);
3073 is_protocol = path_has_protocol(backing_file);
3075 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3077 /* If either of the filename paths is actually a protocol, then
3078 * compare unmodified paths; otherwise make paths relative */
3079 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3080 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3081 retval = curr_bs->backing->bs;
3082 break;
3084 } else {
3085 /* If not an absolute filename path, make it relative to the current
3086 * image's filename path */
3087 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3088 backing_file);
3090 /* We are going to compare absolute pathnames */
3091 if (!realpath(filename_tmp, filename_full)) {
3092 continue;
3095 /* We need to make sure the backing filename we are comparing against
3096 * is relative to the current image filename (or absolute) */
3097 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3098 curr_bs->backing_file);
3100 if (!realpath(filename_tmp, backing_file_full)) {
3101 continue;
3104 if (strcmp(backing_file_full, filename_full) == 0) {
3105 retval = curr_bs->backing->bs;
3106 break;
3111 g_free(filename_full);
3112 g_free(backing_file_full);
3113 g_free(filename_tmp);
3114 return retval;
3117 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3119 if (!bs->drv) {
3120 return 0;
3123 if (!bs->backing) {
3124 return 0;
3127 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3130 void bdrv_init(void)
3132 module_call_init(MODULE_INIT_BLOCK);
3135 void bdrv_init_with_whitelist(void)
3137 use_bdrv_whitelist = 1;
3138 bdrv_init();
3141 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3143 Error *local_err = NULL;
3144 int ret;
3146 if (!bs->drv) {
3147 return;
3150 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3151 return;
3153 bs->open_flags &= ~BDRV_O_INCOMING;
3155 if (bs->drv->bdrv_invalidate_cache) {
3156 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3157 } else if (bs->file) {
3158 bdrv_invalidate_cache(bs->file->bs, &local_err);
3160 if (local_err) {
3161 error_propagate(errp, local_err);
3162 return;
3165 ret = refresh_total_sectors(bs, bs->total_sectors);
3166 if (ret < 0) {
3167 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3168 return;
3172 void bdrv_invalidate_cache_all(Error **errp)
3174 BlockDriverState *bs;
3175 Error *local_err = NULL;
3177 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3178 AioContext *aio_context = bdrv_get_aio_context(bs);
3180 aio_context_acquire(aio_context);
3181 bdrv_invalidate_cache(bs, &local_err);
3182 aio_context_release(aio_context);
3183 if (local_err) {
3184 error_propagate(errp, local_err);
3185 return;
3190 /**************************************************************/
3191 /* removable device support */
3194 * Return TRUE if the media is present
3196 int bdrv_is_inserted(BlockDriverState *bs)
3198 BlockDriver *drv = bs->drv;
3200 if (!drv)
3201 return 0;
3202 if (!drv->bdrv_is_inserted)
3203 return 1;
3204 return drv->bdrv_is_inserted(bs);
3208 * Return whether the media changed since the last call to this
3209 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3211 int bdrv_media_changed(BlockDriverState *bs)
3213 BlockDriver *drv = bs->drv;
3215 if (drv && drv->bdrv_media_changed) {
3216 return drv->bdrv_media_changed(bs);
3218 return -ENOTSUP;
3222 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3224 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3226 BlockDriver *drv = bs->drv;
3227 const char *device_name;
3229 if (drv && drv->bdrv_eject) {
3230 drv->bdrv_eject(bs, eject_flag);
3233 device_name = bdrv_get_device_name(bs);
3234 if (device_name[0] != '\0') {
3235 qapi_event_send_device_tray_moved(device_name,
3236 eject_flag, &error_abort);
3241 * Lock or unlock the media (if it is locked, the user won't be able
3242 * to eject it manually).
3244 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3246 BlockDriver *drv = bs->drv;
3248 trace_bdrv_lock_medium(bs, locked);
3250 if (drv && drv->bdrv_lock_medium) {
3251 drv->bdrv_lock_medium(bs, locked);
3255 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3257 bs->guest_block_size = align;
3260 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3262 BdrvDirtyBitmap *bm;
3264 assert(name);
3265 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3266 if (bm->name && !strcmp(name, bm->name)) {
3267 return bm;
3270 return NULL;
3273 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3275 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3276 g_free(bitmap->name);
3277 bitmap->name = NULL;
3280 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3281 uint32_t granularity,
3282 const char *name,
3283 Error **errp)
3285 int64_t bitmap_size;
3286 BdrvDirtyBitmap *bitmap;
3287 uint32_t sector_granularity;
3289 assert((granularity & (granularity - 1)) == 0);
3291 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3292 error_setg(errp, "Bitmap already exists: %s", name);
3293 return NULL;
3295 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3296 assert(sector_granularity);
3297 bitmap_size = bdrv_nb_sectors(bs);
3298 if (bitmap_size < 0) {
3299 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3300 errno = -bitmap_size;
3301 return NULL;
3303 bitmap = g_new0(BdrvDirtyBitmap, 1);
3304 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3305 bitmap->size = bitmap_size;
3306 bitmap->name = g_strdup(name);
3307 bitmap->disabled = false;
3308 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3309 return bitmap;
3312 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3314 return bitmap->successor;
3317 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3319 return !(bitmap->disabled || bitmap->successor);
3322 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3324 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3325 return DIRTY_BITMAP_STATUS_FROZEN;
3326 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3327 return DIRTY_BITMAP_STATUS_DISABLED;
3328 } else {
3329 return DIRTY_BITMAP_STATUS_ACTIVE;
3334 * Create a successor bitmap destined to replace this bitmap after an operation.
3335 * Requires that the bitmap is not frozen and has no successor.
3337 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3338 BdrvDirtyBitmap *bitmap, Error **errp)
3340 uint64_t granularity;
3341 BdrvDirtyBitmap *child;
3343 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3344 error_setg(errp, "Cannot create a successor for a bitmap that is "
3345 "currently frozen");
3346 return -1;
3348 assert(!bitmap->successor);
3350 /* Create an anonymous successor */
3351 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3352 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3353 if (!child) {
3354 return -1;
3357 /* Successor will be on or off based on our current state. */
3358 child->disabled = bitmap->disabled;
3360 /* Install the successor and freeze the parent */
3361 bitmap->successor = child;
3362 return 0;
3366 * For a bitmap with a successor, yield our name to the successor,
3367 * delete the old bitmap, and return a handle to the new bitmap.
3369 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3370 BdrvDirtyBitmap *bitmap,
3371 Error **errp)
3373 char *name;
3374 BdrvDirtyBitmap *successor = bitmap->successor;
3376 if (successor == NULL) {
3377 error_setg(errp, "Cannot relinquish control if "
3378 "there's no successor present");
3379 return NULL;
3382 name = bitmap->name;
3383 bitmap->name = NULL;
3384 successor->name = name;
3385 bitmap->successor = NULL;
3386 bdrv_release_dirty_bitmap(bs, bitmap);
3388 return successor;
3392 * In cases of failure where we can no longer safely delete the parent,
3393 * we may wish to re-join the parent and child/successor.
3394 * The merged parent will be un-frozen, but not explicitly re-enabled.
3396 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3397 BdrvDirtyBitmap *parent,
3398 Error **errp)
3400 BdrvDirtyBitmap *successor = parent->successor;
3402 if (!successor) {
3403 error_setg(errp, "Cannot reclaim a successor when none is present");
3404 return NULL;
3407 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3408 error_setg(errp, "Merging of parent and successor bitmap failed");
3409 return NULL;
3411 bdrv_release_dirty_bitmap(bs, successor);
3412 parent->successor = NULL;
3414 return parent;
3418 * Truncates _all_ bitmaps attached to a BDS.
3420 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3422 BdrvDirtyBitmap *bitmap;
3423 uint64_t size = bdrv_nb_sectors(bs);
3425 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3426 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3427 hbitmap_truncate(bitmap->bitmap, size);
3428 bitmap->size = size;
3432 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3434 BdrvDirtyBitmap *bm, *next;
3435 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3436 if (bm == bitmap) {
3437 assert(!bdrv_dirty_bitmap_frozen(bm));
3438 QLIST_REMOVE(bitmap, list);
3439 hbitmap_free(bitmap->bitmap);
3440 g_free(bitmap->name);
3441 g_free(bitmap);
3442 return;
3447 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3449 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3450 bitmap->disabled = true;
3453 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3455 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3456 bitmap->disabled = false;
3459 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3461 BdrvDirtyBitmap *bm;
3462 BlockDirtyInfoList *list = NULL;
3463 BlockDirtyInfoList **plist = &list;
3465 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3466 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3467 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3468 info->count = bdrv_get_dirty_count(bm);
3469 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3470 info->has_name = !!bm->name;
3471 info->name = g_strdup(bm->name);
3472 info->status = bdrv_dirty_bitmap_status(bm);
3473 entry->value = info;
3474 *plist = entry;
3475 plist = &entry->next;
3478 return list;
3481 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3483 if (bitmap) {
3484 return hbitmap_get(bitmap->bitmap, sector);
3485 } else {
3486 return 0;
3491 * Chooses a default granularity based on the existing cluster size,
3492 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3493 * is no cluster size information available.
3495 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3497 BlockDriverInfo bdi;
3498 uint32_t granularity;
3500 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3501 granularity = MAX(4096, bdi.cluster_size);
3502 granularity = MIN(65536, granularity);
3503 } else {
3504 granularity = 65536;
3507 return granularity;
3510 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3512 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3515 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3517 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3520 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3521 int64_t cur_sector, int nr_sectors)
3523 assert(bdrv_dirty_bitmap_enabled(bitmap));
3524 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3527 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3528 int64_t cur_sector, int nr_sectors)
3530 assert(bdrv_dirty_bitmap_enabled(bitmap));
3531 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3534 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3536 assert(bdrv_dirty_bitmap_enabled(bitmap));
3537 hbitmap_reset_all(bitmap->bitmap);
3540 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3541 int nr_sectors)
3543 BdrvDirtyBitmap *bitmap;
3544 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3545 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3546 continue;
3548 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3553 * Advance an HBitmapIter to an arbitrary offset.
3555 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3557 assert(hbi->hb);
3558 hbitmap_iter_init(hbi, hbi->hb, offset);
3561 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3563 return hbitmap_count(bitmap->bitmap);
3566 /* Get a reference to bs */
3567 void bdrv_ref(BlockDriverState *bs)
3569 bs->refcnt++;
3572 /* Release a previously grabbed reference to bs.
3573 * If after releasing, reference count is zero, the BlockDriverState is
3574 * deleted. */
3575 void bdrv_unref(BlockDriverState *bs)
3577 if (!bs) {
3578 return;
3580 assert(bs->refcnt > 0);
3581 if (--bs->refcnt == 0) {
3582 bdrv_delete(bs);
3586 struct BdrvOpBlocker {
3587 Error *reason;
3588 QLIST_ENTRY(BdrvOpBlocker) list;
3591 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3593 BdrvOpBlocker *blocker;
3594 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3595 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3596 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3597 if (errp) {
3598 error_setg(errp, "Node '%s' is busy: %s",
3599 bdrv_get_device_or_node_name(bs),
3600 error_get_pretty(blocker->reason));
3602 return true;
3604 return false;
3607 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3609 BdrvOpBlocker *blocker;
3610 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3612 blocker = g_new0(BdrvOpBlocker, 1);
3613 blocker->reason = reason;
3614 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3617 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3619 BdrvOpBlocker *blocker, *next;
3620 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3621 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3622 if (blocker->reason == reason) {
3623 QLIST_REMOVE(blocker, list);
3624 g_free(blocker);
3629 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3631 int i;
3632 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3633 bdrv_op_block(bs, i, reason);
3637 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3639 int i;
3640 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3641 bdrv_op_unblock(bs, i, reason);
3645 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3647 int i;
3649 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3650 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3651 return false;
3654 return true;
3657 void bdrv_iostatus_enable(BlockDriverState *bs)
3659 bs->iostatus_enabled = true;
3660 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3663 /* The I/O status is only enabled if the drive explicitly
3664 * enables it _and_ the VM is configured to stop on errors */
3665 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3667 return (bs->iostatus_enabled &&
3668 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3669 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
3670 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3673 void bdrv_iostatus_disable(BlockDriverState *bs)
3675 bs->iostatus_enabled = false;
3678 void bdrv_iostatus_reset(BlockDriverState *bs)
3680 if (bdrv_iostatus_is_enabled(bs)) {
3681 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3682 if (bs->job) {
3683 block_job_iostatus_reset(bs->job);
3688 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3690 assert(bdrv_iostatus_is_enabled(bs));
3691 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3692 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3693 BLOCK_DEVICE_IO_STATUS_FAILED;
3697 void bdrv_img_create(const char *filename, const char *fmt,
3698 const char *base_filename, const char *base_fmt,
3699 char *options, uint64_t img_size, int flags,
3700 Error **errp, bool quiet)
3702 QemuOptsList *create_opts = NULL;
3703 QemuOpts *opts = NULL;
3704 const char *backing_fmt, *backing_file;
3705 int64_t size;
3706 BlockDriver *drv, *proto_drv;
3707 Error *local_err = NULL;
3708 int ret = 0;
3710 /* Find driver and parse its options */
3711 drv = bdrv_find_format(fmt);
3712 if (!drv) {
3713 error_setg(errp, "Unknown file format '%s'", fmt);
3714 return;
3717 proto_drv = bdrv_find_protocol(filename, true, errp);
3718 if (!proto_drv) {
3719 return;
3722 if (!drv->create_opts) {
3723 error_setg(errp, "Format driver '%s' does not support image creation",
3724 drv->format_name);
3725 return;
3728 if (!proto_drv->create_opts) {
3729 error_setg(errp, "Protocol driver '%s' does not support image creation",
3730 proto_drv->format_name);
3731 return;
3734 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3735 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3737 /* Create parameter list with default values */
3738 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3739 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3741 /* Parse -o options */
3742 if (options) {
3743 qemu_opts_do_parse(opts, options, NULL, &local_err);
3744 if (local_err) {
3745 error_report_err(local_err);
3746 local_err = NULL;
3747 error_setg(errp, "Invalid options for file format '%s'", fmt);
3748 goto out;
3752 if (base_filename) {
3753 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3754 if (local_err) {
3755 error_setg(errp, "Backing file not supported for file format '%s'",
3756 fmt);
3757 goto out;
3761 if (base_fmt) {
3762 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3763 if (local_err) {
3764 error_setg(errp, "Backing file format not supported for file "
3765 "format '%s'", fmt);
3766 goto out;
3770 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3771 if (backing_file) {
3772 if (!strcmp(filename, backing_file)) {
3773 error_setg(errp, "Error: Trying to create an image with the "
3774 "same filename as the backing file");
3775 goto out;
3779 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3781 // The size for the image must always be specified, with one exception:
3782 // If we are using a backing file, we can obtain the size from there
3783 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3784 if (size == -1) {
3785 if (backing_file) {
3786 BlockDriverState *bs;
3787 char *full_backing = g_new0(char, PATH_MAX);
3788 int64_t size;
3789 int back_flags;
3790 QDict *backing_options = NULL;
3792 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3793 full_backing, PATH_MAX,
3794 &local_err);
3795 if (local_err) {
3796 g_free(full_backing);
3797 goto out;
3800 /* backing files always opened read-only */
3801 back_flags =
3802 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3804 if (backing_fmt) {
3805 backing_options = qdict_new();
3806 qdict_put(backing_options, "driver",
3807 qstring_from_str(backing_fmt));
3810 bs = NULL;
3811 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3812 back_flags, &local_err);
3813 g_free(full_backing);
3814 if (ret < 0) {
3815 goto out;
3817 size = bdrv_getlength(bs);
3818 if (size < 0) {
3819 error_setg_errno(errp, -size, "Could not get size of '%s'",
3820 backing_file);
3821 bdrv_unref(bs);
3822 goto out;
3825 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3827 bdrv_unref(bs);
3828 } else {
3829 error_setg(errp, "Image creation needs a size parameter");
3830 goto out;
3834 if (!quiet) {
3835 printf("Formatting '%s', fmt=%s ", filename, fmt);
3836 qemu_opts_print(opts, " ");
3837 puts("");
3840 ret = bdrv_create(drv, filename, opts, &local_err);
3842 if (ret == -EFBIG) {
3843 /* This is generally a better message than whatever the driver would
3844 * deliver (especially because of the cluster_size_hint), since that
3845 * is most probably not much different from "image too large". */
3846 const char *cluster_size_hint = "";
3847 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3848 cluster_size_hint = " (try using a larger cluster size)";
3850 error_setg(errp, "The image size is too large for file format '%s'"
3851 "%s", fmt, cluster_size_hint);
3852 error_free(local_err);
3853 local_err = NULL;
3856 out:
3857 qemu_opts_del(opts);
3858 qemu_opts_free(create_opts);
3859 if (local_err) {
3860 error_propagate(errp, local_err);
3864 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3866 return bs->aio_context;
3869 void bdrv_detach_aio_context(BlockDriverState *bs)
3871 BdrvAioNotifier *baf;
3873 if (!bs->drv) {
3874 return;
3877 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3878 baf->detach_aio_context(baf->opaque);
3881 if (bs->io_limits_enabled) {
3882 throttle_timers_detach_aio_context(&bs->throttle_timers);
3884 if (bs->drv->bdrv_detach_aio_context) {
3885 bs->drv->bdrv_detach_aio_context(bs);
3887 if (bs->file) {
3888 bdrv_detach_aio_context(bs->file->bs);
3890 if (bs->backing) {
3891 bdrv_detach_aio_context(bs->backing->bs);
3894 bs->aio_context = NULL;
3897 void bdrv_attach_aio_context(BlockDriverState *bs,
3898 AioContext *new_context)
3900 BdrvAioNotifier *ban;
3902 if (!bs->drv) {
3903 return;
3906 bs->aio_context = new_context;
3908 if (bs->backing) {
3909 bdrv_attach_aio_context(bs->backing->bs, new_context);
3911 if (bs->file) {
3912 bdrv_attach_aio_context(bs->file->bs, new_context);
3914 if (bs->drv->bdrv_attach_aio_context) {
3915 bs->drv->bdrv_attach_aio_context(bs, new_context);
3917 if (bs->io_limits_enabled) {
3918 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3921 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3922 ban->attached_aio_context(new_context, ban->opaque);
3926 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3928 bdrv_drain(bs); /* ensure there are no in-flight requests */
3930 bdrv_detach_aio_context(bs);
3932 /* This function executes in the old AioContext so acquire the new one in
3933 * case it runs in a different thread.
3935 aio_context_acquire(new_context);
3936 bdrv_attach_aio_context(bs, new_context);
3937 aio_context_release(new_context);
3940 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3941 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3942 void (*detach_aio_context)(void *opaque), void *opaque)
3944 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3945 *ban = (BdrvAioNotifier){
3946 .attached_aio_context = attached_aio_context,
3947 .detach_aio_context = detach_aio_context,
3948 .opaque = opaque
3951 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3954 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3955 void (*attached_aio_context)(AioContext *,
3956 void *),
3957 void (*detach_aio_context)(void *),
3958 void *opaque)
3960 BdrvAioNotifier *ban, *ban_next;
3962 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3963 if (ban->attached_aio_context == attached_aio_context &&
3964 ban->detach_aio_context == detach_aio_context &&
3965 ban->opaque == opaque)
3967 QLIST_REMOVE(ban, list);
3968 g_free(ban);
3970 return;
3974 abort();
3977 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3978 BlockDriverAmendStatusCB *status_cb)
3980 if (!bs->drv->bdrv_amend_options) {
3981 return -ENOTSUP;
3983 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
3986 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3987 * of block filter and by bdrv_is_first_non_filter.
3988 * It is used to test if the given bs is the candidate or recurse more in the
3989 * node graph.
3991 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3992 BlockDriverState *candidate)
3994 /* return false if basic checks fails */
3995 if (!bs || !bs->drv) {
3996 return false;
3999 /* the code reached a non block filter driver -> check if the bs is
4000 * the same as the candidate. It's the recursion termination condition.
4002 if (!bs->drv->is_filter) {
4003 return bs == candidate;
4005 /* Down this path the driver is a block filter driver */
4007 /* If the block filter recursion method is defined use it to recurse down
4008 * the node graph.
4010 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4011 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4014 /* the driver is a block filter but don't allow to recurse -> return false
4016 return false;
4019 /* This function checks if the candidate is the first non filter bs down it's
4020 * bs chain. Since we don't have pointers to parents it explore all bs chains
4021 * from the top. Some filters can choose not to pass down the recursion.
4023 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4025 BlockDriverState *bs;
4027 /* walk down the bs forest recursively */
4028 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4029 bool perm;
4031 /* try to recurse in this top level bs */
4032 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4034 /* candidate is the first non filter */
4035 if (perm) {
4036 return true;
4040 return false;
4043 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4044 const char *node_name, Error **errp)
4046 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4047 AioContext *aio_context;
4049 if (!to_replace_bs) {
4050 error_setg(errp, "Node name '%s' not found", node_name);
4051 return NULL;
4054 aio_context = bdrv_get_aio_context(to_replace_bs);
4055 aio_context_acquire(aio_context);
4057 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4058 to_replace_bs = NULL;
4059 goto out;
4062 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4063 * most non filter in order to prevent data corruption.
4064 * Another benefit is that this tests exclude backing files which are
4065 * blocked by the backing blockers.
4067 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4068 error_setg(errp, "Only top most non filter can be replaced");
4069 to_replace_bs = NULL;
4070 goto out;
4073 out:
4074 aio_context_release(aio_context);
4075 return to_replace_bs;
4078 static bool append_open_options(QDict *d, BlockDriverState *bs)
4080 const QDictEntry *entry;
4081 bool found_any = false;
4083 for (entry = qdict_first(bs->options); entry;
4084 entry = qdict_next(bs->options, entry))
4086 /* Only take options for this level and exclude all non-driver-specific
4087 * options */
4088 if (!strchr(qdict_entry_key(entry), '.') &&
4089 strcmp(qdict_entry_key(entry), "node-name"))
4091 qobject_incref(qdict_entry_value(entry));
4092 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4093 found_any = true;
4097 return found_any;
4100 /* Updates the following BDS fields:
4101 * - exact_filename: A filename which may be used for opening a block device
4102 * which (mostly) equals the given BDS (even without any
4103 * other options; so reading and writing must return the same
4104 * results, but caching etc. may be different)
4105 * - full_open_options: Options which, when given when opening a block device
4106 * (without a filename), result in a BDS (mostly)
4107 * equalling the given one
4108 * - filename: If exact_filename is set, it is copied here. Otherwise,
4109 * full_open_options is converted to a JSON object, prefixed with
4110 * "json:" (for use through the JSON pseudo protocol) and put here.
4112 void bdrv_refresh_filename(BlockDriverState *bs)
4114 BlockDriver *drv = bs->drv;
4115 QDict *opts;
4117 if (!drv) {
4118 return;
4121 /* This BDS's file name will most probably depend on its file's name, so
4122 * refresh that first */
4123 if (bs->file) {
4124 bdrv_refresh_filename(bs->file->bs);
4127 if (drv->bdrv_refresh_filename) {
4128 /* Obsolete information is of no use here, so drop the old file name
4129 * information before refreshing it */
4130 bs->exact_filename[0] = '\0';
4131 if (bs->full_open_options) {
4132 QDECREF(bs->full_open_options);
4133 bs->full_open_options = NULL;
4136 drv->bdrv_refresh_filename(bs);
4137 } else if (bs->file) {
4138 /* Try to reconstruct valid information from the underlying file */
4139 bool has_open_options;
4141 bs->exact_filename[0] = '\0';
4142 if (bs->full_open_options) {
4143 QDECREF(bs->full_open_options);
4144 bs->full_open_options = NULL;
4147 opts = qdict_new();
4148 has_open_options = append_open_options(opts, bs);
4150 /* If no specific options have been given for this BDS, the filename of
4151 * the underlying file should suffice for this one as well */
4152 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4153 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4155 /* Reconstructing the full options QDict is simple for most format block
4156 * drivers, as long as the full options are known for the underlying
4157 * file BDS. The full options QDict of that file BDS should somehow
4158 * contain a representation of the filename, therefore the following
4159 * suffices without querying the (exact_)filename of this BDS. */
4160 if (bs->file->bs->full_open_options) {
4161 qdict_put_obj(opts, "driver",
4162 QOBJECT(qstring_from_str(drv->format_name)));
4163 QINCREF(bs->file->bs->full_open_options);
4164 qdict_put_obj(opts, "file",
4165 QOBJECT(bs->file->bs->full_open_options));
4167 bs->full_open_options = opts;
4168 } else {
4169 QDECREF(opts);
4171 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4172 /* There is no underlying file BDS (at least referenced by BDS.file),
4173 * so the full options QDict should be equal to the options given
4174 * specifically for this block device when it was opened (plus the
4175 * driver specification).
4176 * Because those options don't change, there is no need to update
4177 * full_open_options when it's already set. */
4179 opts = qdict_new();
4180 append_open_options(opts, bs);
4181 qdict_put_obj(opts, "driver",
4182 QOBJECT(qstring_from_str(drv->format_name)));
4184 if (bs->exact_filename[0]) {
4185 /* This may not work for all block protocol drivers (some may
4186 * require this filename to be parsed), but we have to find some
4187 * default solution here, so just include it. If some block driver
4188 * does not support pure options without any filename at all or
4189 * needs some special format of the options QDict, it needs to
4190 * implement the driver-specific bdrv_refresh_filename() function.
4192 qdict_put_obj(opts, "filename",
4193 QOBJECT(qstring_from_str(bs->exact_filename)));
4196 bs->full_open_options = opts;
4199 if (bs->exact_filename[0]) {
4200 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4201 } else if (bs->full_open_options) {
4202 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4203 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4204 qstring_get_str(json));
4205 QDECREF(json);
4209 /* This accessor function purpose is to allow the device models to access the
4210 * BlockAcctStats structure embedded inside a BlockDriverState without being
4211 * aware of the BlockDriverState structure layout.
4212 * It will go away when the BlockAcctStats structure will be moved inside
4213 * the device models.
4215 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4217 return &bs->stats;