qapi: Simplify inclusion cycle detection
[qemu/kevin.git] / block.c
blobdd4f58d6cb56d58052d67ea52ccd63ce01b26a46
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/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
39 #include "block/throttle-groups.h"
41 #ifdef CONFIG_BSD
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
46 #ifndef __DragonFly__
47 #include <sys/disk.h>
48 #endif
49 #endif
51 #ifdef _WIN32
52 #include <windows.h>
53 #endif
55 /**
56 * A BdrvDirtyBitmap can be in three possible states:
57 * (1) successor is NULL and disabled is false: full r/w mode
58 * (2) successor is NULL and disabled is true: read only mode ("disabled")
59 * (3) successor is set: frozen mode.
60 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
61 * or enabled. A frozen bitmap can only abdicate() or reclaim().
63 struct BdrvDirtyBitmap {
64 HBitmap *bitmap; /* Dirty sector bitmap implementation */
65 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
66 char *name; /* Optional non-empty unique ID */
67 int64_t size; /* Size of the bitmap (Number of sectors) */
68 bool disabled; /* Bitmap is read-only */
69 QLIST_ENTRY(BdrvDirtyBitmap) list;
72 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
74 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
75 QTAILQ_HEAD_INITIALIZER(bdrv_states);
77 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
78 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
80 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
81 QLIST_HEAD_INITIALIZER(bdrv_drivers);
83 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
84 const char *reference, QDict *options, int flags,
85 BlockDriverState *parent,
86 const BdrvChildRole *child_role,
87 BlockDriver *drv, Error **errp);
89 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
90 /* If non-zero, use only whitelisted block drivers */
91 static int use_bdrv_whitelist;
93 #ifdef _WIN32
94 static int is_windows_drive_prefix(const char *filename)
96 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
97 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
98 filename[1] == ':');
101 int is_windows_drive(const char *filename)
103 if (is_windows_drive_prefix(filename) &&
104 filename[2] == '\0')
105 return 1;
106 if (strstart(filename, "\\\\.\\", NULL) ||
107 strstart(filename, "//./", NULL))
108 return 1;
109 return 0;
111 #endif
113 size_t bdrv_opt_mem_align(BlockDriverState *bs)
115 if (!bs || !bs->drv) {
116 /* page size or 4k (hdd sector size) should be on the safe side */
117 return MAX(4096, getpagesize());
120 return bs->bl.opt_mem_alignment;
123 size_t bdrv_min_mem_align(BlockDriverState *bs)
125 if (!bs || !bs->drv) {
126 /* page size or 4k (hdd sector size) should be on the safe side */
127 return MAX(4096, getpagesize());
130 return bs->bl.min_mem_alignment;
133 /* check if the path starts with "<protocol>:" */
134 int path_has_protocol(const char *path)
136 const char *p;
138 #ifdef _WIN32
139 if (is_windows_drive(path) ||
140 is_windows_drive_prefix(path)) {
141 return 0;
143 p = path + strcspn(path, ":/\\");
144 #else
145 p = path + strcspn(path, ":/");
146 #endif
148 return *p == ':';
151 int path_is_absolute(const char *path)
153 #ifdef _WIN32
154 /* specific case for names like: "\\.\d:" */
155 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
156 return 1;
158 return (*path == '/' || *path == '\\');
159 #else
160 return (*path == '/');
161 #endif
164 /* if filename is absolute, just copy it to dest. Otherwise, build a
165 path to it by considering it is relative to base_path. URL are
166 supported. */
167 void path_combine(char *dest, int dest_size,
168 const char *base_path,
169 const char *filename)
171 const char *p, *p1;
172 int len;
174 if (dest_size <= 0)
175 return;
176 if (path_is_absolute(filename)) {
177 pstrcpy(dest, dest_size, filename);
178 } else {
179 p = strchr(base_path, ':');
180 if (p)
181 p++;
182 else
183 p = base_path;
184 p1 = strrchr(base_path, '/');
185 #ifdef _WIN32
187 const char *p2;
188 p2 = strrchr(base_path, '\\');
189 if (!p1 || p2 > p1)
190 p1 = p2;
192 #endif
193 if (p1)
194 p1++;
195 else
196 p1 = base_path;
197 if (p1 > p)
198 p = p1;
199 len = p - base_path;
200 if (len > dest_size - 1)
201 len = dest_size - 1;
202 memcpy(dest, base_path, len);
203 dest[len] = '\0';
204 pstrcat(dest, dest_size, filename);
208 void bdrv_get_full_backing_filename_from_filename(const char *backed,
209 const char *backing,
210 char *dest, size_t sz,
211 Error **errp)
213 if (backing[0] == '\0' || path_has_protocol(backing) ||
214 path_is_absolute(backing))
216 pstrcpy(dest, sz, backing);
217 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
218 error_setg(errp, "Cannot use relative backing file names for '%s'",
219 backed);
220 } else {
221 path_combine(dest, sz, backed, backing);
225 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
226 Error **errp)
228 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
230 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
231 dest, sz, errp);
234 void bdrv_register(BlockDriver *bdrv)
236 bdrv_setup_io_funcs(bdrv);
238 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
241 BlockDriverState *bdrv_new_root(void)
243 BlockDriverState *bs = bdrv_new();
245 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
246 return bs;
249 BlockDriverState *bdrv_new(void)
251 BlockDriverState *bs;
252 int i;
254 bs = g_new0(BlockDriverState, 1);
255 QLIST_INIT(&bs->dirty_bitmaps);
256 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
257 QLIST_INIT(&bs->op_blockers[i]);
259 bdrv_iostatus_disable(bs);
260 notifier_list_init(&bs->close_notifiers);
261 notifier_with_return_list_init(&bs->before_write_notifiers);
262 qemu_co_queue_init(&bs->throttled_reqs[0]);
263 qemu_co_queue_init(&bs->throttled_reqs[1]);
264 bs->refcnt = 1;
265 bs->aio_context = qemu_get_aio_context();
267 return bs;
270 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
272 notifier_list_add(&bs->close_notifiers, notify);
275 BlockDriver *bdrv_find_format(const char *format_name)
277 BlockDriver *drv1;
278 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
279 if (!strcmp(drv1->format_name, format_name)) {
280 return drv1;
283 return NULL;
286 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
288 static const char *whitelist_rw[] = {
289 CONFIG_BDRV_RW_WHITELIST
291 static const char *whitelist_ro[] = {
292 CONFIG_BDRV_RO_WHITELIST
294 const char **p;
296 if (!whitelist_rw[0] && !whitelist_ro[0]) {
297 return 1; /* no whitelist, anything goes */
300 for (p = whitelist_rw; *p; p++) {
301 if (!strcmp(drv->format_name, *p)) {
302 return 1;
305 if (read_only) {
306 for (p = whitelist_ro; *p; p++) {
307 if (!strcmp(drv->format_name, *p)) {
308 return 1;
312 return 0;
315 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
316 bool read_only)
318 BlockDriver *drv = bdrv_find_format(format_name);
319 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
322 typedef struct CreateCo {
323 BlockDriver *drv;
324 char *filename;
325 QemuOpts *opts;
326 int ret;
327 Error *err;
328 } CreateCo;
330 static void coroutine_fn bdrv_create_co_entry(void *opaque)
332 Error *local_err = NULL;
333 int ret;
335 CreateCo *cco = opaque;
336 assert(cco->drv);
338 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
339 if (local_err) {
340 error_propagate(&cco->err, local_err);
342 cco->ret = ret;
345 int bdrv_create(BlockDriver *drv, const char* filename,
346 QemuOpts *opts, Error **errp)
348 int ret;
350 Coroutine *co;
351 CreateCo cco = {
352 .drv = drv,
353 .filename = g_strdup(filename),
354 .opts = opts,
355 .ret = NOT_DONE,
356 .err = NULL,
359 if (!drv->bdrv_create) {
360 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
361 ret = -ENOTSUP;
362 goto out;
365 if (qemu_in_coroutine()) {
366 /* Fast-path if already in coroutine context */
367 bdrv_create_co_entry(&cco);
368 } else {
369 co = qemu_coroutine_create(bdrv_create_co_entry);
370 qemu_coroutine_enter(co, &cco);
371 while (cco.ret == NOT_DONE) {
372 aio_poll(qemu_get_aio_context(), true);
376 ret = cco.ret;
377 if (ret < 0) {
378 if (cco.err) {
379 error_propagate(errp, cco.err);
380 } else {
381 error_setg_errno(errp, -ret, "Could not create image");
385 out:
386 g_free(cco.filename);
387 return ret;
390 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
392 BlockDriver *drv;
393 Error *local_err = NULL;
394 int ret;
396 drv = bdrv_find_protocol(filename, true, errp);
397 if (drv == NULL) {
398 return -ENOENT;
401 ret = bdrv_create(drv, filename, opts, &local_err);
402 if (local_err) {
403 error_propagate(errp, local_err);
405 return ret;
409 * Try to get @bs's logical and physical block size.
410 * On success, store them in @bsz struct and return 0.
411 * On failure return -errno.
412 * @bs must not be empty.
414 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
416 BlockDriver *drv = bs->drv;
418 if (drv && drv->bdrv_probe_blocksizes) {
419 return drv->bdrv_probe_blocksizes(bs, bsz);
422 return -ENOTSUP;
426 * Try to get @bs's geometry (cyls, heads, sectors).
427 * On success, store them in @geo struct and return 0.
428 * On failure return -errno.
429 * @bs must not be empty.
431 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
433 BlockDriver *drv = bs->drv;
435 if (drv && drv->bdrv_probe_geometry) {
436 return drv->bdrv_probe_geometry(bs, geo);
439 return -ENOTSUP;
443 * Create a uniquely-named empty temporary file.
444 * Return 0 upon success, otherwise a negative errno value.
446 int get_tmp_filename(char *filename, int size)
448 #ifdef _WIN32
449 char temp_dir[MAX_PATH];
450 /* GetTempFileName requires that its output buffer (4th param)
451 have length MAX_PATH or greater. */
452 assert(size >= MAX_PATH);
453 return (GetTempPath(MAX_PATH, temp_dir)
454 && GetTempFileName(temp_dir, "qem", 0, filename)
455 ? 0 : -GetLastError());
456 #else
457 int fd;
458 const char *tmpdir;
459 tmpdir = getenv("TMPDIR");
460 if (!tmpdir) {
461 tmpdir = "/var/tmp";
463 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
464 return -EOVERFLOW;
466 fd = mkstemp(filename);
467 if (fd < 0) {
468 return -errno;
470 if (close(fd) != 0) {
471 unlink(filename);
472 return -errno;
474 return 0;
475 #endif
479 * Detect host devices. By convention, /dev/cdrom[N] is always
480 * recognized as a host CDROM.
482 static BlockDriver *find_hdev_driver(const char *filename)
484 int score_max = 0, score;
485 BlockDriver *drv = NULL, *d;
487 QLIST_FOREACH(d, &bdrv_drivers, list) {
488 if (d->bdrv_probe_device) {
489 score = d->bdrv_probe_device(filename);
490 if (score > score_max) {
491 score_max = score;
492 drv = d;
497 return drv;
500 BlockDriver *bdrv_find_protocol(const char *filename,
501 bool allow_protocol_prefix,
502 Error **errp)
504 BlockDriver *drv1;
505 char protocol[128];
506 int len;
507 const char *p;
509 /* TODO Drivers without bdrv_file_open must be specified explicitly */
512 * XXX(hch): we really should not let host device detection
513 * override an explicit protocol specification, but moving this
514 * later breaks access to device names with colons in them.
515 * Thanks to the brain-dead persistent naming schemes on udev-
516 * based Linux systems those actually are quite common.
518 drv1 = find_hdev_driver(filename);
519 if (drv1) {
520 return drv1;
523 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
524 return &bdrv_file;
527 p = strchr(filename, ':');
528 assert(p != NULL);
529 len = p - filename;
530 if (len > sizeof(protocol) - 1)
531 len = sizeof(protocol) - 1;
532 memcpy(protocol, filename, len);
533 protocol[len] = '\0';
534 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
535 if (drv1->protocol_name &&
536 !strcmp(drv1->protocol_name, protocol)) {
537 return drv1;
541 error_setg(errp, "Unknown protocol '%s'", protocol);
542 return NULL;
546 * Guess image format by probing its contents.
547 * This is not a good idea when your image is raw (CVE-2008-2004), but
548 * we do it anyway for backward compatibility.
550 * @buf contains the image's first @buf_size bytes.
551 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
552 * but can be smaller if the image file is smaller)
553 * @filename is its filename.
555 * For all block drivers, call the bdrv_probe() method to get its
556 * probing score.
557 * Return the first block driver with the highest probing score.
559 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
560 const char *filename)
562 int score_max = 0, score;
563 BlockDriver *drv = NULL, *d;
565 QLIST_FOREACH(d, &bdrv_drivers, list) {
566 if (d->bdrv_probe) {
567 score = d->bdrv_probe(buf, buf_size, filename);
568 if (score > score_max) {
569 score_max = score;
570 drv = d;
575 return drv;
578 static int find_image_format(BlockDriverState *bs, const char *filename,
579 BlockDriver **pdrv, Error **errp)
581 BlockDriver *drv;
582 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
583 int ret = 0;
585 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
586 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
587 *pdrv = &bdrv_raw;
588 return ret;
591 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
592 if (ret < 0) {
593 error_setg_errno(errp, -ret, "Could not read image for determining its "
594 "format");
595 *pdrv = NULL;
596 return ret;
599 drv = bdrv_probe_all(buf, ret, filename);
600 if (!drv) {
601 error_setg(errp, "Could not determine image format: No compatible "
602 "driver found");
603 ret = -ENOENT;
605 *pdrv = drv;
606 return ret;
610 * Set the current 'total_sectors' value
611 * Return 0 on success, -errno on error.
613 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
615 BlockDriver *drv = bs->drv;
617 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
618 if (bs->sg)
619 return 0;
621 /* query actual device if possible, otherwise just trust the hint */
622 if (drv->bdrv_getlength) {
623 int64_t length = drv->bdrv_getlength(bs);
624 if (length < 0) {
625 return length;
627 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
630 bs->total_sectors = hint;
631 return 0;
635 * Set open flags for a given discard mode
637 * Return 0 on success, -1 if the discard mode was invalid.
639 int bdrv_parse_discard_flags(const char *mode, int *flags)
641 *flags &= ~BDRV_O_UNMAP;
643 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
644 /* do nothing */
645 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
646 *flags |= BDRV_O_UNMAP;
647 } else {
648 return -1;
651 return 0;
655 * Set open flags for a given cache mode
657 * Return 0 on success, -1 if the cache mode was invalid.
659 int bdrv_parse_cache_flags(const char *mode, int *flags)
661 *flags &= ~BDRV_O_CACHE_MASK;
663 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
664 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
665 } else if (!strcmp(mode, "directsync")) {
666 *flags |= BDRV_O_NOCACHE;
667 } else if (!strcmp(mode, "writeback")) {
668 *flags |= BDRV_O_CACHE_WB;
669 } else if (!strcmp(mode, "unsafe")) {
670 *flags |= BDRV_O_CACHE_WB;
671 *flags |= BDRV_O_NO_FLUSH;
672 } else if (!strcmp(mode, "writethrough")) {
673 /* this is the default */
674 } else {
675 return -1;
678 return 0;
682 * Returns the flags that a temporary snapshot should get, based on the
683 * originally requested flags (the originally requested image will have flags
684 * like a backing file)
686 static int bdrv_temp_snapshot_flags(int flags)
688 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
692 * Returns the flags that bs->file should get if a protocol driver is expected,
693 * based on the given flags for the parent BDS
695 static int bdrv_inherited_flags(int flags)
697 /* Enable protocol handling, disable format probing for bs->file */
698 flags |= BDRV_O_PROTOCOL;
700 /* Our block drivers take care to send flushes and respect unmap policy,
701 * so we can enable both unconditionally on lower layers. */
702 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
704 /* Clear flags that only apply to the top layer */
705 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
707 return flags;
710 const BdrvChildRole child_file = {
711 .inherit_flags = bdrv_inherited_flags,
715 * Returns the flags that bs->file should get if the use of formats (and not
716 * only protocols) is permitted for it, based on the given flags for the parent
717 * BDS
719 static int bdrv_inherited_fmt_flags(int parent_flags)
721 int flags = child_file.inherit_flags(parent_flags);
722 return flags & ~BDRV_O_PROTOCOL;
725 const BdrvChildRole child_format = {
726 .inherit_flags = bdrv_inherited_fmt_flags,
730 * Returns the flags that bs->backing_hd should get, based on the given flags
731 * for the parent BDS
733 static int bdrv_backing_flags(int flags)
735 /* backing files always opened read-only */
736 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
738 /* snapshot=on is handled on the top layer */
739 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
741 return flags;
744 static const BdrvChildRole child_backing = {
745 .inherit_flags = bdrv_backing_flags,
748 static int bdrv_open_flags(BlockDriverState *bs, int flags)
750 int open_flags = flags | BDRV_O_CACHE_WB;
753 * Clear flags that are internal to the block layer before opening the
754 * image.
756 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
759 * Snapshots should be writable.
761 if (flags & BDRV_O_TEMPORARY) {
762 open_flags |= BDRV_O_RDWR;
765 return open_flags;
768 static void bdrv_assign_node_name(BlockDriverState *bs,
769 const char *node_name,
770 Error **errp)
772 if (!node_name) {
773 return;
776 /* Check for empty string or invalid characters */
777 if (!id_wellformed(node_name)) {
778 error_setg(errp, "Invalid node name");
779 return;
782 /* takes care of avoiding namespaces collisions */
783 if (blk_by_name(node_name)) {
784 error_setg(errp, "node-name=%s is conflicting with a device id",
785 node_name);
786 return;
789 /* takes care of avoiding duplicates node names */
790 if (bdrv_find_node(node_name)) {
791 error_setg(errp, "Duplicate node name");
792 return;
795 /* copy node name into the bs and insert it into the graph list */
796 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
797 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
800 static QemuOptsList bdrv_runtime_opts = {
801 .name = "bdrv_common",
802 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
803 .desc = {
805 .name = "node-name",
806 .type = QEMU_OPT_STRING,
807 .help = "Node name of the block device node",
809 { /* end of list */ }
814 * Common part for opening disk images and files
816 * Removes all processed options from *options.
818 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
819 QDict *options, int flags, BlockDriver *drv, Error **errp)
821 int ret, open_flags;
822 const char *filename;
823 const char *node_name = NULL;
824 QemuOpts *opts;
825 Error *local_err = NULL;
827 assert(drv != NULL);
828 assert(bs->file == NULL);
829 assert(options != NULL && bs->options != options);
831 if (file != NULL) {
832 filename = file->filename;
833 } else {
834 filename = qdict_get_try_str(options, "filename");
837 if (drv->bdrv_needs_filename && !filename) {
838 error_setg(errp, "The '%s' block driver requires a file name",
839 drv->format_name);
840 return -EINVAL;
843 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
845 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
846 qemu_opts_absorb_qdict(opts, options, &local_err);
847 if (local_err) {
848 error_propagate(errp, local_err);
849 ret = -EINVAL;
850 goto fail_opts;
853 node_name = qemu_opt_get(opts, "node-name");
854 bdrv_assign_node_name(bs, node_name, &local_err);
855 if (local_err) {
856 error_propagate(errp, local_err);
857 ret = -EINVAL;
858 goto fail_opts;
861 bs->guest_block_size = 512;
862 bs->request_alignment = 512;
863 bs->zero_beyond_eof = true;
864 open_flags = bdrv_open_flags(bs, flags);
865 bs->read_only = !(open_flags & BDRV_O_RDWR);
867 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
868 error_setg(errp,
869 !bs->read_only && bdrv_is_whitelisted(drv, true)
870 ? "Driver '%s' can only be used for read-only devices"
871 : "Driver '%s' is not whitelisted",
872 drv->format_name);
873 ret = -ENOTSUP;
874 goto fail_opts;
877 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
878 if (flags & BDRV_O_COPY_ON_READ) {
879 if (!bs->read_only) {
880 bdrv_enable_copy_on_read(bs);
881 } else {
882 error_setg(errp, "Can't use copy-on-read on read-only device");
883 ret = -EINVAL;
884 goto fail_opts;
888 if (filename != NULL) {
889 pstrcpy(bs->filename, sizeof(bs->filename), filename);
890 } else {
891 bs->filename[0] = '\0';
893 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
895 bs->drv = drv;
896 bs->opaque = g_malloc0(drv->instance_size);
898 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
900 /* Open the image, either directly or using a protocol */
901 if (drv->bdrv_file_open) {
902 assert(file == NULL);
903 assert(!drv->bdrv_needs_filename || filename != NULL);
904 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
905 } else {
906 if (file == NULL) {
907 error_setg(errp, "Can't use '%s' as a block driver for the "
908 "protocol level", drv->format_name);
909 ret = -EINVAL;
910 goto free_and_fail;
912 bs->file = file;
913 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
916 if (ret < 0) {
917 if (local_err) {
918 error_propagate(errp, local_err);
919 } else if (bs->filename[0]) {
920 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
921 } else {
922 error_setg_errno(errp, -ret, "Could not open image");
924 goto free_and_fail;
927 if (bs->encrypted) {
928 error_report("Encrypted images are deprecated");
929 error_printf("Support for them will be removed in a future release.\n"
930 "You can use 'qemu-img convert' to convert your image"
931 " to an unencrypted one.\n");
934 ret = refresh_total_sectors(bs, bs->total_sectors);
935 if (ret < 0) {
936 error_setg_errno(errp, -ret, "Could not refresh total sector count");
937 goto free_and_fail;
940 bdrv_refresh_limits(bs, &local_err);
941 if (local_err) {
942 error_propagate(errp, local_err);
943 ret = -EINVAL;
944 goto free_and_fail;
947 assert(bdrv_opt_mem_align(bs) != 0);
948 assert(bdrv_min_mem_align(bs) != 0);
949 assert((bs->request_alignment != 0) || bs->sg);
951 qemu_opts_del(opts);
952 return 0;
954 free_and_fail:
955 bs->file = NULL;
956 g_free(bs->opaque);
957 bs->opaque = NULL;
958 bs->drv = NULL;
959 fail_opts:
960 qemu_opts_del(opts);
961 return ret;
964 static QDict *parse_json_filename(const char *filename, Error **errp)
966 QObject *options_obj;
967 QDict *options;
968 int ret;
970 ret = strstart(filename, "json:", &filename);
971 assert(ret);
973 options_obj = qobject_from_json(filename);
974 if (!options_obj) {
975 error_setg(errp, "Could not parse the JSON options");
976 return NULL;
979 if (qobject_type(options_obj) != QTYPE_QDICT) {
980 qobject_decref(options_obj);
981 error_setg(errp, "Invalid JSON object given");
982 return NULL;
985 options = qobject_to_qdict(options_obj);
986 qdict_flatten(options);
988 return options;
992 * Fills in default options for opening images and converts the legacy
993 * filename/flags pair to option QDict entries.
994 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
995 * block driver has been specified explicitly.
997 static int bdrv_fill_options(QDict **options, const char **pfilename,
998 int *flags, BlockDriver *drv, Error **errp)
1000 const char *filename = *pfilename;
1001 const char *drvname;
1002 bool protocol = *flags & BDRV_O_PROTOCOL;
1003 bool parse_filename = false;
1004 BlockDriver *tmp_drv;
1005 Error *local_err = NULL;
1007 /* Parse json: pseudo-protocol */
1008 if (filename && g_str_has_prefix(filename, "json:")) {
1009 QDict *json_options = parse_json_filename(filename, &local_err);
1010 if (local_err) {
1011 error_propagate(errp, local_err);
1012 return -EINVAL;
1015 /* Options given in the filename have lower priority than options
1016 * specified directly */
1017 qdict_join(*options, json_options, false);
1018 QDECREF(json_options);
1019 *pfilename = filename = NULL;
1022 drvname = qdict_get_try_str(*options, "driver");
1024 /* If the user has explicitly specified the driver, this choice should
1025 * override the BDRV_O_PROTOCOL flag */
1026 tmp_drv = drv;
1027 if (!tmp_drv && drvname) {
1028 tmp_drv = bdrv_find_format(drvname);
1030 if (tmp_drv) {
1031 protocol = tmp_drv->bdrv_file_open;
1034 if (protocol) {
1035 *flags |= BDRV_O_PROTOCOL;
1036 } else {
1037 *flags &= ~BDRV_O_PROTOCOL;
1040 /* Fetch the file name from the options QDict if necessary */
1041 if (protocol && filename) {
1042 if (!qdict_haskey(*options, "filename")) {
1043 qdict_put(*options, "filename", qstring_from_str(filename));
1044 parse_filename = true;
1045 } else {
1046 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1047 "the same time");
1048 return -EINVAL;
1052 /* Find the right block driver */
1053 filename = qdict_get_try_str(*options, "filename");
1055 if (drv) {
1056 if (drvname) {
1057 error_setg(errp, "Driver specified twice");
1058 return -EINVAL;
1060 drvname = drv->format_name;
1061 qdict_put(*options, "driver", qstring_from_str(drvname));
1062 } else {
1063 if (!drvname && protocol) {
1064 if (filename) {
1065 drv = bdrv_find_protocol(filename, parse_filename, errp);
1066 if (!drv) {
1067 return -EINVAL;
1070 drvname = drv->format_name;
1071 qdict_put(*options, "driver", qstring_from_str(drvname));
1072 } else {
1073 error_setg(errp, "Must specify either driver or file");
1074 return -EINVAL;
1076 } else if (drvname) {
1077 drv = bdrv_find_format(drvname);
1078 if (!drv) {
1079 error_setg(errp, "Unknown driver '%s'", drvname);
1080 return -ENOENT;
1085 assert(drv || !protocol);
1087 /* Driver-specific filename parsing */
1088 if (drv && drv->bdrv_parse_filename && parse_filename) {
1089 drv->bdrv_parse_filename(filename, *options, &local_err);
1090 if (local_err) {
1091 error_propagate(errp, local_err);
1092 return -EINVAL;
1095 if (!drv->bdrv_needs_filename) {
1096 qdict_del(*options, "filename");
1100 return 0;
1103 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1106 if (bs->backing_hd) {
1107 assert(bs->backing_blocker);
1108 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1109 } else if (backing_hd) {
1110 error_setg(&bs->backing_blocker,
1111 "node is used as backing hd of '%s'",
1112 bdrv_get_device_or_node_name(bs));
1115 bs->backing_hd = backing_hd;
1116 if (!backing_hd) {
1117 error_free(bs->backing_blocker);
1118 bs->backing_blocker = NULL;
1119 goto out;
1121 bs->open_flags &= ~BDRV_O_NO_BACKING;
1122 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1123 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1124 backing_hd->drv ? backing_hd->drv->format_name : "");
1126 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1127 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1128 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1129 bs->backing_blocker);
1130 out:
1131 bdrv_refresh_limits(bs, NULL);
1135 * Opens the backing file for a BlockDriverState if not yet open
1137 * options is a QDict of options to pass to the block drivers, or NULL for an
1138 * empty set of options. The reference to the QDict is transferred to this
1139 * function (even on failure), so if the caller intends to reuse the dictionary,
1140 * it needs to use QINCREF() before calling bdrv_file_open.
1142 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1144 char *backing_filename = g_malloc0(PATH_MAX);
1145 int ret = 0;
1146 BlockDriverState *backing_hd;
1147 Error *local_err = NULL;
1149 if (bs->backing_hd != NULL) {
1150 QDECREF(options);
1151 goto free_exit;
1154 /* NULL means an empty set of options */
1155 if (options == NULL) {
1156 options = qdict_new();
1159 bs->open_flags &= ~BDRV_O_NO_BACKING;
1160 if (qdict_haskey(options, "file.filename")) {
1161 backing_filename[0] = '\0';
1162 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1163 QDECREF(options);
1164 goto free_exit;
1165 } else {
1166 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1167 &local_err);
1168 if (local_err) {
1169 ret = -EINVAL;
1170 error_propagate(errp, local_err);
1171 QDECREF(options);
1172 goto free_exit;
1176 if (!bs->drv || !bs->drv->supports_backing) {
1177 ret = -EINVAL;
1178 error_setg(errp, "Driver doesn't support backing files");
1179 QDECREF(options);
1180 goto free_exit;
1183 backing_hd = bdrv_new();
1185 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1186 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1189 assert(bs->backing_hd == NULL);
1190 ret = bdrv_open_inherit(&backing_hd,
1191 *backing_filename ? backing_filename : NULL,
1192 NULL, options, 0, bs, &child_backing,
1193 NULL, &local_err);
1194 if (ret < 0) {
1195 bdrv_unref(backing_hd);
1196 backing_hd = NULL;
1197 bs->open_flags |= BDRV_O_NO_BACKING;
1198 error_setg(errp, "Could not open backing file: %s",
1199 error_get_pretty(local_err));
1200 error_free(local_err);
1201 goto free_exit;
1203 bdrv_set_backing_hd(bs, backing_hd);
1205 free_exit:
1206 g_free(backing_filename);
1207 return ret;
1211 * Opens a disk image whose options are given as BlockdevRef in another block
1212 * device's options.
1214 * If allow_none is true, no image will be opened if filename is false and no
1215 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1217 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1218 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1219 * itself, all options starting with "${bdref_key}." are considered part of the
1220 * BlockdevRef.
1222 * The BlockdevRef will be removed from the options QDict.
1224 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1226 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1227 QDict *options, const char *bdref_key,
1228 BlockDriverState* parent, const BdrvChildRole *child_role,
1229 bool allow_none, Error **errp)
1231 QDict *image_options;
1232 int ret;
1233 char *bdref_key_dot;
1234 const char *reference;
1236 assert(pbs);
1237 assert(*pbs == NULL);
1239 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1240 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1241 g_free(bdref_key_dot);
1243 reference = qdict_get_try_str(options, bdref_key);
1244 if (!filename && !reference && !qdict_size(image_options)) {
1245 if (allow_none) {
1246 ret = 0;
1247 } else {
1248 error_setg(errp, "A block device must be specified for \"%s\"",
1249 bdref_key);
1250 ret = -EINVAL;
1252 QDECREF(image_options);
1253 goto done;
1256 ret = bdrv_open_inherit(pbs, filename, reference, image_options, 0,
1257 parent, child_role, NULL, errp);
1259 done:
1260 qdict_del(options, bdref_key);
1261 return ret;
1264 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1266 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1267 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1268 int64_t total_size;
1269 QemuOpts *opts = NULL;
1270 QDict *snapshot_options;
1271 BlockDriverState *bs_snapshot;
1272 Error *local_err;
1273 int ret;
1275 /* if snapshot, we create a temporary backing file and open it
1276 instead of opening 'filename' directly */
1278 /* Get the required size from the image */
1279 total_size = bdrv_getlength(bs);
1280 if (total_size < 0) {
1281 ret = total_size;
1282 error_setg_errno(errp, -total_size, "Could not get image size");
1283 goto out;
1286 /* Create the temporary image */
1287 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1288 if (ret < 0) {
1289 error_setg_errno(errp, -ret, "Could not get temporary filename");
1290 goto out;
1293 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1294 &error_abort);
1295 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1296 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1297 qemu_opts_del(opts);
1298 if (ret < 0) {
1299 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1300 "'%s': %s", tmp_filename,
1301 error_get_pretty(local_err));
1302 error_free(local_err);
1303 goto out;
1306 /* Prepare a new options QDict for the temporary file */
1307 snapshot_options = qdict_new();
1308 qdict_put(snapshot_options, "file.driver",
1309 qstring_from_str("file"));
1310 qdict_put(snapshot_options, "file.filename",
1311 qstring_from_str(tmp_filename));
1313 bs_snapshot = bdrv_new();
1315 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1316 flags, &bdrv_qcow2, &local_err);
1317 if (ret < 0) {
1318 error_propagate(errp, local_err);
1319 goto out;
1322 bdrv_append(bs_snapshot, bs);
1324 out:
1325 g_free(tmp_filename);
1326 return ret;
1329 static void bdrv_attach_child(BlockDriverState *parent_bs,
1330 BlockDriverState *child_bs,
1331 const BdrvChildRole *child_role)
1333 BdrvChild *child = g_new(BdrvChild, 1);
1334 *child = (BdrvChild) {
1335 .bs = child_bs,
1336 .role = child_role,
1339 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1343 * Opens a disk image (raw, qcow2, vmdk, ...)
1345 * options is a QDict of options to pass to the block drivers, or NULL for an
1346 * empty set of options. The reference to the QDict belongs to the block layer
1347 * after the call (even on failure), so if the caller intends to reuse the
1348 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1350 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1351 * If it is not NULL, the referenced BDS will be reused.
1353 * The reference parameter may be used to specify an existing block device which
1354 * should be opened. If specified, neither options nor a filename may be given,
1355 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1357 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1358 const char *reference, QDict *options, int flags,
1359 BlockDriverState *parent,
1360 const BdrvChildRole *child_role,
1361 BlockDriver *drv, Error **errp)
1363 int ret;
1364 BlockDriverState *file = NULL, *bs;
1365 const char *drvname;
1366 Error *local_err = NULL;
1367 int snapshot_flags = 0;
1369 assert(pbs);
1370 assert(!child_role || !flags);
1371 assert(!child_role == !parent);
1373 if (reference) {
1374 bool options_non_empty = options ? qdict_size(options) : false;
1375 QDECREF(options);
1377 if (*pbs) {
1378 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1379 "another block device");
1380 return -EINVAL;
1383 if (filename || options_non_empty) {
1384 error_setg(errp, "Cannot reference an existing block device with "
1385 "additional options or a new filename");
1386 return -EINVAL;
1389 bs = bdrv_lookup_bs(reference, reference, errp);
1390 if (!bs) {
1391 return -ENODEV;
1393 bdrv_ref(bs);
1394 if (child_role) {
1395 bdrv_attach_child(parent, bs, child_role);
1397 *pbs = bs;
1398 return 0;
1401 if (*pbs) {
1402 bs = *pbs;
1403 } else {
1404 bs = bdrv_new();
1407 /* NULL means an empty set of options */
1408 if (options == NULL) {
1409 options = qdict_new();
1412 if (child_role) {
1413 bs->inherits_from = parent;
1414 flags = child_role->inherit_flags(parent->open_flags);
1417 ret = bdrv_fill_options(&options, &filename, &flags, drv, &local_err);
1418 if (local_err) {
1419 goto fail;
1422 /* Find the right image format driver */
1423 drv = NULL;
1424 drvname = qdict_get_try_str(options, "driver");
1425 if (drvname) {
1426 drv = bdrv_find_format(drvname);
1427 qdict_del(options, "driver");
1428 if (!drv) {
1429 error_setg(errp, "Unknown driver: '%s'", drvname);
1430 ret = -EINVAL;
1431 goto fail;
1435 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1437 bs->open_flags = flags;
1438 bs->options = options;
1439 options = qdict_clone_shallow(options);
1441 /* Open image file without format layer */
1442 if ((flags & BDRV_O_PROTOCOL) == 0) {
1443 if (flags & BDRV_O_RDWR) {
1444 flags |= BDRV_O_ALLOW_RDWR;
1446 if (flags & BDRV_O_SNAPSHOT) {
1447 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1448 flags = bdrv_backing_flags(flags);
1451 assert(file == NULL);
1452 bs->open_flags = flags;
1453 ret = bdrv_open_image(&file, filename, options, "file",
1454 bs, &child_file, true, &local_err);
1455 if (ret < 0) {
1456 goto fail;
1460 /* Image format probing */
1461 bs->probed = !drv;
1462 if (!drv && file) {
1463 ret = find_image_format(file, filename, &drv, &local_err);
1464 if (ret < 0) {
1465 goto fail;
1467 } else if (!drv) {
1468 error_setg(errp, "Must specify either driver or file");
1469 ret = -EINVAL;
1470 goto fail;
1473 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1474 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1475 /* file must be NULL if a protocol BDS is about to be created
1476 * (the inverse results in an error message from bdrv_open_common()) */
1477 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1479 /* Open the image */
1480 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1481 if (ret < 0) {
1482 goto fail;
1485 if (file && (bs->file != file)) {
1486 bdrv_unref(file);
1487 file = NULL;
1490 /* If there is a backing file, use it */
1491 if ((flags & BDRV_O_NO_BACKING) == 0) {
1492 QDict *backing_options;
1494 qdict_extract_subqdict(options, &backing_options, "backing.");
1495 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1496 if (ret < 0) {
1497 goto close_and_fail;
1501 bdrv_refresh_filename(bs);
1503 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1504 * temporary snapshot afterwards. */
1505 if (snapshot_flags) {
1506 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1507 if (local_err) {
1508 goto close_and_fail;
1512 /* Check if any unknown options were used */
1513 if (options && (qdict_size(options) != 0)) {
1514 const QDictEntry *entry = qdict_first(options);
1515 if (flags & BDRV_O_PROTOCOL) {
1516 error_setg(errp, "Block protocol '%s' doesn't support the option "
1517 "'%s'", drv->format_name, entry->key);
1518 } else {
1519 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1520 "support the option '%s'", drv->format_name,
1521 bdrv_get_device_name(bs), entry->key);
1524 ret = -EINVAL;
1525 goto close_and_fail;
1528 if (!bdrv_key_required(bs)) {
1529 if (bs->blk) {
1530 blk_dev_change_media_cb(bs->blk, true);
1532 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1533 && !runstate_check(RUN_STATE_INMIGRATE)
1534 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1535 error_setg(errp,
1536 "Guest must be stopped for opening of encrypted image");
1537 ret = -EBUSY;
1538 goto close_and_fail;
1541 if (child_role) {
1542 bdrv_attach_child(parent, bs, child_role);
1545 QDECREF(options);
1546 *pbs = bs;
1547 return 0;
1549 fail:
1550 if (file != NULL) {
1551 bdrv_unref(file);
1553 QDECREF(bs->options);
1554 QDECREF(options);
1555 bs->options = NULL;
1556 if (!*pbs) {
1557 /* If *pbs is NULL, a new BDS has been created in this function and
1558 needs to be freed now. Otherwise, it does not need to be closed,
1559 since it has not really been opened yet. */
1560 bdrv_unref(bs);
1562 if (local_err) {
1563 error_propagate(errp, local_err);
1565 return ret;
1567 close_and_fail:
1568 /* See fail path, but now the BDS has to be always closed */
1569 if (*pbs) {
1570 bdrv_close(bs);
1571 } else {
1572 bdrv_unref(bs);
1574 QDECREF(options);
1575 if (local_err) {
1576 error_propagate(errp, local_err);
1578 return ret;
1581 int bdrv_open(BlockDriverState **pbs, const char *filename,
1582 const char *reference, QDict *options, int flags,
1583 BlockDriver *drv, Error **errp)
1585 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1586 NULL, drv, errp);
1589 typedef struct BlockReopenQueueEntry {
1590 bool prepared;
1591 BDRVReopenState state;
1592 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1593 } BlockReopenQueueEntry;
1596 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1597 * reopen of multiple devices.
1599 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1600 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1601 * be created and initialized. This newly created BlockReopenQueue should be
1602 * passed back in for subsequent calls that are intended to be of the same
1603 * atomic 'set'.
1605 * bs is the BlockDriverState to add to the reopen queue.
1607 * flags contains the open flags for the associated bs
1609 * returns a pointer to bs_queue, which is either the newly allocated
1610 * bs_queue, or the existing bs_queue being used.
1613 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1614 BlockDriverState *bs, int flags)
1616 assert(bs != NULL);
1618 BlockReopenQueueEntry *bs_entry;
1619 BdrvChild *child;
1621 if (bs_queue == NULL) {
1622 bs_queue = g_new0(BlockReopenQueue, 1);
1623 QSIMPLEQ_INIT(bs_queue);
1626 /* bdrv_open() masks this flag out */
1627 flags &= ~BDRV_O_PROTOCOL;
1629 QLIST_FOREACH(child, &bs->children, next) {
1630 int child_flags;
1632 if (child->bs->inherits_from != bs) {
1633 continue;
1636 child_flags = child->role->inherit_flags(flags);
1637 bdrv_reopen_queue(bs_queue, child->bs, child_flags);
1640 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1641 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1643 bs_entry->state.bs = bs;
1644 bs_entry->state.flags = flags;
1646 return bs_queue;
1650 * Reopen multiple BlockDriverStates atomically & transactionally.
1652 * The queue passed in (bs_queue) must have been built up previous
1653 * via bdrv_reopen_queue().
1655 * Reopens all BDS specified in the queue, with the appropriate
1656 * flags. All devices are prepared for reopen, and failure of any
1657 * device will cause all device changes to be abandonded, and intermediate
1658 * data cleaned up.
1660 * If all devices prepare successfully, then the changes are committed
1661 * to all devices.
1664 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1666 int ret = -1;
1667 BlockReopenQueueEntry *bs_entry, *next;
1668 Error *local_err = NULL;
1670 assert(bs_queue != NULL);
1672 bdrv_drain_all();
1674 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1675 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1676 error_propagate(errp, local_err);
1677 goto cleanup;
1679 bs_entry->prepared = true;
1682 /* If we reach this point, we have success and just need to apply the
1683 * changes
1685 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1686 bdrv_reopen_commit(&bs_entry->state);
1689 ret = 0;
1691 cleanup:
1692 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1693 if (ret && bs_entry->prepared) {
1694 bdrv_reopen_abort(&bs_entry->state);
1696 g_free(bs_entry);
1698 g_free(bs_queue);
1699 return ret;
1703 /* Reopen a single BlockDriverState with the specified flags. */
1704 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1706 int ret = -1;
1707 Error *local_err = NULL;
1708 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1710 ret = bdrv_reopen_multiple(queue, &local_err);
1711 if (local_err != NULL) {
1712 error_propagate(errp, local_err);
1714 return ret;
1719 * Prepares a BlockDriverState for reopen. All changes are staged in the
1720 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1721 * the block driver layer .bdrv_reopen_prepare()
1723 * bs is the BlockDriverState to reopen
1724 * flags are the new open flags
1725 * queue is the reopen queue
1727 * Returns 0 on success, non-zero on error. On error errp will be set
1728 * as well.
1730 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1731 * It is the responsibility of the caller to then call the abort() or
1732 * commit() for any other BDS that have been left in a prepare() state
1735 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1736 Error **errp)
1738 int ret = -1;
1739 Error *local_err = NULL;
1740 BlockDriver *drv;
1742 assert(reopen_state != NULL);
1743 assert(reopen_state->bs->drv != NULL);
1744 drv = reopen_state->bs->drv;
1746 /* if we are to stay read-only, do not allow permission change
1747 * to r/w */
1748 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1749 reopen_state->flags & BDRV_O_RDWR) {
1750 error_setg(errp, "Node '%s' is read only",
1751 bdrv_get_device_or_node_name(reopen_state->bs));
1752 goto error;
1756 ret = bdrv_flush(reopen_state->bs);
1757 if (ret) {
1758 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1759 strerror(-ret));
1760 goto error;
1763 if (drv->bdrv_reopen_prepare) {
1764 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1765 if (ret) {
1766 if (local_err != NULL) {
1767 error_propagate(errp, local_err);
1768 } else {
1769 error_setg(errp, "failed while preparing to reopen image '%s'",
1770 reopen_state->bs->filename);
1772 goto error;
1774 } else {
1775 /* It is currently mandatory to have a bdrv_reopen_prepare()
1776 * handler for each supported drv. */
1777 error_setg(errp, "Block format '%s' used by node '%s' "
1778 "does not support reopening files", drv->format_name,
1779 bdrv_get_device_or_node_name(reopen_state->bs));
1780 ret = -1;
1781 goto error;
1784 ret = 0;
1786 error:
1787 return ret;
1791 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1792 * makes them final by swapping the staging BlockDriverState contents into
1793 * the active BlockDriverState contents.
1795 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1797 BlockDriver *drv;
1799 assert(reopen_state != NULL);
1800 drv = reopen_state->bs->drv;
1801 assert(drv != NULL);
1803 /* If there are any driver level actions to take */
1804 if (drv->bdrv_reopen_commit) {
1805 drv->bdrv_reopen_commit(reopen_state);
1808 /* set BDS specific flags now */
1809 reopen_state->bs->open_flags = reopen_state->flags;
1810 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1811 BDRV_O_CACHE_WB);
1812 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1814 bdrv_refresh_limits(reopen_state->bs, NULL);
1818 * Abort the reopen, and delete and free the staged changes in
1819 * reopen_state
1821 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1823 BlockDriver *drv;
1825 assert(reopen_state != NULL);
1826 drv = reopen_state->bs->drv;
1827 assert(drv != NULL);
1829 if (drv->bdrv_reopen_abort) {
1830 drv->bdrv_reopen_abort(reopen_state);
1835 void bdrv_close(BlockDriverState *bs)
1837 BdrvAioNotifier *ban, *ban_next;
1839 if (bs->job) {
1840 block_job_cancel_sync(bs->job);
1842 bdrv_drain_all(); /* complete I/O */
1843 bdrv_flush(bs);
1844 bdrv_drain_all(); /* in case flush left pending I/O */
1845 notifier_list_notify(&bs->close_notifiers, bs);
1847 if (bs->drv) {
1848 BdrvChild *child, *next;
1850 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1851 if (child->bs->inherits_from == bs) {
1852 child->bs->inherits_from = NULL;
1854 QLIST_REMOVE(child, next);
1855 g_free(child);
1858 if (bs->backing_hd) {
1859 BlockDriverState *backing_hd = bs->backing_hd;
1860 bdrv_set_backing_hd(bs, NULL);
1861 bdrv_unref(backing_hd);
1863 bs->drv->bdrv_close(bs);
1864 g_free(bs->opaque);
1865 bs->opaque = NULL;
1866 bs->drv = NULL;
1867 bs->copy_on_read = 0;
1868 bs->backing_file[0] = '\0';
1869 bs->backing_format[0] = '\0';
1870 bs->total_sectors = 0;
1871 bs->encrypted = 0;
1872 bs->valid_key = 0;
1873 bs->sg = 0;
1874 bs->zero_beyond_eof = false;
1875 QDECREF(bs->options);
1876 bs->options = NULL;
1877 QDECREF(bs->full_open_options);
1878 bs->full_open_options = NULL;
1880 if (bs->file != NULL) {
1881 bdrv_unref(bs->file);
1882 bs->file = NULL;
1886 if (bs->blk) {
1887 blk_dev_change_media_cb(bs->blk, false);
1890 /*throttling disk I/O limits*/
1891 if (bs->io_limits_enabled) {
1892 bdrv_io_limits_disable(bs);
1895 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1896 g_free(ban);
1898 QLIST_INIT(&bs->aio_notifiers);
1901 void bdrv_close_all(void)
1903 BlockDriverState *bs;
1905 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1906 AioContext *aio_context = bdrv_get_aio_context(bs);
1908 aio_context_acquire(aio_context);
1909 bdrv_close(bs);
1910 aio_context_release(aio_context);
1914 /* make a BlockDriverState anonymous by removing from bdrv_state and
1915 * graph_bdrv_state list.
1916 Also, NULL terminate the device_name to prevent double remove */
1917 void bdrv_make_anon(BlockDriverState *bs)
1920 * Take care to remove bs from bdrv_states only when it's actually
1921 * in it. Note that bs->device_list.tqe_prev is initially null,
1922 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1923 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1924 * resetting it to null on remove.
1926 if (bs->device_list.tqe_prev) {
1927 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1928 bs->device_list.tqe_prev = NULL;
1930 if (bs->node_name[0] != '\0') {
1931 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1933 bs->node_name[0] = '\0';
1936 static void bdrv_rebind(BlockDriverState *bs)
1938 if (bs->drv && bs->drv->bdrv_rebind) {
1939 bs->drv->bdrv_rebind(bs);
1943 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1944 BlockDriverState *bs_src)
1946 /* move some fields that need to stay attached to the device */
1948 /* dev info */
1949 bs_dest->guest_block_size = bs_src->guest_block_size;
1950 bs_dest->copy_on_read = bs_src->copy_on_read;
1952 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1954 /* i/o throttled req */
1955 bs_dest->throttle_state = bs_src->throttle_state,
1956 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1957 bs_dest->pending_reqs[0] = bs_src->pending_reqs[0];
1958 bs_dest->pending_reqs[1] = bs_src->pending_reqs[1];
1959 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1960 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
1961 memcpy(&bs_dest->round_robin,
1962 &bs_src->round_robin,
1963 sizeof(bs_dest->round_robin));
1964 memcpy(&bs_dest->throttle_timers,
1965 &bs_src->throttle_timers,
1966 sizeof(ThrottleTimers));
1968 /* r/w error */
1969 bs_dest->on_read_error = bs_src->on_read_error;
1970 bs_dest->on_write_error = bs_src->on_write_error;
1972 /* i/o status */
1973 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1974 bs_dest->iostatus = bs_src->iostatus;
1976 /* dirty bitmap */
1977 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
1979 /* reference count */
1980 bs_dest->refcnt = bs_src->refcnt;
1982 /* job */
1983 bs_dest->job = bs_src->job;
1985 /* keep the same entry in bdrv_states */
1986 bs_dest->device_list = bs_src->device_list;
1987 bs_dest->blk = bs_src->blk;
1989 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
1990 sizeof(bs_dest->op_blockers));
1994 * Swap bs contents for two image chains while they are live,
1995 * while keeping required fields on the BlockDriverState that is
1996 * actually attached to a device.
1998 * This will modify the BlockDriverState fields, and swap contents
1999 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2001 * bs_new must not be attached to a BlockBackend.
2003 * This function does not create any image files.
2005 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2007 BlockDriverState tmp;
2008 BdrvChild *child;
2010 bdrv_drain(bs_new);
2011 bdrv_drain(bs_old);
2013 /* The code needs to swap the node_name but simply swapping node_list won't
2014 * work so first remove the nodes from the graph list, do the swap then
2015 * insert them back if needed.
2017 if (bs_new->node_name[0] != '\0') {
2018 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2020 if (bs_old->node_name[0] != '\0') {
2021 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2024 /* If the BlockDriverState is part of a throttling group acquire
2025 * its lock since we're going to mess with the protected fields.
2026 * Otherwise there's no need to worry since no one else can touch
2027 * them. */
2028 if (bs_old->throttle_state) {
2029 throttle_group_lock(bs_old);
2032 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2033 assert(!bs_new->blk);
2034 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2035 assert(bs_new->job == NULL);
2036 assert(bs_new->io_limits_enabled == false);
2037 assert(bs_new->throttle_state == NULL);
2038 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2040 tmp = *bs_new;
2041 *bs_new = *bs_old;
2042 *bs_old = tmp;
2044 /* there are some fields that should not be swapped, move them back */
2045 bdrv_move_feature_fields(&tmp, bs_old);
2046 bdrv_move_feature_fields(bs_old, bs_new);
2047 bdrv_move_feature_fields(bs_new, &tmp);
2049 /* bs_new must remain unattached */
2050 assert(!bs_new->blk);
2052 /* Check a few fields that should remain attached to the device */
2053 assert(bs_new->job == NULL);
2054 assert(bs_new->io_limits_enabled == false);
2055 assert(bs_new->throttle_state == NULL);
2056 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2058 /* Release the ThrottleGroup lock */
2059 if (bs_old->throttle_state) {
2060 throttle_group_unlock(bs_old);
2063 /* insert the nodes back into the graph node list if needed */
2064 if (bs_new->node_name[0] != '\0') {
2065 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2067 if (bs_old->node_name[0] != '\0') {
2068 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2072 * Update lh_first.le_prev for non-empty lists.
2074 * The head of the op blocker list doesn't change because it is moved back
2075 * in bdrv_move_feature_fields().
2077 assert(QLIST_EMPTY(&bs_old->tracked_requests));
2078 assert(QLIST_EMPTY(&bs_new->tracked_requests));
2080 QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2081 QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2083 /* Update references in bs->opaque and children */
2084 QLIST_FOREACH(child, &bs_old->children, next) {
2085 if (child->bs->inherits_from == bs_new) {
2086 child->bs->inherits_from = bs_old;
2089 QLIST_FOREACH(child, &bs_new->children, next) {
2090 if (child->bs->inherits_from == bs_old) {
2091 child->bs->inherits_from = bs_new;
2095 bdrv_rebind(bs_new);
2096 bdrv_rebind(bs_old);
2100 * Add new bs contents at the top of an image chain while the chain is
2101 * live, while keeping required fields on the top layer.
2103 * This will modify the BlockDriverState fields, and swap contents
2104 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2106 * bs_new must not be attached to a BlockBackend.
2108 * This function does not create any image files.
2110 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2112 bdrv_swap(bs_new, bs_top);
2114 /* The contents of 'tmp' will become bs_top, as we are
2115 * swapping bs_new and bs_top contents. */
2116 bdrv_set_backing_hd(bs_top, bs_new);
2117 bdrv_attach_child(bs_top, bs_new, &child_backing);
2120 static void bdrv_delete(BlockDriverState *bs)
2122 assert(!bs->job);
2123 assert(bdrv_op_blocker_is_empty(bs));
2124 assert(!bs->refcnt);
2125 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2127 bdrv_close(bs);
2129 /* remove from list, if necessary */
2130 bdrv_make_anon(bs);
2132 g_free(bs);
2136 * Run consistency checks on an image
2138 * Returns 0 if the check could be completed (it doesn't mean that the image is
2139 * free of errors) or -errno when an internal error occurred. The results of the
2140 * check are stored in res.
2142 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2144 if (bs->drv == NULL) {
2145 return -ENOMEDIUM;
2147 if (bs->drv->bdrv_check == NULL) {
2148 return -ENOTSUP;
2151 memset(res, 0, sizeof(*res));
2152 return bs->drv->bdrv_check(bs, res, fix);
2155 #define COMMIT_BUF_SECTORS 2048
2157 /* commit COW file into the raw image */
2158 int bdrv_commit(BlockDriverState *bs)
2160 BlockDriver *drv = bs->drv;
2161 int64_t sector, total_sectors, length, backing_length;
2162 int n, ro, open_flags;
2163 int ret = 0;
2164 uint8_t *buf = NULL;
2166 if (!drv)
2167 return -ENOMEDIUM;
2169 if (!bs->backing_hd) {
2170 return -ENOTSUP;
2173 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2174 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2175 return -EBUSY;
2178 ro = bs->backing_hd->read_only;
2179 open_flags = bs->backing_hd->open_flags;
2181 if (ro) {
2182 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2183 return -EACCES;
2187 length = bdrv_getlength(bs);
2188 if (length < 0) {
2189 ret = length;
2190 goto ro_cleanup;
2193 backing_length = bdrv_getlength(bs->backing_hd);
2194 if (backing_length < 0) {
2195 ret = backing_length;
2196 goto ro_cleanup;
2199 /* If our top snapshot is larger than the backing file image,
2200 * grow the backing file image if possible. If not possible,
2201 * we must return an error */
2202 if (length > backing_length) {
2203 ret = bdrv_truncate(bs->backing_hd, length);
2204 if (ret < 0) {
2205 goto ro_cleanup;
2209 total_sectors = length >> BDRV_SECTOR_BITS;
2211 /* qemu_try_blockalign() for bs will choose an alignment that works for
2212 * bs->backing_hd as well, so no need to compare the alignment manually. */
2213 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2214 if (buf == NULL) {
2215 ret = -ENOMEM;
2216 goto ro_cleanup;
2219 for (sector = 0; sector < total_sectors; sector += n) {
2220 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2221 if (ret < 0) {
2222 goto ro_cleanup;
2224 if (ret) {
2225 ret = bdrv_read(bs, sector, buf, n);
2226 if (ret < 0) {
2227 goto ro_cleanup;
2230 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2231 if (ret < 0) {
2232 goto ro_cleanup;
2237 if (drv->bdrv_make_empty) {
2238 ret = drv->bdrv_make_empty(bs);
2239 if (ret < 0) {
2240 goto ro_cleanup;
2242 bdrv_flush(bs);
2246 * Make sure all data we wrote to the backing device is actually
2247 * stable on disk.
2249 if (bs->backing_hd) {
2250 bdrv_flush(bs->backing_hd);
2253 ret = 0;
2254 ro_cleanup:
2255 qemu_vfree(buf);
2257 if (ro) {
2258 /* ignoring error return here */
2259 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2262 return ret;
2265 int bdrv_commit_all(void)
2267 BlockDriverState *bs;
2269 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2270 AioContext *aio_context = bdrv_get_aio_context(bs);
2272 aio_context_acquire(aio_context);
2273 if (bs->drv && bs->backing_hd) {
2274 int ret = bdrv_commit(bs);
2275 if (ret < 0) {
2276 aio_context_release(aio_context);
2277 return ret;
2280 aio_context_release(aio_context);
2282 return 0;
2286 * Return values:
2287 * 0 - success
2288 * -EINVAL - backing format specified, but no file
2289 * -ENOSPC - can't update the backing file because no space is left in the
2290 * image file header
2291 * -ENOTSUP - format driver doesn't support changing the backing file
2293 int bdrv_change_backing_file(BlockDriverState *bs,
2294 const char *backing_file, const char *backing_fmt)
2296 BlockDriver *drv = bs->drv;
2297 int ret;
2299 /* Backing file format doesn't make sense without a backing file */
2300 if (backing_fmt && !backing_file) {
2301 return -EINVAL;
2304 if (drv->bdrv_change_backing_file != NULL) {
2305 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2306 } else {
2307 ret = -ENOTSUP;
2310 if (ret == 0) {
2311 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2312 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2314 return ret;
2318 * Finds the image layer in the chain that has 'bs' as its backing file.
2320 * active is the current topmost image.
2322 * Returns NULL if bs is not found in active's image chain,
2323 * or if active == bs.
2325 * Returns the bottommost base image if bs == NULL.
2327 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2328 BlockDriverState *bs)
2330 while (active && bs != active->backing_hd) {
2331 active = active->backing_hd;
2334 return active;
2337 /* Given a BDS, searches for the base layer. */
2338 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2340 return bdrv_find_overlay(bs, NULL);
2343 typedef struct BlkIntermediateStates {
2344 BlockDriverState *bs;
2345 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2346 } BlkIntermediateStates;
2350 * Drops images above 'base' up to and including 'top', and sets the image
2351 * above 'top' to have base as its backing file.
2353 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2354 * information in 'bs' can be properly updated.
2356 * E.g., this will convert the following chain:
2357 * bottom <- base <- intermediate <- top <- active
2359 * to
2361 * bottom <- base <- active
2363 * It is allowed for bottom==base, in which case it converts:
2365 * base <- intermediate <- top <- active
2367 * to
2369 * base <- active
2371 * If backing_file_str is non-NULL, it will be used when modifying top's
2372 * overlay image metadata.
2374 * Error conditions:
2375 * if active == top, that is considered an error
2378 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2379 BlockDriverState *base, const char *backing_file_str)
2381 BlockDriverState *intermediate;
2382 BlockDriverState *base_bs = NULL;
2383 BlockDriverState *new_top_bs = NULL;
2384 BlkIntermediateStates *intermediate_state, *next;
2385 int ret = -EIO;
2387 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2388 QSIMPLEQ_INIT(&states_to_delete);
2390 if (!top->drv || !base->drv) {
2391 goto exit;
2394 new_top_bs = bdrv_find_overlay(active, top);
2396 if (new_top_bs == NULL) {
2397 /* we could not find the image above 'top', this is an error */
2398 goto exit;
2401 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2402 * to do, no intermediate images */
2403 if (new_top_bs->backing_hd == base) {
2404 ret = 0;
2405 goto exit;
2408 intermediate = top;
2410 /* now we will go down through the list, and add each BDS we find
2411 * into our deletion queue, until we hit the 'base'
2413 while (intermediate) {
2414 intermediate_state = g_new0(BlkIntermediateStates, 1);
2415 intermediate_state->bs = intermediate;
2416 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2418 if (intermediate->backing_hd == base) {
2419 base_bs = intermediate->backing_hd;
2420 break;
2422 intermediate = intermediate->backing_hd;
2424 if (base_bs == NULL) {
2425 /* something went wrong, we did not end at the base. safely
2426 * unravel everything, and exit with error */
2427 goto exit;
2430 /* success - we can delete the intermediate states, and link top->base */
2431 backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2432 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2433 base_bs->drv ? base_bs->drv->format_name : "");
2434 if (ret) {
2435 goto exit;
2437 bdrv_set_backing_hd(new_top_bs, base_bs);
2439 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2440 /* so that bdrv_close() does not recursively close the chain */
2441 bdrv_set_backing_hd(intermediate_state->bs, NULL);
2442 bdrv_unref(intermediate_state->bs);
2444 ret = 0;
2446 exit:
2447 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2448 g_free(intermediate_state);
2450 return ret;
2454 * Truncate file to 'offset' bytes (needed only for file protocols)
2456 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2458 BlockDriver *drv = bs->drv;
2459 int ret;
2460 if (!drv)
2461 return -ENOMEDIUM;
2462 if (!drv->bdrv_truncate)
2463 return -ENOTSUP;
2464 if (bs->read_only)
2465 return -EACCES;
2467 ret = drv->bdrv_truncate(bs, offset);
2468 if (ret == 0) {
2469 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2470 bdrv_dirty_bitmap_truncate(bs);
2471 if (bs->blk) {
2472 blk_dev_resize_cb(bs->blk);
2475 return ret;
2479 * Length of a allocated file in bytes. Sparse files are counted by actual
2480 * allocated space. Return < 0 if error or unknown.
2482 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2484 BlockDriver *drv = bs->drv;
2485 if (!drv) {
2486 return -ENOMEDIUM;
2488 if (drv->bdrv_get_allocated_file_size) {
2489 return drv->bdrv_get_allocated_file_size(bs);
2491 if (bs->file) {
2492 return bdrv_get_allocated_file_size(bs->file);
2494 return -ENOTSUP;
2498 * Return number of sectors on success, -errno on error.
2500 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2502 BlockDriver *drv = bs->drv;
2504 if (!drv)
2505 return -ENOMEDIUM;
2507 if (drv->has_variable_length) {
2508 int ret = refresh_total_sectors(bs, bs->total_sectors);
2509 if (ret < 0) {
2510 return ret;
2513 return bs->total_sectors;
2517 * Return length in bytes on success, -errno on error.
2518 * The length is always a multiple of BDRV_SECTOR_SIZE.
2520 int64_t bdrv_getlength(BlockDriverState *bs)
2522 int64_t ret = bdrv_nb_sectors(bs);
2524 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2525 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2528 /* return 0 as number of sectors if no device present or error */
2529 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2531 int64_t nb_sectors = bdrv_nb_sectors(bs);
2533 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2536 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2537 BlockdevOnError on_write_error)
2539 bs->on_read_error = on_read_error;
2540 bs->on_write_error = on_write_error;
2543 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2545 return is_read ? bs->on_read_error : bs->on_write_error;
2548 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2550 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2552 switch (on_err) {
2553 case BLOCKDEV_ON_ERROR_ENOSPC:
2554 return (error == ENOSPC) ?
2555 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2556 case BLOCKDEV_ON_ERROR_STOP:
2557 return BLOCK_ERROR_ACTION_STOP;
2558 case BLOCKDEV_ON_ERROR_REPORT:
2559 return BLOCK_ERROR_ACTION_REPORT;
2560 case BLOCKDEV_ON_ERROR_IGNORE:
2561 return BLOCK_ERROR_ACTION_IGNORE;
2562 default:
2563 abort();
2567 static void send_qmp_error_event(BlockDriverState *bs,
2568 BlockErrorAction action,
2569 bool is_read, int error)
2571 IoOperationType optype;
2573 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2574 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2575 bdrv_iostatus_is_enabled(bs),
2576 error == ENOSPC, strerror(error),
2577 &error_abort);
2580 /* This is done by device models because, while the block layer knows
2581 * about the error, it does not know whether an operation comes from
2582 * the device or the block layer (from a job, for example).
2584 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2585 bool is_read, int error)
2587 assert(error >= 0);
2589 if (action == BLOCK_ERROR_ACTION_STOP) {
2590 /* First set the iostatus, so that "info block" returns an iostatus
2591 * that matches the events raised so far (an additional error iostatus
2592 * is fine, but not a lost one).
2594 bdrv_iostatus_set_err(bs, error);
2596 /* Then raise the request to stop the VM and the event.
2597 * qemu_system_vmstop_request_prepare has two effects. First,
2598 * it ensures that the STOP event always comes after the
2599 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2600 * can observe the STOP event and do a "cont" before the STOP
2601 * event is issued, the VM will not stop. In this case, vm_start()
2602 * also ensures that the STOP/RESUME pair of events is emitted.
2604 qemu_system_vmstop_request_prepare();
2605 send_qmp_error_event(bs, action, is_read, error);
2606 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2607 } else {
2608 send_qmp_error_event(bs, action, is_read, error);
2612 int bdrv_is_read_only(BlockDriverState *bs)
2614 return bs->read_only;
2617 int bdrv_is_sg(BlockDriverState *bs)
2619 return bs->sg;
2622 int bdrv_enable_write_cache(BlockDriverState *bs)
2624 return bs->enable_write_cache;
2627 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2629 bs->enable_write_cache = wce;
2631 /* so a reopen() will preserve wce */
2632 if (wce) {
2633 bs->open_flags |= BDRV_O_CACHE_WB;
2634 } else {
2635 bs->open_flags &= ~BDRV_O_CACHE_WB;
2639 int bdrv_is_encrypted(BlockDriverState *bs)
2641 if (bs->backing_hd && bs->backing_hd->encrypted)
2642 return 1;
2643 return bs->encrypted;
2646 int bdrv_key_required(BlockDriverState *bs)
2648 BlockDriverState *backing_hd = bs->backing_hd;
2650 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2651 return 1;
2652 return (bs->encrypted && !bs->valid_key);
2655 int bdrv_set_key(BlockDriverState *bs, const char *key)
2657 int ret;
2658 if (bs->backing_hd && bs->backing_hd->encrypted) {
2659 ret = bdrv_set_key(bs->backing_hd, key);
2660 if (ret < 0)
2661 return ret;
2662 if (!bs->encrypted)
2663 return 0;
2665 if (!bs->encrypted) {
2666 return -EINVAL;
2667 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2668 return -ENOMEDIUM;
2670 ret = bs->drv->bdrv_set_key(bs, key);
2671 if (ret < 0) {
2672 bs->valid_key = 0;
2673 } else if (!bs->valid_key) {
2674 bs->valid_key = 1;
2675 if (bs->blk) {
2676 /* call the change callback now, we skipped it on open */
2677 blk_dev_change_media_cb(bs->blk, true);
2680 return ret;
2684 * Provide an encryption key for @bs.
2685 * If @key is non-null:
2686 * If @bs is not encrypted, fail.
2687 * Else if the key is invalid, fail.
2688 * Else set @bs's key to @key, replacing the existing key, if any.
2689 * If @key is null:
2690 * If @bs is encrypted and still lacks a key, fail.
2691 * Else do nothing.
2692 * On failure, store an error object through @errp if non-null.
2694 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2696 if (key) {
2697 if (!bdrv_is_encrypted(bs)) {
2698 error_setg(errp, "Node '%s' is not encrypted",
2699 bdrv_get_device_or_node_name(bs));
2700 } else if (bdrv_set_key(bs, key) < 0) {
2701 error_set(errp, QERR_INVALID_PASSWORD);
2703 } else {
2704 if (bdrv_key_required(bs)) {
2705 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2706 "'%s' (%s) is encrypted",
2707 bdrv_get_device_or_node_name(bs),
2708 bdrv_get_encrypted_filename(bs));
2713 const char *bdrv_get_format_name(BlockDriverState *bs)
2715 return bs->drv ? bs->drv->format_name : NULL;
2718 static int qsort_strcmp(const void *a, const void *b)
2720 return strcmp(a, b);
2723 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2724 void *opaque)
2726 BlockDriver *drv;
2727 int count = 0;
2728 int i;
2729 const char **formats = NULL;
2731 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2732 if (drv->format_name) {
2733 bool found = false;
2734 int i = count;
2735 while (formats && i && !found) {
2736 found = !strcmp(formats[--i], drv->format_name);
2739 if (!found) {
2740 formats = g_renew(const char *, formats, count + 1);
2741 formats[count++] = drv->format_name;
2746 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2748 for (i = 0; i < count; i++) {
2749 it(opaque, formats[i]);
2752 g_free(formats);
2755 /* This function is to find a node in the bs graph */
2756 BlockDriverState *bdrv_find_node(const char *node_name)
2758 BlockDriverState *bs;
2760 assert(node_name);
2762 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2763 if (!strcmp(node_name, bs->node_name)) {
2764 return bs;
2767 return NULL;
2770 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2771 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2773 BlockDeviceInfoList *list, *entry;
2774 BlockDriverState *bs;
2776 list = NULL;
2777 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2778 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2779 if (!info) {
2780 qapi_free_BlockDeviceInfoList(list);
2781 return NULL;
2783 entry = g_malloc0(sizeof(*entry));
2784 entry->value = info;
2785 entry->next = list;
2786 list = entry;
2789 return list;
2792 BlockDriverState *bdrv_lookup_bs(const char *device,
2793 const char *node_name,
2794 Error **errp)
2796 BlockBackend *blk;
2797 BlockDriverState *bs;
2799 if (device) {
2800 blk = blk_by_name(device);
2802 if (blk) {
2803 return blk_bs(blk);
2807 if (node_name) {
2808 bs = bdrv_find_node(node_name);
2810 if (bs) {
2811 return bs;
2815 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2816 device ? device : "",
2817 node_name ? node_name : "");
2818 return NULL;
2821 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2822 * return false. If either argument is NULL, return false. */
2823 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2825 while (top && top != base) {
2826 top = top->backing_hd;
2829 return top != NULL;
2832 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2834 if (!bs) {
2835 return QTAILQ_FIRST(&graph_bdrv_states);
2837 return QTAILQ_NEXT(bs, node_list);
2840 BlockDriverState *bdrv_next(BlockDriverState *bs)
2842 if (!bs) {
2843 return QTAILQ_FIRST(&bdrv_states);
2845 return QTAILQ_NEXT(bs, device_list);
2848 const char *bdrv_get_node_name(const BlockDriverState *bs)
2850 return bs->node_name;
2853 /* TODO check what callers really want: bs->node_name or blk_name() */
2854 const char *bdrv_get_device_name(const BlockDriverState *bs)
2856 return bs->blk ? blk_name(bs->blk) : "";
2859 /* This can be used to identify nodes that might not have a device
2860 * name associated. Since node and device names live in the same
2861 * namespace, the result is unambiguous. The exception is if both are
2862 * absent, then this returns an empty (non-null) string. */
2863 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2865 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2868 int bdrv_get_flags(BlockDriverState *bs)
2870 return bs->open_flags;
2873 int bdrv_has_zero_init_1(BlockDriverState *bs)
2875 return 1;
2878 int bdrv_has_zero_init(BlockDriverState *bs)
2880 assert(bs->drv);
2882 /* If BS is a copy on write image, it is initialized to
2883 the contents of the base image, which may not be zeroes. */
2884 if (bs->backing_hd) {
2885 return 0;
2887 if (bs->drv->bdrv_has_zero_init) {
2888 return bs->drv->bdrv_has_zero_init(bs);
2891 /* safe default */
2892 return 0;
2895 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2897 BlockDriverInfo bdi;
2899 if (bs->backing_hd) {
2900 return false;
2903 if (bdrv_get_info(bs, &bdi) == 0) {
2904 return bdi.unallocated_blocks_are_zero;
2907 return false;
2910 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2912 BlockDriverInfo bdi;
2914 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
2915 return false;
2918 if (bdrv_get_info(bs, &bdi) == 0) {
2919 return bdi.can_write_zeroes_with_unmap;
2922 return false;
2925 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2927 if (bs->backing_hd && bs->backing_hd->encrypted)
2928 return bs->backing_file;
2929 else if (bs->encrypted)
2930 return bs->filename;
2931 else
2932 return NULL;
2935 void bdrv_get_backing_filename(BlockDriverState *bs,
2936 char *filename, int filename_size)
2938 pstrcpy(filename, filename_size, bs->backing_file);
2941 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2943 BlockDriver *drv = bs->drv;
2944 if (!drv)
2945 return -ENOMEDIUM;
2946 if (!drv->bdrv_get_info)
2947 return -ENOTSUP;
2948 memset(bdi, 0, sizeof(*bdi));
2949 return drv->bdrv_get_info(bs, bdi);
2952 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
2954 BlockDriver *drv = bs->drv;
2955 if (drv && drv->bdrv_get_specific_info) {
2956 return drv->bdrv_get_specific_info(bs);
2958 return NULL;
2961 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
2963 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
2964 return;
2967 bs->drv->bdrv_debug_event(bs, event);
2970 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
2971 const char *tag)
2973 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
2974 bs = bs->file;
2977 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
2978 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
2981 return -ENOTSUP;
2984 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
2986 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
2987 bs = bs->file;
2990 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
2991 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
2994 return -ENOTSUP;
2997 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
2999 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3000 bs = bs->file;
3003 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3004 return bs->drv->bdrv_debug_resume(bs, tag);
3007 return -ENOTSUP;
3010 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3012 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3013 bs = bs->file;
3016 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3017 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3020 return false;
3023 int bdrv_is_snapshot(BlockDriverState *bs)
3025 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3028 /* backing_file can either be relative, or absolute, or a protocol. If it is
3029 * relative, it must be relative to the chain. So, passing in bs->filename
3030 * from a BDS as backing_file should not be done, as that may be relative to
3031 * the CWD rather than the chain. */
3032 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3033 const char *backing_file)
3035 char *filename_full = NULL;
3036 char *backing_file_full = NULL;
3037 char *filename_tmp = NULL;
3038 int is_protocol = 0;
3039 BlockDriverState *curr_bs = NULL;
3040 BlockDriverState *retval = NULL;
3042 if (!bs || !bs->drv || !backing_file) {
3043 return NULL;
3046 filename_full = g_malloc(PATH_MAX);
3047 backing_file_full = g_malloc(PATH_MAX);
3048 filename_tmp = g_malloc(PATH_MAX);
3050 is_protocol = path_has_protocol(backing_file);
3052 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3054 /* If either of the filename paths is actually a protocol, then
3055 * compare unmodified paths; otherwise make paths relative */
3056 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3057 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3058 retval = curr_bs->backing_hd;
3059 break;
3061 } else {
3062 /* If not an absolute filename path, make it relative to the current
3063 * image's filename path */
3064 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3065 backing_file);
3067 /* We are going to compare absolute pathnames */
3068 if (!realpath(filename_tmp, filename_full)) {
3069 continue;
3072 /* We need to make sure the backing filename we are comparing against
3073 * is relative to the current image filename (or absolute) */
3074 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3075 curr_bs->backing_file);
3077 if (!realpath(filename_tmp, backing_file_full)) {
3078 continue;
3081 if (strcmp(backing_file_full, filename_full) == 0) {
3082 retval = curr_bs->backing_hd;
3083 break;
3088 g_free(filename_full);
3089 g_free(backing_file_full);
3090 g_free(filename_tmp);
3091 return retval;
3094 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3096 if (!bs->drv) {
3097 return 0;
3100 if (!bs->backing_hd) {
3101 return 0;
3104 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3107 void bdrv_init(void)
3109 module_call_init(MODULE_INIT_BLOCK);
3112 void bdrv_init_with_whitelist(void)
3114 use_bdrv_whitelist = 1;
3115 bdrv_init();
3118 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3120 Error *local_err = NULL;
3121 int ret;
3123 if (!bs->drv) {
3124 return;
3127 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3128 return;
3130 bs->open_flags &= ~BDRV_O_INCOMING;
3132 if (bs->drv->bdrv_invalidate_cache) {
3133 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3134 } else if (bs->file) {
3135 bdrv_invalidate_cache(bs->file, &local_err);
3137 if (local_err) {
3138 error_propagate(errp, local_err);
3139 return;
3142 ret = refresh_total_sectors(bs, bs->total_sectors);
3143 if (ret < 0) {
3144 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3145 return;
3149 void bdrv_invalidate_cache_all(Error **errp)
3151 BlockDriverState *bs;
3152 Error *local_err = NULL;
3154 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3155 AioContext *aio_context = bdrv_get_aio_context(bs);
3157 aio_context_acquire(aio_context);
3158 bdrv_invalidate_cache(bs, &local_err);
3159 aio_context_release(aio_context);
3160 if (local_err) {
3161 error_propagate(errp, local_err);
3162 return;
3167 /**************************************************************/
3168 /* removable device support */
3171 * Return TRUE if the media is present
3173 int bdrv_is_inserted(BlockDriverState *bs)
3175 BlockDriver *drv = bs->drv;
3177 if (!drv)
3178 return 0;
3179 if (!drv->bdrv_is_inserted)
3180 return 1;
3181 return drv->bdrv_is_inserted(bs);
3185 * Return whether the media changed since the last call to this
3186 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3188 int bdrv_media_changed(BlockDriverState *bs)
3190 BlockDriver *drv = bs->drv;
3192 if (drv && drv->bdrv_media_changed) {
3193 return drv->bdrv_media_changed(bs);
3195 return -ENOTSUP;
3199 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3201 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3203 BlockDriver *drv = bs->drv;
3204 const char *device_name;
3206 if (drv && drv->bdrv_eject) {
3207 drv->bdrv_eject(bs, eject_flag);
3210 device_name = bdrv_get_device_name(bs);
3211 if (device_name[0] != '\0') {
3212 qapi_event_send_device_tray_moved(device_name,
3213 eject_flag, &error_abort);
3218 * Lock or unlock the media (if it is locked, the user won't be able
3219 * to eject it manually).
3221 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3223 BlockDriver *drv = bs->drv;
3225 trace_bdrv_lock_medium(bs, locked);
3227 if (drv && drv->bdrv_lock_medium) {
3228 drv->bdrv_lock_medium(bs, locked);
3232 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3234 bs->guest_block_size = align;
3237 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3239 BdrvDirtyBitmap *bm;
3241 assert(name);
3242 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3243 if (bm->name && !strcmp(name, bm->name)) {
3244 return bm;
3247 return NULL;
3250 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3252 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3253 g_free(bitmap->name);
3254 bitmap->name = NULL;
3257 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3258 uint32_t granularity,
3259 const char *name,
3260 Error **errp)
3262 int64_t bitmap_size;
3263 BdrvDirtyBitmap *bitmap;
3264 uint32_t sector_granularity;
3266 assert((granularity & (granularity - 1)) == 0);
3268 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3269 error_setg(errp, "Bitmap already exists: %s", name);
3270 return NULL;
3272 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3273 assert(sector_granularity);
3274 bitmap_size = bdrv_nb_sectors(bs);
3275 if (bitmap_size < 0) {
3276 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3277 errno = -bitmap_size;
3278 return NULL;
3280 bitmap = g_new0(BdrvDirtyBitmap, 1);
3281 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3282 bitmap->size = bitmap_size;
3283 bitmap->name = g_strdup(name);
3284 bitmap->disabled = false;
3285 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3286 return bitmap;
3289 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3291 return bitmap->successor;
3294 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3296 return !(bitmap->disabled || bitmap->successor);
3299 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3301 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3302 return DIRTY_BITMAP_STATUS_FROZEN;
3303 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3304 return DIRTY_BITMAP_STATUS_DISABLED;
3305 } else {
3306 return DIRTY_BITMAP_STATUS_ACTIVE;
3311 * Create a successor bitmap destined to replace this bitmap after an operation.
3312 * Requires that the bitmap is not frozen and has no successor.
3314 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3315 BdrvDirtyBitmap *bitmap, Error **errp)
3317 uint64_t granularity;
3318 BdrvDirtyBitmap *child;
3320 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3321 error_setg(errp, "Cannot create a successor for a bitmap that is "
3322 "currently frozen");
3323 return -1;
3325 assert(!bitmap->successor);
3327 /* Create an anonymous successor */
3328 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3329 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3330 if (!child) {
3331 return -1;
3334 /* Successor will be on or off based on our current state. */
3335 child->disabled = bitmap->disabled;
3337 /* Install the successor and freeze the parent */
3338 bitmap->successor = child;
3339 return 0;
3343 * For a bitmap with a successor, yield our name to the successor,
3344 * delete the old bitmap, and return a handle to the new bitmap.
3346 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3347 BdrvDirtyBitmap *bitmap,
3348 Error **errp)
3350 char *name;
3351 BdrvDirtyBitmap *successor = bitmap->successor;
3353 if (successor == NULL) {
3354 error_setg(errp, "Cannot relinquish control if "
3355 "there's no successor present");
3356 return NULL;
3359 name = bitmap->name;
3360 bitmap->name = NULL;
3361 successor->name = name;
3362 bitmap->successor = NULL;
3363 bdrv_release_dirty_bitmap(bs, bitmap);
3365 return successor;
3369 * In cases of failure where we can no longer safely delete the parent,
3370 * we may wish to re-join the parent and child/successor.
3371 * The merged parent will be un-frozen, but not explicitly re-enabled.
3373 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3374 BdrvDirtyBitmap *parent,
3375 Error **errp)
3377 BdrvDirtyBitmap *successor = parent->successor;
3379 if (!successor) {
3380 error_setg(errp, "Cannot reclaim a successor when none is present");
3381 return NULL;
3384 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3385 error_setg(errp, "Merging of parent and successor bitmap failed");
3386 return NULL;
3388 bdrv_release_dirty_bitmap(bs, successor);
3389 parent->successor = NULL;
3391 return parent;
3395 * Truncates _all_ bitmaps attached to a BDS.
3397 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3399 BdrvDirtyBitmap *bitmap;
3400 uint64_t size = bdrv_nb_sectors(bs);
3402 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3403 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3404 hbitmap_truncate(bitmap->bitmap, size);
3405 bitmap->size = size;
3409 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3411 BdrvDirtyBitmap *bm, *next;
3412 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3413 if (bm == bitmap) {
3414 assert(!bdrv_dirty_bitmap_frozen(bm));
3415 QLIST_REMOVE(bitmap, list);
3416 hbitmap_free(bitmap->bitmap);
3417 g_free(bitmap->name);
3418 g_free(bitmap);
3419 return;
3424 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3426 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3427 bitmap->disabled = true;
3430 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3432 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3433 bitmap->disabled = false;
3436 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3438 BdrvDirtyBitmap *bm;
3439 BlockDirtyInfoList *list = NULL;
3440 BlockDirtyInfoList **plist = &list;
3442 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3443 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3444 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3445 info->count = bdrv_get_dirty_count(bm);
3446 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3447 info->has_name = !!bm->name;
3448 info->name = g_strdup(bm->name);
3449 info->status = bdrv_dirty_bitmap_status(bm);
3450 entry->value = info;
3451 *plist = entry;
3452 plist = &entry->next;
3455 return list;
3458 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3460 if (bitmap) {
3461 return hbitmap_get(bitmap->bitmap, sector);
3462 } else {
3463 return 0;
3468 * Chooses a default granularity based on the existing cluster size,
3469 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3470 * is no cluster size information available.
3472 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3474 BlockDriverInfo bdi;
3475 uint32_t granularity;
3477 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3478 granularity = MAX(4096, bdi.cluster_size);
3479 granularity = MIN(65536, granularity);
3480 } else {
3481 granularity = 65536;
3484 return granularity;
3487 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3489 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3492 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3494 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3497 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3498 int64_t cur_sector, int nr_sectors)
3500 assert(bdrv_dirty_bitmap_enabled(bitmap));
3501 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3504 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3505 int64_t cur_sector, int nr_sectors)
3507 assert(bdrv_dirty_bitmap_enabled(bitmap));
3508 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3511 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3513 assert(bdrv_dirty_bitmap_enabled(bitmap));
3514 hbitmap_reset(bitmap->bitmap, 0, bitmap->size);
3517 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3518 int nr_sectors)
3520 BdrvDirtyBitmap *bitmap;
3521 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3522 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3523 continue;
3525 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3529 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
3530 int nr_sectors)
3532 BdrvDirtyBitmap *bitmap;
3533 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3534 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3535 continue;
3537 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3542 * Advance an HBitmapIter to an arbitrary offset.
3544 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3546 assert(hbi->hb);
3547 hbitmap_iter_init(hbi, hbi->hb, offset);
3550 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3552 return hbitmap_count(bitmap->bitmap);
3555 /* Get a reference to bs */
3556 void bdrv_ref(BlockDriverState *bs)
3558 bs->refcnt++;
3561 /* Release a previously grabbed reference to bs.
3562 * If after releasing, reference count is zero, the BlockDriverState is
3563 * deleted. */
3564 void bdrv_unref(BlockDriverState *bs)
3566 if (!bs) {
3567 return;
3569 assert(bs->refcnt > 0);
3570 if (--bs->refcnt == 0) {
3571 bdrv_delete(bs);
3575 struct BdrvOpBlocker {
3576 Error *reason;
3577 QLIST_ENTRY(BdrvOpBlocker) list;
3580 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3582 BdrvOpBlocker *blocker;
3583 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3584 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3585 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3586 if (errp) {
3587 error_setg(errp, "Node '%s' is busy: %s",
3588 bdrv_get_device_or_node_name(bs),
3589 error_get_pretty(blocker->reason));
3591 return true;
3593 return false;
3596 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3598 BdrvOpBlocker *blocker;
3599 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3601 blocker = g_new0(BdrvOpBlocker, 1);
3602 blocker->reason = reason;
3603 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3606 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3608 BdrvOpBlocker *blocker, *next;
3609 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3610 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3611 if (blocker->reason == reason) {
3612 QLIST_REMOVE(blocker, list);
3613 g_free(blocker);
3618 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3620 int i;
3621 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3622 bdrv_op_block(bs, i, reason);
3626 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3628 int i;
3629 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3630 bdrv_op_unblock(bs, i, reason);
3634 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3636 int i;
3638 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3639 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3640 return false;
3643 return true;
3646 void bdrv_iostatus_enable(BlockDriverState *bs)
3648 bs->iostatus_enabled = true;
3649 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3652 /* The I/O status is only enabled if the drive explicitly
3653 * enables it _and_ the VM is configured to stop on errors */
3654 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3656 return (bs->iostatus_enabled &&
3657 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3658 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
3659 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3662 void bdrv_iostatus_disable(BlockDriverState *bs)
3664 bs->iostatus_enabled = false;
3667 void bdrv_iostatus_reset(BlockDriverState *bs)
3669 if (bdrv_iostatus_is_enabled(bs)) {
3670 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3671 if (bs->job) {
3672 block_job_iostatus_reset(bs->job);
3677 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3679 assert(bdrv_iostatus_is_enabled(bs));
3680 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3681 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3682 BLOCK_DEVICE_IO_STATUS_FAILED;
3686 void bdrv_img_create(const char *filename, const char *fmt,
3687 const char *base_filename, const char *base_fmt,
3688 char *options, uint64_t img_size, int flags,
3689 Error **errp, bool quiet)
3691 QemuOptsList *create_opts = NULL;
3692 QemuOpts *opts = NULL;
3693 const char *backing_fmt, *backing_file;
3694 int64_t size;
3695 BlockDriver *drv, *proto_drv;
3696 BlockDriver *backing_drv = NULL;
3697 Error *local_err = NULL;
3698 int ret = 0;
3700 /* Find driver and parse its options */
3701 drv = bdrv_find_format(fmt);
3702 if (!drv) {
3703 error_setg(errp, "Unknown file format '%s'", fmt);
3704 return;
3707 proto_drv = bdrv_find_protocol(filename, true, errp);
3708 if (!proto_drv) {
3709 return;
3712 if (!drv->create_opts) {
3713 error_setg(errp, "Format driver '%s' does not support image creation",
3714 drv->format_name);
3715 return;
3718 if (!proto_drv->create_opts) {
3719 error_setg(errp, "Protocol driver '%s' does not support image creation",
3720 proto_drv->format_name);
3721 return;
3724 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3725 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3727 /* Create parameter list with default values */
3728 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3729 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3731 /* Parse -o options */
3732 if (options) {
3733 qemu_opts_do_parse(opts, options, NULL, &local_err);
3734 if (local_err) {
3735 error_report_err(local_err);
3736 local_err = NULL;
3737 error_setg(errp, "Invalid options for file format '%s'", fmt);
3738 goto out;
3742 if (base_filename) {
3743 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3744 if (local_err) {
3745 error_setg(errp, "Backing file not supported for file format '%s'",
3746 fmt);
3747 goto out;
3751 if (base_fmt) {
3752 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3753 if (local_err) {
3754 error_setg(errp, "Backing file format not supported for file "
3755 "format '%s'", fmt);
3756 goto out;
3760 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3761 if (backing_file) {
3762 if (!strcmp(filename, backing_file)) {
3763 error_setg(errp, "Error: Trying to create an image with the "
3764 "same filename as the backing file");
3765 goto out;
3769 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3770 if (backing_fmt) {
3771 backing_drv = bdrv_find_format(backing_fmt);
3772 if (!backing_drv) {
3773 error_setg(errp, "Unknown backing file format '%s'",
3774 backing_fmt);
3775 goto out;
3779 // The size for the image must always be specified, with one exception:
3780 // If we are using a backing file, we can obtain the size from there
3781 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3782 if (size == -1) {
3783 if (backing_file) {
3784 BlockDriverState *bs;
3785 char *full_backing = g_new0(char, PATH_MAX);
3786 int64_t size;
3787 int back_flags;
3789 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3790 full_backing, PATH_MAX,
3791 &local_err);
3792 if (local_err) {
3793 g_free(full_backing);
3794 goto out;
3797 /* backing files always opened read-only */
3798 back_flags =
3799 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3801 bs = NULL;
3802 ret = bdrv_open(&bs, full_backing, NULL, NULL, back_flags,
3803 backing_drv, &local_err);
3804 g_free(full_backing);
3805 if (ret < 0) {
3806 goto out;
3808 size = bdrv_getlength(bs);
3809 if (size < 0) {
3810 error_setg_errno(errp, -size, "Could not get size of '%s'",
3811 backing_file);
3812 bdrv_unref(bs);
3813 goto out;
3816 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3818 bdrv_unref(bs);
3819 } else {
3820 error_setg(errp, "Image creation needs a size parameter");
3821 goto out;
3825 if (!quiet) {
3826 printf("Formatting '%s', fmt=%s", filename, fmt);
3827 qemu_opts_print(opts, " ");
3828 puts("");
3831 ret = bdrv_create(drv, filename, opts, &local_err);
3833 if (ret == -EFBIG) {
3834 /* This is generally a better message than whatever the driver would
3835 * deliver (especially because of the cluster_size_hint), since that
3836 * is most probably not much different from "image too large". */
3837 const char *cluster_size_hint = "";
3838 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3839 cluster_size_hint = " (try using a larger cluster size)";
3841 error_setg(errp, "The image size is too large for file format '%s'"
3842 "%s", fmt, cluster_size_hint);
3843 error_free(local_err);
3844 local_err = NULL;
3847 out:
3848 qemu_opts_del(opts);
3849 qemu_opts_free(create_opts);
3850 if (local_err) {
3851 error_propagate(errp, local_err);
3855 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3857 return bs->aio_context;
3860 void bdrv_detach_aio_context(BlockDriverState *bs)
3862 BdrvAioNotifier *baf;
3864 if (!bs->drv) {
3865 return;
3868 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3869 baf->detach_aio_context(baf->opaque);
3872 if (bs->io_limits_enabled) {
3873 throttle_timers_detach_aio_context(&bs->throttle_timers);
3875 if (bs->drv->bdrv_detach_aio_context) {
3876 bs->drv->bdrv_detach_aio_context(bs);
3878 if (bs->file) {
3879 bdrv_detach_aio_context(bs->file);
3881 if (bs->backing_hd) {
3882 bdrv_detach_aio_context(bs->backing_hd);
3885 bs->aio_context = NULL;
3888 void bdrv_attach_aio_context(BlockDriverState *bs,
3889 AioContext *new_context)
3891 BdrvAioNotifier *ban;
3893 if (!bs->drv) {
3894 return;
3897 bs->aio_context = new_context;
3899 if (bs->backing_hd) {
3900 bdrv_attach_aio_context(bs->backing_hd, new_context);
3902 if (bs->file) {
3903 bdrv_attach_aio_context(bs->file, new_context);
3905 if (bs->drv->bdrv_attach_aio_context) {
3906 bs->drv->bdrv_attach_aio_context(bs, new_context);
3908 if (bs->io_limits_enabled) {
3909 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3912 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3913 ban->attached_aio_context(new_context, ban->opaque);
3917 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3919 bdrv_drain_all(); /* ensure there are no in-flight requests */
3921 bdrv_detach_aio_context(bs);
3923 /* This function executes in the old AioContext so acquire the new one in
3924 * case it runs in a different thread.
3926 aio_context_acquire(new_context);
3927 bdrv_attach_aio_context(bs, new_context);
3928 aio_context_release(new_context);
3931 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3932 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3933 void (*detach_aio_context)(void *opaque), void *opaque)
3935 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3936 *ban = (BdrvAioNotifier){
3937 .attached_aio_context = attached_aio_context,
3938 .detach_aio_context = detach_aio_context,
3939 .opaque = opaque
3942 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3945 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3946 void (*attached_aio_context)(AioContext *,
3947 void *),
3948 void (*detach_aio_context)(void *),
3949 void *opaque)
3951 BdrvAioNotifier *ban, *ban_next;
3953 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3954 if (ban->attached_aio_context == attached_aio_context &&
3955 ban->detach_aio_context == detach_aio_context &&
3956 ban->opaque == opaque)
3958 QLIST_REMOVE(ban, list);
3959 g_free(ban);
3961 return;
3965 abort();
3968 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3969 BlockDriverAmendStatusCB *status_cb)
3971 if (!bs->drv->bdrv_amend_options) {
3972 return -ENOTSUP;
3974 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
3977 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3978 * of block filter and by bdrv_is_first_non_filter.
3979 * It is used to test if the given bs is the candidate or recurse more in the
3980 * node graph.
3982 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3983 BlockDriverState *candidate)
3985 /* return false if basic checks fails */
3986 if (!bs || !bs->drv) {
3987 return false;
3990 /* the code reached a non block filter driver -> check if the bs is
3991 * the same as the candidate. It's the recursion termination condition.
3993 if (!bs->drv->is_filter) {
3994 return bs == candidate;
3996 /* Down this path the driver is a block filter driver */
3998 /* If the block filter recursion method is defined use it to recurse down
3999 * the node graph.
4001 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4002 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4005 /* the driver is a block filter but don't allow to recurse -> return false
4007 return false;
4010 /* This function checks if the candidate is the first non filter bs down it's
4011 * bs chain. Since we don't have pointers to parents it explore all bs chains
4012 * from the top. Some filters can choose not to pass down the recursion.
4014 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4016 BlockDriverState *bs;
4018 /* walk down the bs forest recursively */
4019 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4020 bool perm;
4022 /* try to recurse in this top level bs */
4023 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4025 /* candidate is the first non filter */
4026 if (perm) {
4027 return true;
4031 return false;
4034 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
4036 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4037 AioContext *aio_context;
4039 if (!to_replace_bs) {
4040 error_setg(errp, "Node name '%s' not found", node_name);
4041 return NULL;
4044 aio_context = bdrv_get_aio_context(to_replace_bs);
4045 aio_context_acquire(aio_context);
4047 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4048 to_replace_bs = NULL;
4049 goto out;
4052 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4053 * most non filter in order to prevent data corruption.
4054 * Another benefit is that this tests exclude backing files which are
4055 * blocked by the backing blockers.
4057 if (!bdrv_is_first_non_filter(to_replace_bs)) {
4058 error_setg(errp, "Only top most non filter can be replaced");
4059 to_replace_bs = NULL;
4060 goto out;
4063 out:
4064 aio_context_release(aio_context);
4065 return to_replace_bs;
4068 static bool append_open_options(QDict *d, BlockDriverState *bs)
4070 const QDictEntry *entry;
4071 bool found_any = false;
4073 for (entry = qdict_first(bs->options); entry;
4074 entry = qdict_next(bs->options, entry))
4076 /* Only take options for this level and exclude all non-driver-specific
4077 * options */
4078 if (!strchr(qdict_entry_key(entry), '.') &&
4079 strcmp(qdict_entry_key(entry), "node-name"))
4081 qobject_incref(qdict_entry_value(entry));
4082 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4083 found_any = true;
4087 return found_any;
4090 /* Updates the following BDS fields:
4091 * - exact_filename: A filename which may be used for opening a block device
4092 * which (mostly) equals the given BDS (even without any
4093 * other options; so reading and writing must return the same
4094 * results, but caching etc. may be different)
4095 * - full_open_options: Options which, when given when opening a block device
4096 * (without a filename), result in a BDS (mostly)
4097 * equalling the given one
4098 * - filename: If exact_filename is set, it is copied here. Otherwise,
4099 * full_open_options is converted to a JSON object, prefixed with
4100 * "json:" (for use through the JSON pseudo protocol) and put here.
4102 void bdrv_refresh_filename(BlockDriverState *bs)
4104 BlockDriver *drv = bs->drv;
4105 QDict *opts;
4107 if (!drv) {
4108 return;
4111 /* This BDS's file name will most probably depend on its file's name, so
4112 * refresh that first */
4113 if (bs->file) {
4114 bdrv_refresh_filename(bs->file);
4117 if (drv->bdrv_refresh_filename) {
4118 /* Obsolete information is of no use here, so drop the old file name
4119 * information before refreshing it */
4120 bs->exact_filename[0] = '\0';
4121 if (bs->full_open_options) {
4122 QDECREF(bs->full_open_options);
4123 bs->full_open_options = NULL;
4126 drv->bdrv_refresh_filename(bs);
4127 } else if (bs->file) {
4128 /* Try to reconstruct valid information from the underlying file */
4129 bool has_open_options;
4131 bs->exact_filename[0] = '\0';
4132 if (bs->full_open_options) {
4133 QDECREF(bs->full_open_options);
4134 bs->full_open_options = NULL;
4137 opts = qdict_new();
4138 has_open_options = append_open_options(opts, bs);
4140 /* If no specific options have been given for this BDS, the filename of
4141 * the underlying file should suffice for this one as well */
4142 if (bs->file->exact_filename[0] && !has_open_options) {
4143 strcpy(bs->exact_filename, bs->file->exact_filename);
4145 /* Reconstructing the full options QDict is simple for most format block
4146 * drivers, as long as the full options are known for the underlying
4147 * file BDS. The full options QDict of that file BDS should somehow
4148 * contain a representation of the filename, therefore the following
4149 * suffices without querying the (exact_)filename of this BDS. */
4150 if (bs->file->full_open_options) {
4151 qdict_put_obj(opts, "driver",
4152 QOBJECT(qstring_from_str(drv->format_name)));
4153 QINCREF(bs->file->full_open_options);
4154 qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
4156 bs->full_open_options = opts;
4157 } else {
4158 QDECREF(opts);
4160 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4161 /* There is no underlying file BDS (at least referenced by BDS.file),
4162 * so the full options QDict should be equal to the options given
4163 * specifically for this block device when it was opened (plus the
4164 * driver specification).
4165 * Because those options don't change, there is no need to update
4166 * full_open_options when it's already set. */
4168 opts = qdict_new();
4169 append_open_options(opts, bs);
4170 qdict_put_obj(opts, "driver",
4171 QOBJECT(qstring_from_str(drv->format_name)));
4173 if (bs->exact_filename[0]) {
4174 /* This may not work for all block protocol drivers (some may
4175 * require this filename to be parsed), but we have to find some
4176 * default solution here, so just include it. If some block driver
4177 * does not support pure options without any filename at all or
4178 * needs some special format of the options QDict, it needs to
4179 * implement the driver-specific bdrv_refresh_filename() function.
4181 qdict_put_obj(opts, "filename",
4182 QOBJECT(qstring_from_str(bs->exact_filename)));
4185 bs->full_open_options = opts;
4188 if (bs->exact_filename[0]) {
4189 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4190 } else if (bs->full_open_options) {
4191 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4192 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4193 qstring_get_str(json));
4194 QDECREF(json);
4198 /* This accessor function purpose is to allow the device models to access the
4199 * BlockAcctStats structure embedded inside a BlockDriverState without being
4200 * aware of the BlockDriverState structure layout.
4201 * It will go away when the BlockAcctStats structure will be moved inside
4202 * the device models.
4204 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4206 return &bs->stats;