Update version for v2.4.0-rc3 release
[qemu/ar7.git] / block.c
blobd088ee02fff31f2456c94ad891a8688daae6b35d
1 /*
2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qjson.h"
33 #include "sysemu/block-backend.h"
34 #include "sysemu/sysemu.h"
35 #include "qemu/notify.h"
36 #include "block/coroutine.h"
37 #include "block/qapi.h"
38 #include "qmp-commands.h"
39 #include "qemu/timer.h"
40 #include "qapi-event.h"
41 #include "block/throttle-groups.h"
43 #ifdef CONFIG_BSD
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #include <sys/ioctl.h>
47 #include <sys/queue.h>
48 #ifndef __DragonFly__
49 #include <sys/disk.h>
50 #endif
51 #endif
53 #ifdef _WIN32
54 #include <windows.h>
55 #endif
57 /**
58 * A BdrvDirtyBitmap can be in three possible states:
59 * (1) successor is NULL and disabled is false: full r/w mode
60 * (2) successor is NULL and disabled is true: read only mode ("disabled")
61 * (3) successor is set: frozen mode.
62 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
63 * or enabled. A frozen bitmap can only abdicate() or reclaim().
65 struct BdrvDirtyBitmap {
66 HBitmap *bitmap; /* Dirty sector bitmap implementation */
67 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
68 char *name; /* Optional non-empty unique ID */
69 int64_t size; /* Size of the bitmap (Number of sectors) */
70 bool disabled; /* Bitmap is read-only */
71 QLIST_ENTRY(BdrvDirtyBitmap) list;
74 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
76 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
77 QTAILQ_HEAD_INITIALIZER(bdrv_states);
79 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
82 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
83 QLIST_HEAD_INITIALIZER(bdrv_drivers);
85 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
86 const char *reference, QDict *options, int flags,
87 BlockDriverState *parent,
88 const BdrvChildRole *child_role,
89 BlockDriver *drv, Error **errp);
91 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
92 /* If non-zero, use only whitelisted block drivers */
93 static int use_bdrv_whitelist;
95 #ifdef _WIN32
96 static int is_windows_drive_prefix(const char *filename)
98 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
99 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
100 filename[1] == ':');
103 int is_windows_drive(const char *filename)
105 if (is_windows_drive_prefix(filename) &&
106 filename[2] == '\0')
107 return 1;
108 if (strstart(filename, "\\\\.\\", NULL) ||
109 strstart(filename, "//./", NULL))
110 return 1;
111 return 0;
113 #endif
115 size_t bdrv_opt_mem_align(BlockDriverState *bs)
117 if (!bs || !bs->drv) {
118 /* page size or 4k (hdd sector size) should be on the safe side */
119 return MAX(4096, getpagesize());
122 return bs->bl.opt_mem_alignment;
125 size_t bdrv_min_mem_align(BlockDriverState *bs)
127 if (!bs || !bs->drv) {
128 /* page size or 4k (hdd sector size) should be on the safe side */
129 return MAX(4096, getpagesize());
132 return bs->bl.min_mem_alignment;
135 /* check if the path starts with "<protocol>:" */
136 int path_has_protocol(const char *path)
138 const char *p;
140 #ifdef _WIN32
141 if (is_windows_drive(path) ||
142 is_windows_drive_prefix(path)) {
143 return 0;
145 p = path + strcspn(path, ":/\\");
146 #else
147 p = path + strcspn(path, ":/");
148 #endif
150 return *p == ':';
153 int path_is_absolute(const char *path)
155 #ifdef _WIN32
156 /* specific case for names like: "\\.\d:" */
157 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
158 return 1;
160 return (*path == '/' || *path == '\\');
161 #else
162 return (*path == '/');
163 #endif
166 /* if filename is absolute, just copy it to dest. Otherwise, build a
167 path to it by considering it is relative to base_path. URL are
168 supported. */
169 void path_combine(char *dest, int dest_size,
170 const char *base_path,
171 const char *filename)
173 const char *p, *p1;
174 int len;
176 if (dest_size <= 0)
177 return;
178 if (path_is_absolute(filename)) {
179 pstrcpy(dest, dest_size, filename);
180 } else {
181 p = strchr(base_path, ':');
182 if (p)
183 p++;
184 else
185 p = base_path;
186 p1 = strrchr(base_path, '/');
187 #ifdef _WIN32
189 const char *p2;
190 p2 = strrchr(base_path, '\\');
191 if (!p1 || p2 > p1)
192 p1 = p2;
194 #endif
195 if (p1)
196 p1++;
197 else
198 p1 = base_path;
199 if (p1 > p)
200 p = p1;
201 len = p - base_path;
202 if (len > dest_size - 1)
203 len = dest_size - 1;
204 memcpy(dest, base_path, len);
205 dest[len] = '\0';
206 pstrcat(dest, dest_size, filename);
210 void bdrv_get_full_backing_filename_from_filename(const char *backed,
211 const char *backing,
212 char *dest, size_t sz,
213 Error **errp)
215 if (backing[0] == '\0' || path_has_protocol(backing) ||
216 path_is_absolute(backing))
218 pstrcpy(dest, sz, backing);
219 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
220 error_setg(errp, "Cannot use relative backing file names for '%s'",
221 backed);
222 } else {
223 path_combine(dest, sz, backed, backing);
227 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
228 Error **errp)
230 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
232 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
233 dest, sz, errp);
236 void bdrv_register(BlockDriver *bdrv)
238 bdrv_setup_io_funcs(bdrv);
240 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
243 BlockDriverState *bdrv_new_root(void)
245 BlockDriverState *bs = bdrv_new();
247 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
248 return bs;
251 BlockDriverState *bdrv_new(void)
253 BlockDriverState *bs;
254 int i;
256 bs = g_new0(BlockDriverState, 1);
257 QLIST_INIT(&bs->dirty_bitmaps);
258 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
259 QLIST_INIT(&bs->op_blockers[i]);
261 bdrv_iostatus_disable(bs);
262 notifier_list_init(&bs->close_notifiers);
263 notifier_with_return_list_init(&bs->before_write_notifiers);
264 qemu_co_queue_init(&bs->throttled_reqs[0]);
265 qemu_co_queue_init(&bs->throttled_reqs[1]);
266 bs->refcnt = 1;
267 bs->aio_context = qemu_get_aio_context();
269 return bs;
272 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
274 notifier_list_add(&bs->close_notifiers, notify);
277 BlockDriver *bdrv_find_format(const char *format_name)
279 BlockDriver *drv1;
280 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
281 if (!strcmp(drv1->format_name, format_name)) {
282 return drv1;
285 return NULL;
288 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
290 static const char *whitelist_rw[] = {
291 CONFIG_BDRV_RW_WHITELIST
293 static const char *whitelist_ro[] = {
294 CONFIG_BDRV_RO_WHITELIST
296 const char **p;
298 if (!whitelist_rw[0] && !whitelist_ro[0]) {
299 return 1; /* no whitelist, anything goes */
302 for (p = whitelist_rw; *p; p++) {
303 if (!strcmp(drv->format_name, *p)) {
304 return 1;
307 if (read_only) {
308 for (p = whitelist_ro; *p; p++) {
309 if (!strcmp(drv->format_name, *p)) {
310 return 1;
314 return 0;
317 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
318 bool read_only)
320 BlockDriver *drv = bdrv_find_format(format_name);
321 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
324 typedef struct CreateCo {
325 BlockDriver *drv;
326 char *filename;
327 QemuOpts *opts;
328 int ret;
329 Error *err;
330 } CreateCo;
332 static void coroutine_fn bdrv_create_co_entry(void *opaque)
334 Error *local_err = NULL;
335 int ret;
337 CreateCo *cco = opaque;
338 assert(cco->drv);
340 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
341 if (local_err) {
342 error_propagate(&cco->err, local_err);
344 cco->ret = ret;
347 int bdrv_create(BlockDriver *drv, const char* filename,
348 QemuOpts *opts, Error **errp)
350 int ret;
352 Coroutine *co;
353 CreateCo cco = {
354 .drv = drv,
355 .filename = g_strdup(filename),
356 .opts = opts,
357 .ret = NOT_DONE,
358 .err = NULL,
361 if (!drv->bdrv_create) {
362 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
363 ret = -ENOTSUP;
364 goto out;
367 if (qemu_in_coroutine()) {
368 /* Fast-path if already in coroutine context */
369 bdrv_create_co_entry(&cco);
370 } else {
371 co = qemu_coroutine_create(bdrv_create_co_entry);
372 qemu_coroutine_enter(co, &cco);
373 while (cco.ret == NOT_DONE) {
374 aio_poll(qemu_get_aio_context(), true);
378 ret = cco.ret;
379 if (ret < 0) {
380 if (cco.err) {
381 error_propagate(errp, cco.err);
382 } else {
383 error_setg_errno(errp, -ret, "Could not create image");
387 out:
388 g_free(cco.filename);
389 return ret;
392 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
394 BlockDriver *drv;
395 Error *local_err = NULL;
396 int ret;
398 drv = bdrv_find_protocol(filename, true, errp);
399 if (drv == NULL) {
400 return -ENOENT;
403 ret = bdrv_create(drv, filename, opts, &local_err);
404 if (local_err) {
405 error_propagate(errp, local_err);
407 return ret;
411 * Try to get @bs's logical and physical block size.
412 * On success, store them in @bsz struct and return 0.
413 * On failure return -errno.
414 * @bs must not be empty.
416 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
418 BlockDriver *drv = bs->drv;
420 if (drv && drv->bdrv_probe_blocksizes) {
421 return drv->bdrv_probe_blocksizes(bs, bsz);
424 return -ENOTSUP;
428 * Try to get @bs's geometry (cyls, heads, sectors).
429 * On success, store them in @geo struct and return 0.
430 * On failure return -errno.
431 * @bs must not be empty.
433 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
435 BlockDriver *drv = bs->drv;
437 if (drv && drv->bdrv_probe_geometry) {
438 return drv->bdrv_probe_geometry(bs, geo);
441 return -ENOTSUP;
445 * Create a uniquely-named empty temporary file.
446 * Return 0 upon success, otherwise a negative errno value.
448 int get_tmp_filename(char *filename, int size)
450 #ifdef _WIN32
451 char temp_dir[MAX_PATH];
452 /* GetTempFileName requires that its output buffer (4th param)
453 have length MAX_PATH or greater. */
454 assert(size >= MAX_PATH);
455 return (GetTempPath(MAX_PATH, temp_dir)
456 && GetTempFileName(temp_dir, "qem", 0, filename)
457 ? 0 : -GetLastError());
458 #else
459 int fd;
460 const char *tmpdir;
461 tmpdir = getenv("TMPDIR");
462 if (!tmpdir) {
463 tmpdir = "/var/tmp";
465 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
466 return -EOVERFLOW;
468 fd = mkstemp(filename);
469 if (fd < 0) {
470 return -errno;
472 if (close(fd) != 0) {
473 unlink(filename);
474 return -errno;
476 return 0;
477 #endif
481 * Detect host devices. By convention, /dev/cdrom[N] is always
482 * recognized as a host CDROM.
484 static BlockDriver *find_hdev_driver(const char *filename)
486 int score_max = 0, score;
487 BlockDriver *drv = NULL, *d;
489 QLIST_FOREACH(d, &bdrv_drivers, list) {
490 if (d->bdrv_probe_device) {
491 score = d->bdrv_probe_device(filename);
492 if (score > score_max) {
493 score_max = score;
494 drv = d;
499 return drv;
502 BlockDriver *bdrv_find_protocol(const char *filename,
503 bool allow_protocol_prefix,
504 Error **errp)
506 BlockDriver *drv1;
507 char protocol[128];
508 int len;
509 const char *p;
511 /* TODO Drivers without bdrv_file_open must be specified explicitly */
514 * XXX(hch): we really should not let host device detection
515 * override an explicit protocol specification, but moving this
516 * later breaks access to device names with colons in them.
517 * Thanks to the brain-dead persistent naming schemes on udev-
518 * based Linux systems those actually are quite common.
520 drv1 = find_hdev_driver(filename);
521 if (drv1) {
522 return drv1;
525 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
526 return &bdrv_file;
529 p = strchr(filename, ':');
530 assert(p != NULL);
531 len = p - filename;
532 if (len > sizeof(protocol) - 1)
533 len = sizeof(protocol) - 1;
534 memcpy(protocol, filename, len);
535 protocol[len] = '\0';
536 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
537 if (drv1->protocol_name &&
538 !strcmp(drv1->protocol_name, protocol)) {
539 return drv1;
543 error_setg(errp, "Unknown protocol '%s'", protocol);
544 return NULL;
548 * Guess image format by probing its contents.
549 * This is not a good idea when your image is raw (CVE-2008-2004), but
550 * we do it anyway for backward compatibility.
552 * @buf contains the image's first @buf_size bytes.
553 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
554 * but can be smaller if the image file is smaller)
555 * @filename is its filename.
557 * For all block drivers, call the bdrv_probe() method to get its
558 * probing score.
559 * Return the first block driver with the highest probing score.
561 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
562 const char *filename)
564 int score_max = 0, score;
565 BlockDriver *drv = NULL, *d;
567 QLIST_FOREACH(d, &bdrv_drivers, list) {
568 if (d->bdrv_probe) {
569 score = d->bdrv_probe(buf, buf_size, filename);
570 if (score > score_max) {
571 score_max = score;
572 drv = d;
577 return drv;
580 static int find_image_format(BlockDriverState *bs, const char *filename,
581 BlockDriver **pdrv, Error **errp)
583 BlockDriver *drv;
584 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
585 int ret = 0;
587 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
588 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
589 *pdrv = &bdrv_raw;
590 return ret;
593 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
594 if (ret < 0) {
595 error_setg_errno(errp, -ret, "Could not read image for determining its "
596 "format");
597 *pdrv = NULL;
598 return ret;
601 drv = bdrv_probe_all(buf, ret, filename);
602 if (!drv) {
603 error_setg(errp, "Could not determine image format: No compatible "
604 "driver found");
605 ret = -ENOENT;
607 *pdrv = drv;
608 return ret;
612 * Set the current 'total_sectors' value
613 * Return 0 on success, -errno on error.
615 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
617 BlockDriver *drv = bs->drv;
619 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
620 if (bdrv_is_sg(bs))
621 return 0;
623 /* query actual device if possible, otherwise just trust the hint */
624 if (drv->bdrv_getlength) {
625 int64_t length = drv->bdrv_getlength(bs);
626 if (length < 0) {
627 return length;
629 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
632 bs->total_sectors = hint;
633 return 0;
637 * Set open flags for a given discard mode
639 * Return 0 on success, -1 if the discard mode was invalid.
641 int bdrv_parse_discard_flags(const char *mode, int *flags)
643 *flags &= ~BDRV_O_UNMAP;
645 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
646 /* do nothing */
647 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
648 *flags |= BDRV_O_UNMAP;
649 } else {
650 return -1;
653 return 0;
657 * Set open flags for a given cache mode
659 * Return 0 on success, -1 if the cache mode was invalid.
661 int bdrv_parse_cache_flags(const char *mode, int *flags)
663 *flags &= ~BDRV_O_CACHE_MASK;
665 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
666 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
667 } else if (!strcmp(mode, "directsync")) {
668 *flags |= BDRV_O_NOCACHE;
669 } else if (!strcmp(mode, "writeback")) {
670 *flags |= BDRV_O_CACHE_WB;
671 } else if (!strcmp(mode, "unsafe")) {
672 *flags |= BDRV_O_CACHE_WB;
673 *flags |= BDRV_O_NO_FLUSH;
674 } else if (!strcmp(mode, "writethrough")) {
675 /* this is the default */
676 } else {
677 return -1;
680 return 0;
684 * Returns the flags that a temporary snapshot should get, based on the
685 * originally requested flags (the originally requested image will have flags
686 * like a backing file)
688 static int bdrv_temp_snapshot_flags(int flags)
690 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
694 * Returns the flags that bs->file should get if a protocol driver is expected,
695 * based on the given flags for the parent BDS
697 static int bdrv_inherited_flags(int flags)
699 /* Enable protocol handling, disable format probing for bs->file */
700 flags |= BDRV_O_PROTOCOL;
702 /* Our block drivers take care to send flushes and respect unmap policy,
703 * so we can enable both unconditionally on lower layers. */
704 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
706 /* Clear flags that only apply to the top layer */
707 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
709 return flags;
712 const BdrvChildRole child_file = {
713 .inherit_flags = bdrv_inherited_flags,
717 * Returns the flags that bs->file should get if the use of formats (and not
718 * only protocols) is permitted for it, based on the given flags for the parent
719 * BDS
721 static int bdrv_inherited_fmt_flags(int parent_flags)
723 int flags = child_file.inherit_flags(parent_flags);
724 return flags & ~BDRV_O_PROTOCOL;
727 const BdrvChildRole child_format = {
728 .inherit_flags = bdrv_inherited_fmt_flags,
732 * Returns the flags that bs->backing_hd should get, based on the given flags
733 * for the parent BDS
735 static int bdrv_backing_flags(int flags)
737 /* backing files always opened read-only */
738 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
740 /* snapshot=on is handled on the top layer */
741 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
743 return flags;
746 static const BdrvChildRole child_backing = {
747 .inherit_flags = bdrv_backing_flags,
750 static int bdrv_open_flags(BlockDriverState *bs, int flags)
752 int open_flags = flags | BDRV_O_CACHE_WB;
755 * Clear flags that are internal to the block layer before opening the
756 * image.
758 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
761 * Snapshots should be writable.
763 if (flags & BDRV_O_TEMPORARY) {
764 open_flags |= BDRV_O_RDWR;
767 return open_flags;
770 static void bdrv_assign_node_name(BlockDriverState *bs,
771 const char *node_name,
772 Error **errp)
774 if (!node_name) {
775 return;
778 /* Check for empty string or invalid characters */
779 if (!id_wellformed(node_name)) {
780 error_setg(errp, "Invalid node name");
781 return;
784 /* takes care of avoiding namespaces collisions */
785 if (blk_by_name(node_name)) {
786 error_setg(errp, "node-name=%s is conflicting with a device id",
787 node_name);
788 return;
791 /* takes care of avoiding duplicates node names */
792 if (bdrv_find_node(node_name)) {
793 error_setg(errp, "Duplicate node name");
794 return;
797 /* copy node name into the bs and insert it into the graph list */
798 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
799 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
802 static QemuOptsList bdrv_runtime_opts = {
803 .name = "bdrv_common",
804 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
805 .desc = {
807 .name = "node-name",
808 .type = QEMU_OPT_STRING,
809 .help = "Node name of the block device node",
811 { /* end of list */ }
816 * Common part for opening disk images and files
818 * Removes all processed options from *options.
820 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
821 QDict *options, int flags, BlockDriver *drv, Error **errp)
823 int ret, open_flags;
824 const char *filename;
825 const char *node_name = NULL;
826 QemuOpts *opts;
827 Error *local_err = NULL;
829 assert(drv != NULL);
830 assert(bs->file == NULL);
831 assert(options != NULL && bs->options != options);
833 if (file != NULL) {
834 filename = file->filename;
835 } else {
836 filename = qdict_get_try_str(options, "filename");
839 if (drv->bdrv_needs_filename && !filename) {
840 error_setg(errp, "The '%s' block driver requires a file name",
841 drv->format_name);
842 return -EINVAL;
845 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
847 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
848 qemu_opts_absorb_qdict(opts, options, &local_err);
849 if (local_err) {
850 error_propagate(errp, local_err);
851 ret = -EINVAL;
852 goto fail_opts;
855 node_name = qemu_opt_get(opts, "node-name");
856 bdrv_assign_node_name(bs, node_name, &local_err);
857 if (local_err) {
858 error_propagate(errp, local_err);
859 ret = -EINVAL;
860 goto fail_opts;
863 bs->guest_block_size = 512;
864 bs->request_alignment = 512;
865 bs->zero_beyond_eof = true;
866 open_flags = bdrv_open_flags(bs, flags);
867 bs->read_only = !(open_flags & BDRV_O_RDWR);
869 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
870 error_setg(errp,
871 !bs->read_only && bdrv_is_whitelisted(drv, true)
872 ? "Driver '%s' can only be used for read-only devices"
873 : "Driver '%s' is not whitelisted",
874 drv->format_name);
875 ret = -ENOTSUP;
876 goto fail_opts;
879 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
880 if (flags & BDRV_O_COPY_ON_READ) {
881 if (!bs->read_only) {
882 bdrv_enable_copy_on_read(bs);
883 } else {
884 error_setg(errp, "Can't use copy-on-read on read-only device");
885 ret = -EINVAL;
886 goto fail_opts;
890 if (filename != NULL) {
891 pstrcpy(bs->filename, sizeof(bs->filename), filename);
892 } else {
893 bs->filename[0] = '\0';
895 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
897 bs->drv = drv;
898 bs->opaque = g_malloc0(drv->instance_size);
900 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
902 /* Open the image, either directly or using a protocol */
903 if (drv->bdrv_file_open) {
904 assert(file == NULL);
905 assert(!drv->bdrv_needs_filename || filename != NULL);
906 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
907 } else {
908 if (file == NULL) {
909 error_setg(errp, "Can't use '%s' as a block driver for the "
910 "protocol level", drv->format_name);
911 ret = -EINVAL;
912 goto free_and_fail;
914 bs->file = file;
915 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
918 if (ret < 0) {
919 if (local_err) {
920 error_propagate(errp, local_err);
921 } else if (bs->filename[0]) {
922 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
923 } else {
924 error_setg_errno(errp, -ret, "Could not open image");
926 goto free_and_fail;
929 if (bs->encrypted) {
930 error_report("Encrypted images are deprecated");
931 error_printf("Support for them will be removed in a future release.\n"
932 "You can use 'qemu-img convert' to convert your image"
933 " to an unencrypted one.\n");
936 ret = refresh_total_sectors(bs, bs->total_sectors);
937 if (ret < 0) {
938 error_setg_errno(errp, -ret, "Could not refresh total sector count");
939 goto free_and_fail;
942 bdrv_refresh_limits(bs, &local_err);
943 if (local_err) {
944 error_propagate(errp, local_err);
945 ret = -EINVAL;
946 goto free_and_fail;
949 assert(bdrv_opt_mem_align(bs) != 0);
950 assert(bdrv_min_mem_align(bs) != 0);
951 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
953 qemu_opts_del(opts);
954 return 0;
956 free_and_fail:
957 bs->file = NULL;
958 g_free(bs->opaque);
959 bs->opaque = NULL;
960 bs->drv = NULL;
961 fail_opts:
962 qemu_opts_del(opts);
963 return ret;
966 static QDict *parse_json_filename(const char *filename, Error **errp)
968 QObject *options_obj;
969 QDict *options;
970 int ret;
972 ret = strstart(filename, "json:", &filename);
973 assert(ret);
975 options_obj = qobject_from_json(filename);
976 if (!options_obj) {
977 error_setg(errp, "Could not parse the JSON options");
978 return NULL;
981 if (qobject_type(options_obj) != QTYPE_QDICT) {
982 qobject_decref(options_obj);
983 error_setg(errp, "Invalid JSON object given");
984 return NULL;
987 options = qobject_to_qdict(options_obj);
988 qdict_flatten(options);
990 return options;
994 * Fills in default options for opening images and converts the legacy
995 * filename/flags pair to option QDict entries.
996 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
997 * block driver has been specified explicitly.
999 static int bdrv_fill_options(QDict **options, const char **pfilename,
1000 int *flags, BlockDriver *drv, Error **errp)
1002 const char *filename = *pfilename;
1003 const char *drvname;
1004 bool protocol = *flags & BDRV_O_PROTOCOL;
1005 bool parse_filename = false;
1006 BlockDriver *tmp_drv;
1007 Error *local_err = NULL;
1009 /* Parse json: pseudo-protocol */
1010 if (filename && g_str_has_prefix(filename, "json:")) {
1011 QDict *json_options = parse_json_filename(filename, &local_err);
1012 if (local_err) {
1013 error_propagate(errp, local_err);
1014 return -EINVAL;
1017 /* Options given in the filename have lower priority than options
1018 * specified directly */
1019 qdict_join(*options, json_options, false);
1020 QDECREF(json_options);
1021 *pfilename = filename = NULL;
1024 drvname = qdict_get_try_str(*options, "driver");
1026 /* If the user has explicitly specified the driver, this choice should
1027 * override the BDRV_O_PROTOCOL flag */
1028 tmp_drv = drv;
1029 if (!tmp_drv && drvname) {
1030 tmp_drv = bdrv_find_format(drvname);
1032 if (tmp_drv) {
1033 protocol = tmp_drv->bdrv_file_open;
1036 if (protocol) {
1037 *flags |= BDRV_O_PROTOCOL;
1038 } else {
1039 *flags &= ~BDRV_O_PROTOCOL;
1042 /* Fetch the file name from the options QDict if necessary */
1043 if (protocol && filename) {
1044 if (!qdict_haskey(*options, "filename")) {
1045 qdict_put(*options, "filename", qstring_from_str(filename));
1046 parse_filename = true;
1047 } else {
1048 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1049 "the same time");
1050 return -EINVAL;
1054 /* Find the right block driver */
1055 filename = qdict_get_try_str(*options, "filename");
1057 if (drv) {
1058 if (drvname) {
1059 error_setg(errp, "Driver specified twice");
1060 return -EINVAL;
1062 drvname = drv->format_name;
1063 qdict_put(*options, "driver", qstring_from_str(drvname));
1064 } else {
1065 if (!drvname && protocol) {
1066 if (filename) {
1067 drv = bdrv_find_protocol(filename, parse_filename, errp);
1068 if (!drv) {
1069 return -EINVAL;
1072 drvname = drv->format_name;
1073 qdict_put(*options, "driver", qstring_from_str(drvname));
1074 } else {
1075 error_setg(errp, "Must specify either driver or file");
1076 return -EINVAL;
1078 } else if (drvname) {
1079 drv = bdrv_find_format(drvname);
1080 if (!drv) {
1081 error_setg(errp, "Unknown driver '%s'", drvname);
1082 return -ENOENT;
1087 assert(drv || !protocol);
1089 /* Driver-specific filename parsing */
1090 if (drv && drv->bdrv_parse_filename && parse_filename) {
1091 drv->bdrv_parse_filename(filename, *options, &local_err);
1092 if (local_err) {
1093 error_propagate(errp, local_err);
1094 return -EINVAL;
1097 if (!drv->bdrv_needs_filename) {
1098 qdict_del(*options, "filename");
1102 return 0;
1105 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1106 BlockDriverState *child_bs,
1107 const BdrvChildRole *child_role)
1109 BdrvChild *child = g_new(BdrvChild, 1);
1110 *child = (BdrvChild) {
1111 .bs = child_bs,
1112 .role = child_role,
1115 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1117 return child;
1120 static void bdrv_detach_child(BdrvChild *child)
1122 QLIST_REMOVE(child, next);
1123 g_free(child);
1126 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1128 BlockDriverState *child_bs = child->bs;
1130 if (child->bs->inherits_from == parent) {
1131 child->bs->inherits_from = NULL;
1134 bdrv_detach_child(child);
1135 bdrv_unref(child_bs);
1138 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1141 if (bs->backing_hd) {
1142 assert(bs->backing_blocker);
1143 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1144 bdrv_detach_child(bs->backing_child);
1145 } else if (backing_hd) {
1146 error_setg(&bs->backing_blocker,
1147 "node is used as backing hd of '%s'",
1148 bdrv_get_device_or_node_name(bs));
1151 bs->backing_hd = backing_hd;
1152 if (!backing_hd) {
1153 error_free(bs->backing_blocker);
1154 bs->backing_blocker = NULL;
1155 bs->backing_child = NULL;
1156 goto out;
1158 bs->backing_child = bdrv_attach_child(bs, backing_hd, &child_backing);
1159 bs->open_flags &= ~BDRV_O_NO_BACKING;
1160 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1161 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1162 backing_hd->drv ? backing_hd->drv->format_name : "");
1164 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1165 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1166 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1167 bs->backing_blocker);
1168 out:
1169 bdrv_refresh_limits(bs, NULL);
1173 * Opens the backing file for a BlockDriverState if not yet open
1175 * options is a QDict of options to pass to the block drivers, or NULL for an
1176 * empty set of options. The reference to the QDict is transferred to this
1177 * function (even on failure), so if the caller intends to reuse the dictionary,
1178 * it needs to use QINCREF() before calling bdrv_file_open.
1180 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1182 char *backing_filename = g_malloc0(PATH_MAX);
1183 int ret = 0;
1184 BlockDriverState *backing_hd;
1185 Error *local_err = NULL;
1187 if (bs->backing_hd != NULL) {
1188 QDECREF(options);
1189 goto free_exit;
1192 /* NULL means an empty set of options */
1193 if (options == NULL) {
1194 options = qdict_new();
1197 bs->open_flags &= ~BDRV_O_NO_BACKING;
1198 if (qdict_haskey(options, "file.filename")) {
1199 backing_filename[0] = '\0';
1200 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1201 QDECREF(options);
1202 goto free_exit;
1203 } else {
1204 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1205 &local_err);
1206 if (local_err) {
1207 ret = -EINVAL;
1208 error_propagate(errp, local_err);
1209 QDECREF(options);
1210 goto free_exit;
1214 if (!bs->drv || !bs->drv->supports_backing) {
1215 ret = -EINVAL;
1216 error_setg(errp, "Driver doesn't support backing files");
1217 QDECREF(options);
1218 goto free_exit;
1221 backing_hd = bdrv_new();
1223 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1224 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1227 assert(bs->backing_hd == NULL);
1228 ret = bdrv_open_inherit(&backing_hd,
1229 *backing_filename ? backing_filename : NULL,
1230 NULL, options, 0, bs, &child_backing,
1231 NULL, &local_err);
1232 if (ret < 0) {
1233 bdrv_unref(backing_hd);
1234 backing_hd = NULL;
1235 bs->open_flags |= BDRV_O_NO_BACKING;
1236 error_setg(errp, "Could not open backing file: %s",
1237 error_get_pretty(local_err));
1238 error_free(local_err);
1239 goto free_exit;
1242 bdrv_set_backing_hd(bs, backing_hd);
1244 free_exit:
1245 g_free(backing_filename);
1246 return ret;
1250 * Opens a disk image whose options are given as BlockdevRef in another block
1251 * device's options.
1253 * If allow_none is true, no image will be opened if filename is false and no
1254 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1256 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1257 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1258 * itself, all options starting with "${bdref_key}." are considered part of the
1259 * BlockdevRef.
1261 * The BlockdevRef will be removed from the options QDict.
1263 BdrvChild *bdrv_open_child(const char *filename,
1264 QDict *options, const char *bdref_key,
1265 BlockDriverState* parent,
1266 const BdrvChildRole *child_role,
1267 bool allow_none, Error **errp)
1269 BdrvChild *c = NULL;
1270 BlockDriverState *bs;
1271 QDict *image_options;
1272 int ret;
1273 char *bdref_key_dot;
1274 const char *reference;
1276 assert(child_role != NULL);
1278 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1279 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1280 g_free(bdref_key_dot);
1282 reference = qdict_get_try_str(options, bdref_key);
1283 if (!filename && !reference && !qdict_size(image_options)) {
1284 if (!allow_none) {
1285 error_setg(errp, "A block device must be specified for \"%s\"",
1286 bdref_key);
1288 QDECREF(image_options);
1289 goto done;
1292 bs = NULL;
1293 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1294 parent, child_role, NULL, errp);
1295 if (ret < 0) {
1296 goto done;
1299 c = bdrv_attach_child(parent, bs, child_role);
1301 done:
1302 qdict_del(options, bdref_key);
1303 return c;
1307 * This is a version of bdrv_open_child() that returns 0/-EINVAL instead of
1308 * a BdrvChild object.
1310 * If allow_none is true, no image will be opened if filename is false and no
1311 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1313 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1315 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1316 QDict *options, const char *bdref_key,
1317 BlockDriverState* parent, const BdrvChildRole *child_role,
1318 bool allow_none, Error **errp)
1320 Error *local_err = NULL;
1321 BdrvChild *c;
1323 assert(pbs);
1324 assert(*pbs == NULL);
1326 c = bdrv_open_child(filename, options, bdref_key, parent, child_role,
1327 allow_none, &local_err);
1328 if (local_err) {
1329 error_propagate(errp, local_err);
1330 return -EINVAL;
1333 if (c != NULL) {
1334 *pbs = c->bs;
1337 return 0;
1340 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1342 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1343 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1344 int64_t total_size;
1345 QemuOpts *opts = NULL;
1346 QDict *snapshot_options;
1347 BlockDriverState *bs_snapshot;
1348 Error *local_err = NULL;
1349 int ret;
1351 /* if snapshot, we create a temporary backing file and open it
1352 instead of opening 'filename' directly */
1354 /* Get the required size from the image */
1355 total_size = bdrv_getlength(bs);
1356 if (total_size < 0) {
1357 ret = total_size;
1358 error_setg_errno(errp, -total_size, "Could not get image size");
1359 goto out;
1362 /* Create the temporary image */
1363 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1364 if (ret < 0) {
1365 error_setg_errno(errp, -ret, "Could not get temporary filename");
1366 goto out;
1369 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1370 &error_abort);
1371 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1372 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, &local_err);
1373 qemu_opts_del(opts);
1374 if (ret < 0) {
1375 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1376 "'%s': %s", tmp_filename,
1377 error_get_pretty(local_err));
1378 error_free(local_err);
1379 goto out;
1382 /* Prepare a new options QDict for the temporary file */
1383 snapshot_options = qdict_new();
1384 qdict_put(snapshot_options, "file.driver",
1385 qstring_from_str("file"));
1386 qdict_put(snapshot_options, "file.filename",
1387 qstring_from_str(tmp_filename));
1389 bs_snapshot = bdrv_new();
1391 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1392 flags, &bdrv_qcow2, &local_err);
1393 if (ret < 0) {
1394 error_propagate(errp, local_err);
1395 goto out;
1398 bdrv_append(bs_snapshot, bs);
1400 out:
1401 g_free(tmp_filename);
1402 return ret;
1406 * Opens a disk image (raw, qcow2, vmdk, ...)
1408 * options is a QDict of options to pass to the block drivers, or NULL for an
1409 * empty set of options. The reference to the QDict belongs to the block layer
1410 * after the call (even on failure), so if the caller intends to reuse the
1411 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1413 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1414 * If it is not NULL, the referenced BDS will be reused.
1416 * The reference parameter may be used to specify an existing block device which
1417 * should be opened. If specified, neither options nor a filename may be given,
1418 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1420 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1421 const char *reference, QDict *options, int flags,
1422 BlockDriverState *parent,
1423 const BdrvChildRole *child_role,
1424 BlockDriver *drv, Error **errp)
1426 int ret;
1427 BlockDriverState *file = NULL, *bs;
1428 const char *drvname;
1429 Error *local_err = NULL;
1430 int snapshot_flags = 0;
1432 assert(pbs);
1433 assert(!child_role || !flags);
1434 assert(!child_role == !parent);
1436 if (reference) {
1437 bool options_non_empty = options ? qdict_size(options) : false;
1438 QDECREF(options);
1440 if (*pbs) {
1441 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1442 "another block device");
1443 return -EINVAL;
1446 if (filename || options_non_empty) {
1447 error_setg(errp, "Cannot reference an existing block device with "
1448 "additional options or a new filename");
1449 return -EINVAL;
1452 bs = bdrv_lookup_bs(reference, reference, errp);
1453 if (!bs) {
1454 return -ENODEV;
1456 bdrv_ref(bs);
1457 *pbs = bs;
1458 return 0;
1461 if (*pbs) {
1462 bs = *pbs;
1463 } else {
1464 bs = bdrv_new();
1467 /* NULL means an empty set of options */
1468 if (options == NULL) {
1469 options = qdict_new();
1472 if (child_role) {
1473 bs->inherits_from = parent;
1474 flags = child_role->inherit_flags(parent->open_flags);
1477 ret = bdrv_fill_options(&options, &filename, &flags, drv, &local_err);
1478 if (local_err) {
1479 goto fail;
1482 /* Find the right image format driver */
1483 drv = NULL;
1484 drvname = qdict_get_try_str(options, "driver");
1485 if (drvname) {
1486 drv = bdrv_find_format(drvname);
1487 qdict_del(options, "driver");
1488 if (!drv) {
1489 error_setg(errp, "Unknown driver: '%s'", drvname);
1490 ret = -EINVAL;
1491 goto fail;
1495 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1497 bs->open_flags = flags;
1498 bs->options = options;
1499 options = qdict_clone_shallow(options);
1501 /* Open image file without format layer */
1502 if ((flags & BDRV_O_PROTOCOL) == 0) {
1503 if (flags & BDRV_O_RDWR) {
1504 flags |= BDRV_O_ALLOW_RDWR;
1506 if (flags & BDRV_O_SNAPSHOT) {
1507 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1508 flags = bdrv_backing_flags(flags);
1511 assert(file == NULL);
1512 bs->open_flags = flags;
1513 ret = bdrv_open_image(&file, filename, options, "file",
1514 bs, &child_file, true, &local_err);
1515 if (ret < 0) {
1516 goto fail;
1520 /* Image format probing */
1521 bs->probed = !drv;
1522 if (!drv && file) {
1523 ret = find_image_format(file, filename, &drv, &local_err);
1524 if (ret < 0) {
1525 goto fail;
1527 } else if (!drv) {
1528 error_setg(errp, "Must specify either driver or file");
1529 ret = -EINVAL;
1530 goto fail;
1533 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1534 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1535 /* file must be NULL if a protocol BDS is about to be created
1536 * (the inverse results in an error message from bdrv_open_common()) */
1537 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1539 /* Open the image */
1540 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1541 if (ret < 0) {
1542 goto fail;
1545 if (file && (bs->file != file)) {
1546 bdrv_unref(file);
1547 file = NULL;
1550 /* If there is a backing file, use it */
1551 if ((flags & BDRV_O_NO_BACKING) == 0) {
1552 QDict *backing_options;
1554 qdict_extract_subqdict(options, &backing_options, "backing.");
1555 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1556 if (ret < 0) {
1557 goto close_and_fail;
1561 bdrv_refresh_filename(bs);
1563 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1564 * temporary snapshot afterwards. */
1565 if (snapshot_flags) {
1566 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1567 if (local_err) {
1568 goto close_and_fail;
1572 /* Check if any unknown options were used */
1573 if (options && (qdict_size(options) != 0)) {
1574 const QDictEntry *entry = qdict_first(options);
1575 if (flags & BDRV_O_PROTOCOL) {
1576 error_setg(errp, "Block protocol '%s' doesn't support the option "
1577 "'%s'", drv->format_name, entry->key);
1578 } else {
1579 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1580 "support the option '%s'", drv->format_name,
1581 bdrv_get_device_name(bs), entry->key);
1584 ret = -EINVAL;
1585 goto close_and_fail;
1588 if (!bdrv_key_required(bs)) {
1589 if (bs->blk) {
1590 blk_dev_change_media_cb(bs->blk, true);
1592 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1593 && !runstate_check(RUN_STATE_INMIGRATE)
1594 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1595 error_setg(errp,
1596 "Guest must be stopped for opening of encrypted image");
1597 ret = -EBUSY;
1598 goto close_and_fail;
1601 QDECREF(options);
1602 *pbs = bs;
1603 return 0;
1605 fail:
1606 if (file != NULL) {
1607 bdrv_unref(file);
1609 QDECREF(bs->options);
1610 QDECREF(options);
1611 bs->options = NULL;
1612 if (!*pbs) {
1613 /* If *pbs is NULL, a new BDS has been created in this function and
1614 needs to be freed now. Otherwise, it does not need to be closed,
1615 since it has not really been opened yet. */
1616 bdrv_unref(bs);
1618 if (local_err) {
1619 error_propagate(errp, local_err);
1621 return ret;
1623 close_and_fail:
1624 /* See fail path, but now the BDS has to be always closed */
1625 if (*pbs) {
1626 bdrv_close(bs);
1627 } else {
1628 bdrv_unref(bs);
1630 QDECREF(options);
1631 if (local_err) {
1632 error_propagate(errp, local_err);
1634 return ret;
1637 int bdrv_open(BlockDriverState **pbs, const char *filename,
1638 const char *reference, QDict *options, int flags,
1639 BlockDriver *drv, Error **errp)
1641 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1642 NULL, drv, errp);
1645 typedef struct BlockReopenQueueEntry {
1646 bool prepared;
1647 BDRVReopenState state;
1648 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1649 } BlockReopenQueueEntry;
1652 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1653 * reopen of multiple devices.
1655 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1656 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1657 * be created and initialized. This newly created BlockReopenQueue should be
1658 * passed back in for subsequent calls that are intended to be of the same
1659 * atomic 'set'.
1661 * bs is the BlockDriverState to add to the reopen queue.
1663 * flags contains the open flags for the associated bs
1665 * returns a pointer to bs_queue, which is either the newly allocated
1666 * bs_queue, or the existing bs_queue being used.
1669 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1670 BlockDriverState *bs, int flags)
1672 assert(bs != NULL);
1674 BlockReopenQueueEntry *bs_entry;
1675 BdrvChild *child;
1677 if (bs_queue == NULL) {
1678 bs_queue = g_new0(BlockReopenQueue, 1);
1679 QSIMPLEQ_INIT(bs_queue);
1682 /* bdrv_open() masks this flag out */
1683 flags &= ~BDRV_O_PROTOCOL;
1685 QLIST_FOREACH(child, &bs->children, next) {
1686 int child_flags;
1688 if (child->bs->inherits_from != bs) {
1689 continue;
1692 child_flags = child->role->inherit_flags(flags);
1693 bdrv_reopen_queue(bs_queue, child->bs, child_flags);
1696 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1697 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1699 bs_entry->state.bs = bs;
1700 bs_entry->state.flags = flags;
1702 return bs_queue;
1706 * Reopen multiple BlockDriverStates atomically & transactionally.
1708 * The queue passed in (bs_queue) must have been built up previous
1709 * via bdrv_reopen_queue().
1711 * Reopens all BDS specified in the queue, with the appropriate
1712 * flags. All devices are prepared for reopen, and failure of any
1713 * device will cause all device changes to be abandonded, and intermediate
1714 * data cleaned up.
1716 * If all devices prepare successfully, then the changes are committed
1717 * to all devices.
1720 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1722 int ret = -1;
1723 BlockReopenQueueEntry *bs_entry, *next;
1724 Error *local_err = NULL;
1726 assert(bs_queue != NULL);
1728 bdrv_drain_all();
1730 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1731 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1732 error_propagate(errp, local_err);
1733 goto cleanup;
1735 bs_entry->prepared = true;
1738 /* If we reach this point, we have success and just need to apply the
1739 * changes
1741 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1742 bdrv_reopen_commit(&bs_entry->state);
1745 ret = 0;
1747 cleanup:
1748 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1749 if (ret && bs_entry->prepared) {
1750 bdrv_reopen_abort(&bs_entry->state);
1752 g_free(bs_entry);
1754 g_free(bs_queue);
1755 return ret;
1759 /* Reopen a single BlockDriverState with the specified flags. */
1760 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1762 int ret = -1;
1763 Error *local_err = NULL;
1764 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1766 ret = bdrv_reopen_multiple(queue, &local_err);
1767 if (local_err != NULL) {
1768 error_propagate(errp, local_err);
1770 return ret;
1775 * Prepares a BlockDriverState for reopen. All changes are staged in the
1776 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1777 * the block driver layer .bdrv_reopen_prepare()
1779 * bs is the BlockDriverState to reopen
1780 * flags are the new open flags
1781 * queue is the reopen queue
1783 * Returns 0 on success, non-zero on error. On error errp will be set
1784 * as well.
1786 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1787 * It is the responsibility of the caller to then call the abort() or
1788 * commit() for any other BDS that have been left in a prepare() state
1791 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1792 Error **errp)
1794 int ret = -1;
1795 Error *local_err = NULL;
1796 BlockDriver *drv;
1798 assert(reopen_state != NULL);
1799 assert(reopen_state->bs->drv != NULL);
1800 drv = reopen_state->bs->drv;
1802 /* if we are to stay read-only, do not allow permission change
1803 * to r/w */
1804 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1805 reopen_state->flags & BDRV_O_RDWR) {
1806 error_setg(errp, "Node '%s' is read only",
1807 bdrv_get_device_or_node_name(reopen_state->bs));
1808 goto error;
1812 ret = bdrv_flush(reopen_state->bs);
1813 if (ret) {
1814 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1815 strerror(-ret));
1816 goto error;
1819 if (drv->bdrv_reopen_prepare) {
1820 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1821 if (ret) {
1822 if (local_err != NULL) {
1823 error_propagate(errp, local_err);
1824 } else {
1825 error_setg(errp, "failed while preparing to reopen image '%s'",
1826 reopen_state->bs->filename);
1828 goto error;
1830 } else {
1831 /* It is currently mandatory to have a bdrv_reopen_prepare()
1832 * handler for each supported drv. */
1833 error_setg(errp, "Block format '%s' used by node '%s' "
1834 "does not support reopening files", drv->format_name,
1835 bdrv_get_device_or_node_name(reopen_state->bs));
1836 ret = -1;
1837 goto error;
1840 ret = 0;
1842 error:
1843 return ret;
1847 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1848 * makes them final by swapping the staging BlockDriverState contents into
1849 * the active BlockDriverState contents.
1851 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1853 BlockDriver *drv;
1855 assert(reopen_state != NULL);
1856 drv = reopen_state->bs->drv;
1857 assert(drv != NULL);
1859 /* If there are any driver level actions to take */
1860 if (drv->bdrv_reopen_commit) {
1861 drv->bdrv_reopen_commit(reopen_state);
1864 /* set BDS specific flags now */
1865 reopen_state->bs->open_flags = reopen_state->flags;
1866 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1867 BDRV_O_CACHE_WB);
1868 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1870 bdrv_refresh_limits(reopen_state->bs, NULL);
1874 * Abort the reopen, and delete and free the staged changes in
1875 * reopen_state
1877 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1879 BlockDriver *drv;
1881 assert(reopen_state != NULL);
1882 drv = reopen_state->bs->drv;
1883 assert(drv != NULL);
1885 if (drv->bdrv_reopen_abort) {
1886 drv->bdrv_reopen_abort(reopen_state);
1891 void bdrv_close(BlockDriverState *bs)
1893 BdrvAioNotifier *ban, *ban_next;
1895 if (bs->job) {
1896 block_job_cancel_sync(bs->job);
1898 bdrv_drain(bs); /* complete I/O */
1899 bdrv_flush(bs);
1900 bdrv_drain(bs); /* in case flush left pending I/O */
1901 notifier_list_notify(&bs->close_notifiers, bs);
1903 if (bs->drv) {
1904 BdrvChild *child, *next;
1906 bs->drv->bdrv_close(bs);
1908 if (bs->backing_hd) {
1909 BlockDriverState *backing_hd = bs->backing_hd;
1910 bdrv_set_backing_hd(bs, NULL);
1911 bdrv_unref(backing_hd);
1914 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
1915 /* TODO Remove bdrv_unref() from drivers' close function and use
1916 * bdrv_unref_child() here */
1917 if (child->bs->inherits_from == bs) {
1918 child->bs->inherits_from = NULL;
1920 bdrv_detach_child(child);
1923 g_free(bs->opaque);
1924 bs->opaque = NULL;
1925 bs->drv = NULL;
1926 bs->copy_on_read = 0;
1927 bs->backing_file[0] = '\0';
1928 bs->backing_format[0] = '\0';
1929 bs->total_sectors = 0;
1930 bs->encrypted = 0;
1931 bs->valid_key = 0;
1932 bs->sg = 0;
1933 bs->zero_beyond_eof = false;
1934 QDECREF(bs->options);
1935 bs->options = NULL;
1936 QDECREF(bs->full_open_options);
1937 bs->full_open_options = NULL;
1939 if (bs->file != NULL) {
1940 bdrv_unref(bs->file);
1941 bs->file = NULL;
1945 if (bs->blk) {
1946 blk_dev_change_media_cb(bs->blk, false);
1949 /*throttling disk I/O limits*/
1950 if (bs->io_limits_enabled) {
1951 bdrv_io_limits_disable(bs);
1954 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1955 g_free(ban);
1957 QLIST_INIT(&bs->aio_notifiers);
1960 void bdrv_close_all(void)
1962 BlockDriverState *bs;
1964 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1965 AioContext *aio_context = bdrv_get_aio_context(bs);
1967 aio_context_acquire(aio_context);
1968 bdrv_close(bs);
1969 aio_context_release(aio_context);
1973 /* make a BlockDriverState anonymous by removing from bdrv_state and
1974 * graph_bdrv_state list.
1975 Also, NULL terminate the device_name to prevent double remove */
1976 void bdrv_make_anon(BlockDriverState *bs)
1979 * Take care to remove bs from bdrv_states only when it's actually
1980 * in it. Note that bs->device_list.tqe_prev is initially null,
1981 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1982 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1983 * resetting it to null on remove.
1985 if (bs->device_list.tqe_prev) {
1986 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1987 bs->device_list.tqe_prev = NULL;
1989 if (bs->node_name[0] != '\0') {
1990 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1992 bs->node_name[0] = '\0';
1995 static void bdrv_rebind(BlockDriverState *bs)
1997 if (bs->drv && bs->drv->bdrv_rebind) {
1998 bs->drv->bdrv_rebind(bs);
2002 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2003 BlockDriverState *bs_src)
2005 /* move some fields that need to stay attached to the device */
2007 /* dev info */
2008 bs_dest->guest_block_size = bs_src->guest_block_size;
2009 bs_dest->copy_on_read = bs_src->copy_on_read;
2011 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2013 /* i/o throttled req */
2014 bs_dest->throttle_state = bs_src->throttle_state,
2015 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
2016 bs_dest->pending_reqs[0] = bs_src->pending_reqs[0];
2017 bs_dest->pending_reqs[1] = bs_src->pending_reqs[1];
2018 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
2019 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
2020 memcpy(&bs_dest->round_robin,
2021 &bs_src->round_robin,
2022 sizeof(bs_dest->round_robin));
2023 memcpy(&bs_dest->throttle_timers,
2024 &bs_src->throttle_timers,
2025 sizeof(ThrottleTimers));
2027 /* r/w error */
2028 bs_dest->on_read_error = bs_src->on_read_error;
2029 bs_dest->on_write_error = bs_src->on_write_error;
2031 /* i/o status */
2032 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
2033 bs_dest->iostatus = bs_src->iostatus;
2035 /* dirty bitmap */
2036 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2038 /* reference count */
2039 bs_dest->refcnt = bs_src->refcnt;
2041 /* job */
2042 bs_dest->job = bs_src->job;
2044 /* keep the same entry in bdrv_states */
2045 bs_dest->device_list = bs_src->device_list;
2046 bs_dest->blk = bs_src->blk;
2048 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2049 sizeof(bs_dest->op_blockers));
2053 * Swap bs contents for two image chains while they are live,
2054 * while keeping required fields on the BlockDriverState that is
2055 * actually attached to a device.
2057 * This will modify the BlockDriverState fields, and swap contents
2058 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2060 * bs_new must not be attached to a BlockBackend.
2062 * This function does not create any image files.
2064 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2066 BlockDriverState tmp;
2067 BdrvChild *child;
2069 bdrv_drain(bs_new);
2070 bdrv_drain(bs_old);
2072 /* The code needs to swap the node_name but simply swapping node_list won't
2073 * work so first remove the nodes from the graph list, do the swap then
2074 * insert them back if needed.
2076 if (bs_new->node_name[0] != '\0') {
2077 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2079 if (bs_old->node_name[0] != '\0') {
2080 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2083 /* If the BlockDriverState is part of a throttling group acquire
2084 * its lock since we're going to mess with the protected fields.
2085 * Otherwise there's no need to worry since no one else can touch
2086 * them. */
2087 if (bs_old->throttle_state) {
2088 throttle_group_lock(bs_old);
2091 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2092 assert(!bs_new->blk);
2093 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2094 assert(bs_new->job == NULL);
2095 assert(bs_new->io_limits_enabled == false);
2096 assert(bs_new->throttle_state == NULL);
2097 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2099 tmp = *bs_new;
2100 *bs_new = *bs_old;
2101 *bs_old = tmp;
2103 /* there are some fields that should not be swapped, move them back */
2104 bdrv_move_feature_fields(&tmp, bs_old);
2105 bdrv_move_feature_fields(bs_old, bs_new);
2106 bdrv_move_feature_fields(bs_new, &tmp);
2108 /* bs_new must remain unattached */
2109 assert(!bs_new->blk);
2111 /* Check a few fields that should remain attached to the device */
2112 assert(bs_new->job == NULL);
2113 assert(bs_new->io_limits_enabled == false);
2114 assert(bs_new->throttle_state == NULL);
2115 assert(!throttle_timers_are_initialized(&bs_new->throttle_timers));
2117 /* Release the ThrottleGroup lock */
2118 if (bs_old->throttle_state) {
2119 throttle_group_unlock(bs_old);
2122 /* insert the nodes back into the graph node list if needed */
2123 if (bs_new->node_name[0] != '\0') {
2124 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2126 if (bs_old->node_name[0] != '\0') {
2127 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2131 * Update lh_first.le_prev for non-empty lists.
2133 * The head of the op blocker list doesn't change because it is moved back
2134 * in bdrv_move_feature_fields().
2136 assert(QLIST_EMPTY(&bs_old->tracked_requests));
2137 assert(QLIST_EMPTY(&bs_new->tracked_requests));
2139 QLIST_FIX_HEAD_PTR(&bs_new->children, next);
2140 QLIST_FIX_HEAD_PTR(&bs_old->children, next);
2142 /* Update references in bs->opaque and children */
2143 QLIST_FOREACH(child, &bs_old->children, next) {
2144 if (child->bs->inherits_from == bs_new) {
2145 child->bs->inherits_from = bs_old;
2148 QLIST_FOREACH(child, &bs_new->children, next) {
2149 if (child->bs->inherits_from == bs_old) {
2150 child->bs->inherits_from = bs_new;
2154 bdrv_rebind(bs_new);
2155 bdrv_rebind(bs_old);
2159 * Add new bs contents at the top of an image chain while the chain is
2160 * live, while keeping required fields on the top layer.
2162 * This will modify the BlockDriverState fields, and swap contents
2163 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2165 * bs_new must not be attached to a BlockBackend.
2167 * This function does not create any image files.
2169 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2171 bdrv_swap(bs_new, bs_top);
2173 /* The contents of 'tmp' will become bs_top, as we are
2174 * swapping bs_new and bs_top contents. */
2175 bdrv_set_backing_hd(bs_top, bs_new);
2178 static void bdrv_delete(BlockDriverState *bs)
2180 assert(!bs->job);
2181 assert(bdrv_op_blocker_is_empty(bs));
2182 assert(!bs->refcnt);
2183 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2185 bdrv_close(bs);
2187 /* remove from list, if necessary */
2188 bdrv_make_anon(bs);
2190 g_free(bs);
2194 * Run consistency checks on an image
2196 * Returns 0 if the check could be completed (it doesn't mean that the image is
2197 * free of errors) or -errno when an internal error occurred. The results of the
2198 * check are stored in res.
2200 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2202 if (bs->drv == NULL) {
2203 return -ENOMEDIUM;
2205 if (bs->drv->bdrv_check == NULL) {
2206 return -ENOTSUP;
2209 memset(res, 0, sizeof(*res));
2210 return bs->drv->bdrv_check(bs, res, fix);
2213 #define COMMIT_BUF_SECTORS 2048
2215 /* commit COW file into the raw image */
2216 int bdrv_commit(BlockDriverState *bs)
2218 BlockDriver *drv = bs->drv;
2219 int64_t sector, total_sectors, length, backing_length;
2220 int n, ro, open_flags;
2221 int ret = 0;
2222 uint8_t *buf = NULL;
2224 if (!drv)
2225 return -ENOMEDIUM;
2227 if (!bs->backing_hd) {
2228 return -ENOTSUP;
2231 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2232 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2233 return -EBUSY;
2236 ro = bs->backing_hd->read_only;
2237 open_flags = bs->backing_hd->open_flags;
2239 if (ro) {
2240 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2241 return -EACCES;
2245 length = bdrv_getlength(bs);
2246 if (length < 0) {
2247 ret = length;
2248 goto ro_cleanup;
2251 backing_length = bdrv_getlength(bs->backing_hd);
2252 if (backing_length < 0) {
2253 ret = backing_length;
2254 goto ro_cleanup;
2257 /* If our top snapshot is larger than the backing file image,
2258 * grow the backing file image if possible. If not possible,
2259 * we must return an error */
2260 if (length > backing_length) {
2261 ret = bdrv_truncate(bs->backing_hd, length);
2262 if (ret < 0) {
2263 goto ro_cleanup;
2267 total_sectors = length >> BDRV_SECTOR_BITS;
2269 /* qemu_try_blockalign() for bs will choose an alignment that works for
2270 * bs->backing_hd as well, so no need to compare the alignment manually. */
2271 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2272 if (buf == NULL) {
2273 ret = -ENOMEM;
2274 goto ro_cleanup;
2277 for (sector = 0; sector < total_sectors; sector += n) {
2278 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2279 if (ret < 0) {
2280 goto ro_cleanup;
2282 if (ret) {
2283 ret = bdrv_read(bs, sector, buf, n);
2284 if (ret < 0) {
2285 goto ro_cleanup;
2288 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2289 if (ret < 0) {
2290 goto ro_cleanup;
2295 if (drv->bdrv_make_empty) {
2296 ret = drv->bdrv_make_empty(bs);
2297 if (ret < 0) {
2298 goto ro_cleanup;
2300 bdrv_flush(bs);
2304 * Make sure all data we wrote to the backing device is actually
2305 * stable on disk.
2307 if (bs->backing_hd) {
2308 bdrv_flush(bs->backing_hd);
2311 ret = 0;
2312 ro_cleanup:
2313 qemu_vfree(buf);
2315 if (ro) {
2316 /* ignoring error return here */
2317 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2320 return ret;
2323 int bdrv_commit_all(void)
2325 BlockDriverState *bs;
2327 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2328 AioContext *aio_context = bdrv_get_aio_context(bs);
2330 aio_context_acquire(aio_context);
2331 if (bs->drv && bs->backing_hd) {
2332 int ret = bdrv_commit(bs);
2333 if (ret < 0) {
2334 aio_context_release(aio_context);
2335 return ret;
2338 aio_context_release(aio_context);
2340 return 0;
2344 * Return values:
2345 * 0 - success
2346 * -EINVAL - backing format specified, but no file
2347 * -ENOSPC - can't update the backing file because no space is left in the
2348 * image file header
2349 * -ENOTSUP - format driver doesn't support changing the backing file
2351 int bdrv_change_backing_file(BlockDriverState *bs,
2352 const char *backing_file, const char *backing_fmt)
2354 BlockDriver *drv = bs->drv;
2355 int ret;
2357 /* Backing file format doesn't make sense without a backing file */
2358 if (backing_fmt && !backing_file) {
2359 return -EINVAL;
2362 if (drv->bdrv_change_backing_file != NULL) {
2363 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2364 } else {
2365 ret = -ENOTSUP;
2368 if (ret == 0) {
2369 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2370 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2372 return ret;
2376 * Finds the image layer in the chain that has 'bs' as its backing file.
2378 * active is the current topmost image.
2380 * Returns NULL if bs is not found in active's image chain,
2381 * or if active == bs.
2383 * Returns the bottommost base image if bs == NULL.
2385 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2386 BlockDriverState *bs)
2388 while (active && bs != active->backing_hd) {
2389 active = active->backing_hd;
2392 return active;
2395 /* Given a BDS, searches for the base layer. */
2396 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2398 return bdrv_find_overlay(bs, NULL);
2401 typedef struct BlkIntermediateStates {
2402 BlockDriverState *bs;
2403 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2404 } BlkIntermediateStates;
2408 * Drops images above 'base' up to and including 'top', and sets the image
2409 * above 'top' to have base as its backing file.
2411 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2412 * information in 'bs' can be properly updated.
2414 * E.g., this will convert the following chain:
2415 * bottom <- base <- intermediate <- top <- active
2417 * to
2419 * bottom <- base <- active
2421 * It is allowed for bottom==base, in which case it converts:
2423 * base <- intermediate <- top <- active
2425 * to
2427 * base <- active
2429 * If backing_file_str is non-NULL, it will be used when modifying top's
2430 * overlay image metadata.
2432 * Error conditions:
2433 * if active == top, that is considered an error
2436 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2437 BlockDriverState *base, const char *backing_file_str)
2439 BlockDriverState *intermediate;
2440 BlockDriverState *base_bs = NULL;
2441 BlockDriverState *new_top_bs = NULL;
2442 BlkIntermediateStates *intermediate_state, *next;
2443 int ret = -EIO;
2445 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2446 QSIMPLEQ_INIT(&states_to_delete);
2448 if (!top->drv || !base->drv) {
2449 goto exit;
2452 new_top_bs = bdrv_find_overlay(active, top);
2454 if (new_top_bs == NULL) {
2455 /* we could not find the image above 'top', this is an error */
2456 goto exit;
2459 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2460 * to do, no intermediate images */
2461 if (new_top_bs->backing_hd == base) {
2462 ret = 0;
2463 goto exit;
2466 intermediate = top;
2468 /* now we will go down through the list, and add each BDS we find
2469 * into our deletion queue, until we hit the 'base'
2471 while (intermediate) {
2472 intermediate_state = g_new0(BlkIntermediateStates, 1);
2473 intermediate_state->bs = intermediate;
2474 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2476 if (intermediate->backing_hd == base) {
2477 base_bs = intermediate->backing_hd;
2478 break;
2480 intermediate = intermediate->backing_hd;
2482 if (base_bs == NULL) {
2483 /* something went wrong, we did not end at the base. safely
2484 * unravel everything, and exit with error */
2485 goto exit;
2488 /* success - we can delete the intermediate states, and link top->base */
2489 backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2490 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2491 base_bs->drv ? base_bs->drv->format_name : "");
2492 if (ret) {
2493 goto exit;
2495 bdrv_set_backing_hd(new_top_bs, base_bs);
2497 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2498 /* so that bdrv_close() does not recursively close the chain */
2499 bdrv_set_backing_hd(intermediate_state->bs, NULL);
2500 bdrv_unref(intermediate_state->bs);
2502 ret = 0;
2504 exit:
2505 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2506 g_free(intermediate_state);
2508 return ret;
2512 * Truncate file to 'offset' bytes (needed only for file protocols)
2514 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2516 BlockDriver *drv = bs->drv;
2517 int ret;
2518 if (!drv)
2519 return -ENOMEDIUM;
2520 if (!drv->bdrv_truncate)
2521 return -ENOTSUP;
2522 if (bs->read_only)
2523 return -EACCES;
2525 ret = drv->bdrv_truncate(bs, offset);
2526 if (ret == 0) {
2527 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2528 bdrv_dirty_bitmap_truncate(bs);
2529 if (bs->blk) {
2530 blk_dev_resize_cb(bs->blk);
2533 return ret;
2537 * Length of a allocated file in bytes. Sparse files are counted by actual
2538 * allocated space. Return < 0 if error or unknown.
2540 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2542 BlockDriver *drv = bs->drv;
2543 if (!drv) {
2544 return -ENOMEDIUM;
2546 if (drv->bdrv_get_allocated_file_size) {
2547 return drv->bdrv_get_allocated_file_size(bs);
2549 if (bs->file) {
2550 return bdrv_get_allocated_file_size(bs->file);
2552 return -ENOTSUP;
2556 * Return number of sectors on success, -errno on error.
2558 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2560 BlockDriver *drv = bs->drv;
2562 if (!drv)
2563 return -ENOMEDIUM;
2565 if (drv->has_variable_length) {
2566 int ret = refresh_total_sectors(bs, bs->total_sectors);
2567 if (ret < 0) {
2568 return ret;
2571 return bs->total_sectors;
2575 * Return length in bytes on success, -errno on error.
2576 * The length is always a multiple of BDRV_SECTOR_SIZE.
2578 int64_t bdrv_getlength(BlockDriverState *bs)
2580 int64_t ret = bdrv_nb_sectors(bs);
2582 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2583 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2586 /* return 0 as number of sectors if no device present or error */
2587 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2589 int64_t nb_sectors = bdrv_nb_sectors(bs);
2591 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2594 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2595 BlockdevOnError on_write_error)
2597 bs->on_read_error = on_read_error;
2598 bs->on_write_error = on_write_error;
2601 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2603 return is_read ? bs->on_read_error : bs->on_write_error;
2606 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2608 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2610 switch (on_err) {
2611 case BLOCKDEV_ON_ERROR_ENOSPC:
2612 return (error == ENOSPC) ?
2613 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
2614 case BLOCKDEV_ON_ERROR_STOP:
2615 return BLOCK_ERROR_ACTION_STOP;
2616 case BLOCKDEV_ON_ERROR_REPORT:
2617 return BLOCK_ERROR_ACTION_REPORT;
2618 case BLOCKDEV_ON_ERROR_IGNORE:
2619 return BLOCK_ERROR_ACTION_IGNORE;
2620 default:
2621 abort();
2625 static void send_qmp_error_event(BlockDriverState *bs,
2626 BlockErrorAction action,
2627 bool is_read, int error)
2629 IoOperationType optype;
2631 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
2632 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
2633 bdrv_iostatus_is_enabled(bs),
2634 error == ENOSPC, strerror(error),
2635 &error_abort);
2638 /* This is done by device models because, while the block layer knows
2639 * about the error, it does not know whether an operation comes from
2640 * the device or the block layer (from a job, for example).
2642 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2643 bool is_read, int error)
2645 assert(error >= 0);
2647 if (action == BLOCK_ERROR_ACTION_STOP) {
2648 /* First set the iostatus, so that "info block" returns an iostatus
2649 * that matches the events raised so far (an additional error iostatus
2650 * is fine, but not a lost one).
2652 bdrv_iostatus_set_err(bs, error);
2654 /* Then raise the request to stop the VM and the event.
2655 * qemu_system_vmstop_request_prepare has two effects. First,
2656 * it ensures that the STOP event always comes after the
2657 * BLOCK_IO_ERROR event. Second, it ensures that even if management
2658 * can observe the STOP event and do a "cont" before the STOP
2659 * event is issued, the VM will not stop. In this case, vm_start()
2660 * also ensures that the STOP/RESUME pair of events is emitted.
2662 qemu_system_vmstop_request_prepare();
2663 send_qmp_error_event(bs, action, is_read, error);
2664 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
2665 } else {
2666 send_qmp_error_event(bs, action, is_read, error);
2670 int bdrv_is_read_only(BlockDriverState *bs)
2672 return bs->read_only;
2675 int bdrv_is_sg(BlockDriverState *bs)
2677 return bs->sg;
2680 int bdrv_enable_write_cache(BlockDriverState *bs)
2682 return bs->enable_write_cache;
2685 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2687 bs->enable_write_cache = wce;
2689 /* so a reopen() will preserve wce */
2690 if (wce) {
2691 bs->open_flags |= BDRV_O_CACHE_WB;
2692 } else {
2693 bs->open_flags &= ~BDRV_O_CACHE_WB;
2697 int bdrv_is_encrypted(BlockDriverState *bs)
2699 if (bs->backing_hd && bs->backing_hd->encrypted)
2700 return 1;
2701 return bs->encrypted;
2704 int bdrv_key_required(BlockDriverState *bs)
2706 BlockDriverState *backing_hd = bs->backing_hd;
2708 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2709 return 1;
2710 return (bs->encrypted && !bs->valid_key);
2713 int bdrv_set_key(BlockDriverState *bs, const char *key)
2715 int ret;
2716 if (bs->backing_hd && bs->backing_hd->encrypted) {
2717 ret = bdrv_set_key(bs->backing_hd, key);
2718 if (ret < 0)
2719 return ret;
2720 if (!bs->encrypted)
2721 return 0;
2723 if (!bs->encrypted) {
2724 return -EINVAL;
2725 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2726 return -ENOMEDIUM;
2728 ret = bs->drv->bdrv_set_key(bs, key);
2729 if (ret < 0) {
2730 bs->valid_key = 0;
2731 } else if (!bs->valid_key) {
2732 bs->valid_key = 1;
2733 if (bs->blk) {
2734 /* call the change callback now, we skipped it on open */
2735 blk_dev_change_media_cb(bs->blk, true);
2738 return ret;
2742 * Provide an encryption key for @bs.
2743 * If @key is non-null:
2744 * If @bs is not encrypted, fail.
2745 * Else if the key is invalid, fail.
2746 * Else set @bs's key to @key, replacing the existing key, if any.
2747 * If @key is null:
2748 * If @bs is encrypted and still lacks a key, fail.
2749 * Else do nothing.
2750 * On failure, store an error object through @errp if non-null.
2752 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2754 if (key) {
2755 if (!bdrv_is_encrypted(bs)) {
2756 error_setg(errp, "Node '%s' is not encrypted",
2757 bdrv_get_device_or_node_name(bs));
2758 } else if (bdrv_set_key(bs, key) < 0) {
2759 error_setg(errp, QERR_INVALID_PASSWORD);
2761 } else {
2762 if (bdrv_key_required(bs)) {
2763 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2764 "'%s' (%s) is encrypted",
2765 bdrv_get_device_or_node_name(bs),
2766 bdrv_get_encrypted_filename(bs));
2771 const char *bdrv_get_format_name(BlockDriverState *bs)
2773 return bs->drv ? bs->drv->format_name : NULL;
2776 static int qsort_strcmp(const void *a, const void *b)
2778 return strcmp(a, b);
2781 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2782 void *opaque)
2784 BlockDriver *drv;
2785 int count = 0;
2786 int i;
2787 const char **formats = NULL;
2789 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2790 if (drv->format_name) {
2791 bool found = false;
2792 int i = count;
2793 while (formats && i && !found) {
2794 found = !strcmp(formats[--i], drv->format_name);
2797 if (!found) {
2798 formats = g_renew(const char *, formats, count + 1);
2799 formats[count++] = drv->format_name;
2804 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2806 for (i = 0; i < count; i++) {
2807 it(opaque, formats[i]);
2810 g_free(formats);
2813 /* This function is to find a node in the bs graph */
2814 BlockDriverState *bdrv_find_node(const char *node_name)
2816 BlockDriverState *bs;
2818 assert(node_name);
2820 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2821 if (!strcmp(node_name, bs->node_name)) {
2822 return bs;
2825 return NULL;
2828 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2829 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2831 BlockDeviceInfoList *list, *entry;
2832 BlockDriverState *bs;
2834 list = NULL;
2835 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2836 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2837 if (!info) {
2838 qapi_free_BlockDeviceInfoList(list);
2839 return NULL;
2841 entry = g_malloc0(sizeof(*entry));
2842 entry->value = info;
2843 entry->next = list;
2844 list = entry;
2847 return list;
2850 BlockDriverState *bdrv_lookup_bs(const char *device,
2851 const char *node_name,
2852 Error **errp)
2854 BlockBackend *blk;
2855 BlockDriverState *bs;
2857 if (device) {
2858 blk = blk_by_name(device);
2860 if (blk) {
2861 return blk_bs(blk);
2865 if (node_name) {
2866 bs = bdrv_find_node(node_name);
2868 if (bs) {
2869 return bs;
2873 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2874 device ? device : "",
2875 node_name ? node_name : "");
2876 return NULL;
2879 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2880 * return false. If either argument is NULL, return false. */
2881 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2883 while (top && top != base) {
2884 top = top->backing_hd;
2887 return top != NULL;
2890 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2892 if (!bs) {
2893 return QTAILQ_FIRST(&graph_bdrv_states);
2895 return QTAILQ_NEXT(bs, node_list);
2898 BlockDriverState *bdrv_next(BlockDriverState *bs)
2900 if (!bs) {
2901 return QTAILQ_FIRST(&bdrv_states);
2903 return QTAILQ_NEXT(bs, device_list);
2906 const char *bdrv_get_node_name(const BlockDriverState *bs)
2908 return bs->node_name;
2911 /* TODO check what callers really want: bs->node_name or blk_name() */
2912 const char *bdrv_get_device_name(const BlockDriverState *bs)
2914 return bs->blk ? blk_name(bs->blk) : "";
2917 /* This can be used to identify nodes that might not have a device
2918 * name associated. Since node and device names live in the same
2919 * namespace, the result is unambiguous. The exception is if both are
2920 * absent, then this returns an empty (non-null) string. */
2921 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
2923 return bs->blk ? blk_name(bs->blk) : bs->node_name;
2926 int bdrv_get_flags(BlockDriverState *bs)
2928 return bs->open_flags;
2931 int bdrv_has_zero_init_1(BlockDriverState *bs)
2933 return 1;
2936 int bdrv_has_zero_init(BlockDriverState *bs)
2938 assert(bs->drv);
2940 /* If BS is a copy on write image, it is initialized to
2941 the contents of the base image, which may not be zeroes. */
2942 if (bs->backing_hd) {
2943 return 0;
2945 if (bs->drv->bdrv_has_zero_init) {
2946 return bs->drv->bdrv_has_zero_init(bs);
2949 /* safe default */
2950 return 0;
2953 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
2955 BlockDriverInfo bdi;
2957 if (bs->backing_hd) {
2958 return false;
2961 if (bdrv_get_info(bs, &bdi) == 0) {
2962 return bdi.unallocated_blocks_are_zero;
2965 return false;
2968 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
2970 BlockDriverInfo bdi;
2972 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
2973 return false;
2976 if (bdrv_get_info(bs, &bdi) == 0) {
2977 return bdi.can_write_zeroes_with_unmap;
2980 return false;
2983 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2985 if (bs->backing_hd && bs->backing_hd->encrypted)
2986 return bs->backing_file;
2987 else if (bs->encrypted)
2988 return bs->filename;
2989 else
2990 return NULL;
2993 void bdrv_get_backing_filename(BlockDriverState *bs,
2994 char *filename, int filename_size)
2996 pstrcpy(filename, filename_size, bs->backing_file);
2999 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3001 BlockDriver *drv = bs->drv;
3002 if (!drv)
3003 return -ENOMEDIUM;
3004 if (!drv->bdrv_get_info)
3005 return -ENOTSUP;
3006 memset(bdi, 0, sizeof(*bdi));
3007 return drv->bdrv_get_info(bs, bdi);
3010 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3012 BlockDriver *drv = bs->drv;
3013 if (drv && drv->bdrv_get_specific_info) {
3014 return drv->bdrv_get_specific_info(bs);
3016 return NULL;
3019 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3021 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3022 return;
3025 bs->drv->bdrv_debug_event(bs, event);
3028 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3029 const char *tag)
3031 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3032 bs = bs->file;
3035 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3036 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3039 return -ENOTSUP;
3042 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3044 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3045 bs = bs->file;
3048 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3049 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3052 return -ENOTSUP;
3055 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3057 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3058 bs = bs->file;
3061 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3062 return bs->drv->bdrv_debug_resume(bs, tag);
3065 return -ENOTSUP;
3068 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3070 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3071 bs = bs->file;
3074 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3075 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3078 return false;
3081 int bdrv_is_snapshot(BlockDriverState *bs)
3083 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3086 /* backing_file can either be relative, or absolute, or a protocol. If it is
3087 * relative, it must be relative to the chain. So, passing in bs->filename
3088 * from a BDS as backing_file should not be done, as that may be relative to
3089 * the CWD rather than the chain. */
3090 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3091 const char *backing_file)
3093 char *filename_full = NULL;
3094 char *backing_file_full = NULL;
3095 char *filename_tmp = NULL;
3096 int is_protocol = 0;
3097 BlockDriverState *curr_bs = NULL;
3098 BlockDriverState *retval = NULL;
3100 if (!bs || !bs->drv || !backing_file) {
3101 return NULL;
3104 filename_full = g_malloc(PATH_MAX);
3105 backing_file_full = g_malloc(PATH_MAX);
3106 filename_tmp = g_malloc(PATH_MAX);
3108 is_protocol = path_has_protocol(backing_file);
3110 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3112 /* If either of the filename paths is actually a protocol, then
3113 * compare unmodified paths; otherwise make paths relative */
3114 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3115 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3116 retval = curr_bs->backing_hd;
3117 break;
3119 } else {
3120 /* If not an absolute filename path, make it relative to the current
3121 * image's filename path */
3122 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3123 backing_file);
3125 /* We are going to compare absolute pathnames */
3126 if (!realpath(filename_tmp, filename_full)) {
3127 continue;
3130 /* We need to make sure the backing filename we are comparing against
3131 * is relative to the current image filename (or absolute) */
3132 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3133 curr_bs->backing_file);
3135 if (!realpath(filename_tmp, backing_file_full)) {
3136 continue;
3139 if (strcmp(backing_file_full, filename_full) == 0) {
3140 retval = curr_bs->backing_hd;
3141 break;
3146 g_free(filename_full);
3147 g_free(backing_file_full);
3148 g_free(filename_tmp);
3149 return retval;
3152 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3154 if (!bs->drv) {
3155 return 0;
3158 if (!bs->backing_hd) {
3159 return 0;
3162 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3165 void bdrv_init(void)
3167 module_call_init(MODULE_INIT_BLOCK);
3170 void bdrv_init_with_whitelist(void)
3172 use_bdrv_whitelist = 1;
3173 bdrv_init();
3176 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3178 Error *local_err = NULL;
3179 int ret;
3181 if (!bs->drv) {
3182 return;
3185 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3186 return;
3188 bs->open_flags &= ~BDRV_O_INCOMING;
3190 if (bs->drv->bdrv_invalidate_cache) {
3191 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3192 } else if (bs->file) {
3193 bdrv_invalidate_cache(bs->file, &local_err);
3195 if (local_err) {
3196 error_propagate(errp, local_err);
3197 return;
3200 ret = refresh_total_sectors(bs, bs->total_sectors);
3201 if (ret < 0) {
3202 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3203 return;
3207 void bdrv_invalidate_cache_all(Error **errp)
3209 BlockDriverState *bs;
3210 Error *local_err = NULL;
3212 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3213 AioContext *aio_context = bdrv_get_aio_context(bs);
3215 aio_context_acquire(aio_context);
3216 bdrv_invalidate_cache(bs, &local_err);
3217 aio_context_release(aio_context);
3218 if (local_err) {
3219 error_propagate(errp, local_err);
3220 return;
3225 /**************************************************************/
3226 /* removable device support */
3229 * Return TRUE if the media is present
3231 int bdrv_is_inserted(BlockDriverState *bs)
3233 BlockDriver *drv = bs->drv;
3235 if (!drv)
3236 return 0;
3237 if (!drv->bdrv_is_inserted)
3238 return 1;
3239 return drv->bdrv_is_inserted(bs);
3243 * Return whether the media changed since the last call to this
3244 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3246 int bdrv_media_changed(BlockDriverState *bs)
3248 BlockDriver *drv = bs->drv;
3250 if (drv && drv->bdrv_media_changed) {
3251 return drv->bdrv_media_changed(bs);
3253 return -ENOTSUP;
3257 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3259 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3261 BlockDriver *drv = bs->drv;
3262 const char *device_name;
3264 if (drv && drv->bdrv_eject) {
3265 drv->bdrv_eject(bs, eject_flag);
3268 device_name = bdrv_get_device_name(bs);
3269 if (device_name[0] != '\0') {
3270 qapi_event_send_device_tray_moved(device_name,
3271 eject_flag, &error_abort);
3276 * Lock or unlock the media (if it is locked, the user won't be able
3277 * to eject it manually).
3279 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3281 BlockDriver *drv = bs->drv;
3283 trace_bdrv_lock_medium(bs, locked);
3285 if (drv && drv->bdrv_lock_medium) {
3286 drv->bdrv_lock_medium(bs, locked);
3290 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
3292 bs->guest_block_size = align;
3295 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3297 BdrvDirtyBitmap *bm;
3299 assert(name);
3300 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3301 if (bm->name && !strcmp(name, bm->name)) {
3302 return bm;
3305 return NULL;
3308 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3310 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3311 g_free(bitmap->name);
3312 bitmap->name = NULL;
3315 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3316 uint32_t granularity,
3317 const char *name,
3318 Error **errp)
3320 int64_t bitmap_size;
3321 BdrvDirtyBitmap *bitmap;
3322 uint32_t sector_granularity;
3324 assert((granularity & (granularity - 1)) == 0);
3326 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3327 error_setg(errp, "Bitmap already exists: %s", name);
3328 return NULL;
3330 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3331 assert(sector_granularity);
3332 bitmap_size = bdrv_nb_sectors(bs);
3333 if (bitmap_size < 0) {
3334 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3335 errno = -bitmap_size;
3336 return NULL;
3338 bitmap = g_new0(BdrvDirtyBitmap, 1);
3339 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3340 bitmap->size = bitmap_size;
3341 bitmap->name = g_strdup(name);
3342 bitmap->disabled = false;
3343 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3344 return bitmap;
3347 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3349 return bitmap->successor;
3352 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3354 return !(bitmap->disabled || bitmap->successor);
3357 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3359 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3360 return DIRTY_BITMAP_STATUS_FROZEN;
3361 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3362 return DIRTY_BITMAP_STATUS_DISABLED;
3363 } else {
3364 return DIRTY_BITMAP_STATUS_ACTIVE;
3369 * Create a successor bitmap destined to replace this bitmap after an operation.
3370 * Requires that the bitmap is not frozen and has no successor.
3372 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3373 BdrvDirtyBitmap *bitmap, Error **errp)
3375 uint64_t granularity;
3376 BdrvDirtyBitmap *child;
3378 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3379 error_setg(errp, "Cannot create a successor for a bitmap that is "
3380 "currently frozen");
3381 return -1;
3383 assert(!bitmap->successor);
3385 /* Create an anonymous successor */
3386 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3387 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3388 if (!child) {
3389 return -1;
3392 /* Successor will be on or off based on our current state. */
3393 child->disabled = bitmap->disabled;
3395 /* Install the successor and freeze the parent */
3396 bitmap->successor = child;
3397 return 0;
3401 * For a bitmap with a successor, yield our name to the successor,
3402 * delete the old bitmap, and return a handle to the new bitmap.
3404 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3405 BdrvDirtyBitmap *bitmap,
3406 Error **errp)
3408 char *name;
3409 BdrvDirtyBitmap *successor = bitmap->successor;
3411 if (successor == NULL) {
3412 error_setg(errp, "Cannot relinquish control if "
3413 "there's no successor present");
3414 return NULL;
3417 name = bitmap->name;
3418 bitmap->name = NULL;
3419 successor->name = name;
3420 bitmap->successor = NULL;
3421 bdrv_release_dirty_bitmap(bs, bitmap);
3423 return successor;
3427 * In cases of failure where we can no longer safely delete the parent,
3428 * we may wish to re-join the parent and child/successor.
3429 * The merged parent will be un-frozen, but not explicitly re-enabled.
3431 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3432 BdrvDirtyBitmap *parent,
3433 Error **errp)
3435 BdrvDirtyBitmap *successor = parent->successor;
3437 if (!successor) {
3438 error_setg(errp, "Cannot reclaim a successor when none is present");
3439 return NULL;
3442 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3443 error_setg(errp, "Merging of parent and successor bitmap failed");
3444 return NULL;
3446 bdrv_release_dirty_bitmap(bs, successor);
3447 parent->successor = NULL;
3449 return parent;
3453 * Truncates _all_ bitmaps attached to a BDS.
3455 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3457 BdrvDirtyBitmap *bitmap;
3458 uint64_t size = bdrv_nb_sectors(bs);
3460 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3461 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3462 hbitmap_truncate(bitmap->bitmap, size);
3463 bitmap->size = size;
3467 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3469 BdrvDirtyBitmap *bm, *next;
3470 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3471 if (bm == bitmap) {
3472 assert(!bdrv_dirty_bitmap_frozen(bm));
3473 QLIST_REMOVE(bitmap, list);
3474 hbitmap_free(bitmap->bitmap);
3475 g_free(bitmap->name);
3476 g_free(bitmap);
3477 return;
3482 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3484 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3485 bitmap->disabled = true;
3488 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3490 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3491 bitmap->disabled = false;
3494 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3496 BdrvDirtyBitmap *bm;
3497 BlockDirtyInfoList *list = NULL;
3498 BlockDirtyInfoList **plist = &list;
3500 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3501 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3502 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3503 info->count = bdrv_get_dirty_count(bm);
3504 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3505 info->has_name = !!bm->name;
3506 info->name = g_strdup(bm->name);
3507 info->status = bdrv_dirty_bitmap_status(bm);
3508 entry->value = info;
3509 *plist = entry;
3510 plist = &entry->next;
3513 return list;
3516 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3518 if (bitmap) {
3519 return hbitmap_get(bitmap->bitmap, sector);
3520 } else {
3521 return 0;
3526 * Chooses a default granularity based on the existing cluster size,
3527 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3528 * is no cluster size information available.
3530 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3532 BlockDriverInfo bdi;
3533 uint32_t granularity;
3535 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3536 granularity = MAX(4096, bdi.cluster_size);
3537 granularity = MIN(65536, granularity);
3538 } else {
3539 granularity = 65536;
3542 return granularity;
3545 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3547 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3550 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3552 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3555 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3556 int64_t cur_sector, int nr_sectors)
3558 assert(bdrv_dirty_bitmap_enabled(bitmap));
3559 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3562 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3563 int64_t cur_sector, int nr_sectors)
3565 assert(bdrv_dirty_bitmap_enabled(bitmap));
3566 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3569 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3571 assert(bdrv_dirty_bitmap_enabled(bitmap));
3572 hbitmap_reset_all(bitmap->bitmap);
3575 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3576 int nr_sectors)
3578 BdrvDirtyBitmap *bitmap;
3579 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3580 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3581 continue;
3583 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3588 * Advance an HBitmapIter to an arbitrary offset.
3590 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3592 assert(hbi->hb);
3593 hbitmap_iter_init(hbi, hbi->hb, offset);
3596 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3598 return hbitmap_count(bitmap->bitmap);
3601 /* Get a reference to bs */
3602 void bdrv_ref(BlockDriverState *bs)
3604 bs->refcnt++;
3607 /* Release a previously grabbed reference to bs.
3608 * If after releasing, reference count is zero, the BlockDriverState is
3609 * deleted. */
3610 void bdrv_unref(BlockDriverState *bs)
3612 if (!bs) {
3613 return;
3615 assert(bs->refcnt > 0);
3616 if (--bs->refcnt == 0) {
3617 bdrv_delete(bs);
3621 struct BdrvOpBlocker {
3622 Error *reason;
3623 QLIST_ENTRY(BdrvOpBlocker) list;
3626 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3628 BdrvOpBlocker *blocker;
3629 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3630 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3631 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3632 if (errp) {
3633 error_setg(errp, "Node '%s' is busy: %s",
3634 bdrv_get_device_or_node_name(bs),
3635 error_get_pretty(blocker->reason));
3637 return true;
3639 return false;
3642 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3644 BdrvOpBlocker *blocker;
3645 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3647 blocker = g_new0(BdrvOpBlocker, 1);
3648 blocker->reason = reason;
3649 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3652 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3654 BdrvOpBlocker *blocker, *next;
3655 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3656 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3657 if (blocker->reason == reason) {
3658 QLIST_REMOVE(blocker, list);
3659 g_free(blocker);
3664 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3666 int i;
3667 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3668 bdrv_op_block(bs, i, reason);
3672 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3674 int i;
3675 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3676 bdrv_op_unblock(bs, i, reason);
3680 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3682 int i;
3684 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3685 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3686 return false;
3689 return true;
3692 void bdrv_iostatus_enable(BlockDriverState *bs)
3694 bs->iostatus_enabled = true;
3695 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3698 /* The I/O status is only enabled if the drive explicitly
3699 * enables it _and_ the VM is configured to stop on errors */
3700 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
3702 return (bs->iostatus_enabled &&
3703 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
3704 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
3705 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
3708 void bdrv_iostatus_disable(BlockDriverState *bs)
3710 bs->iostatus_enabled = false;
3713 void bdrv_iostatus_reset(BlockDriverState *bs)
3715 if (bdrv_iostatus_is_enabled(bs)) {
3716 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
3717 if (bs->job) {
3718 block_job_iostatus_reset(bs->job);
3723 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
3725 assert(bdrv_iostatus_is_enabled(bs));
3726 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
3727 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
3728 BLOCK_DEVICE_IO_STATUS_FAILED;
3732 void bdrv_img_create(const char *filename, const char *fmt,
3733 const char *base_filename, const char *base_fmt,
3734 char *options, uint64_t img_size, int flags,
3735 Error **errp, bool quiet)
3737 QemuOptsList *create_opts = NULL;
3738 QemuOpts *opts = NULL;
3739 const char *backing_fmt, *backing_file;
3740 int64_t size;
3741 BlockDriver *drv, *proto_drv;
3742 BlockDriver *backing_drv = NULL;
3743 Error *local_err = NULL;
3744 int ret = 0;
3746 /* Find driver and parse its options */
3747 drv = bdrv_find_format(fmt);
3748 if (!drv) {
3749 error_setg(errp, "Unknown file format '%s'", fmt);
3750 return;
3753 proto_drv = bdrv_find_protocol(filename, true, errp);
3754 if (!proto_drv) {
3755 return;
3758 if (!drv->create_opts) {
3759 error_setg(errp, "Format driver '%s' does not support image creation",
3760 drv->format_name);
3761 return;
3764 if (!proto_drv->create_opts) {
3765 error_setg(errp, "Protocol driver '%s' does not support image creation",
3766 proto_drv->format_name);
3767 return;
3770 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3771 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3773 /* Create parameter list with default values */
3774 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3775 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3777 /* Parse -o options */
3778 if (options) {
3779 qemu_opts_do_parse(opts, options, NULL, &local_err);
3780 if (local_err) {
3781 error_report_err(local_err);
3782 local_err = NULL;
3783 error_setg(errp, "Invalid options for file format '%s'", fmt);
3784 goto out;
3788 if (base_filename) {
3789 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3790 if (local_err) {
3791 error_setg(errp, "Backing file not supported for file format '%s'",
3792 fmt);
3793 goto out;
3797 if (base_fmt) {
3798 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3799 if (local_err) {
3800 error_setg(errp, "Backing file format not supported for file "
3801 "format '%s'", fmt);
3802 goto out;
3806 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3807 if (backing_file) {
3808 if (!strcmp(filename, backing_file)) {
3809 error_setg(errp, "Error: Trying to create an image with the "
3810 "same filename as the backing file");
3811 goto out;
3815 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3816 if (backing_fmt) {
3817 backing_drv = bdrv_find_format(backing_fmt);
3818 if (!backing_drv) {
3819 error_setg(errp, "Unknown backing file format '%s'",
3820 backing_fmt);
3821 goto out;
3825 // The size for the image must always be specified, with one exception:
3826 // If we are using a backing file, we can obtain the size from there
3827 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3828 if (size == -1) {
3829 if (backing_file) {
3830 BlockDriverState *bs;
3831 char *full_backing = g_new0(char, PATH_MAX);
3832 int64_t size;
3833 int back_flags;
3835 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3836 full_backing, PATH_MAX,
3837 &local_err);
3838 if (local_err) {
3839 g_free(full_backing);
3840 goto out;
3843 /* backing files always opened read-only */
3844 back_flags =
3845 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3847 bs = NULL;
3848 ret = bdrv_open(&bs, full_backing, NULL, NULL, back_flags,
3849 backing_drv, &local_err);
3850 g_free(full_backing);
3851 if (ret < 0) {
3852 goto out;
3854 size = bdrv_getlength(bs);
3855 if (size < 0) {
3856 error_setg_errno(errp, -size, "Could not get size of '%s'",
3857 backing_file);
3858 bdrv_unref(bs);
3859 goto out;
3862 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3864 bdrv_unref(bs);
3865 } else {
3866 error_setg(errp, "Image creation needs a size parameter");
3867 goto out;
3871 if (!quiet) {
3872 printf("Formatting '%s', fmt=%s", filename, fmt);
3873 qemu_opts_print(opts, " ");
3874 puts("");
3877 ret = bdrv_create(drv, filename, opts, &local_err);
3879 if (ret == -EFBIG) {
3880 /* This is generally a better message than whatever the driver would
3881 * deliver (especially because of the cluster_size_hint), since that
3882 * is most probably not much different from "image too large". */
3883 const char *cluster_size_hint = "";
3884 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3885 cluster_size_hint = " (try using a larger cluster size)";
3887 error_setg(errp, "The image size is too large for file format '%s'"
3888 "%s", fmt, cluster_size_hint);
3889 error_free(local_err);
3890 local_err = NULL;
3893 out:
3894 qemu_opts_del(opts);
3895 qemu_opts_free(create_opts);
3896 if (local_err) {
3897 error_propagate(errp, local_err);
3901 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3903 return bs->aio_context;
3906 void bdrv_detach_aio_context(BlockDriverState *bs)
3908 BdrvAioNotifier *baf;
3910 if (!bs->drv) {
3911 return;
3914 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3915 baf->detach_aio_context(baf->opaque);
3918 if (bs->io_limits_enabled) {
3919 throttle_timers_detach_aio_context(&bs->throttle_timers);
3921 if (bs->drv->bdrv_detach_aio_context) {
3922 bs->drv->bdrv_detach_aio_context(bs);
3924 if (bs->file) {
3925 bdrv_detach_aio_context(bs->file);
3927 if (bs->backing_hd) {
3928 bdrv_detach_aio_context(bs->backing_hd);
3931 bs->aio_context = NULL;
3934 void bdrv_attach_aio_context(BlockDriverState *bs,
3935 AioContext *new_context)
3937 BdrvAioNotifier *ban;
3939 if (!bs->drv) {
3940 return;
3943 bs->aio_context = new_context;
3945 if (bs->backing_hd) {
3946 bdrv_attach_aio_context(bs->backing_hd, new_context);
3948 if (bs->file) {
3949 bdrv_attach_aio_context(bs->file, new_context);
3951 if (bs->drv->bdrv_attach_aio_context) {
3952 bs->drv->bdrv_attach_aio_context(bs, new_context);
3954 if (bs->io_limits_enabled) {
3955 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3958 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3959 ban->attached_aio_context(new_context, ban->opaque);
3963 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3965 bdrv_drain(bs); /* ensure there are no in-flight requests */
3967 bdrv_detach_aio_context(bs);
3969 /* This function executes in the old AioContext so acquire the new one in
3970 * case it runs in a different thread.
3972 aio_context_acquire(new_context);
3973 bdrv_attach_aio_context(bs, new_context);
3974 aio_context_release(new_context);
3977 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3978 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3979 void (*detach_aio_context)(void *opaque), void *opaque)
3981 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3982 *ban = (BdrvAioNotifier){
3983 .attached_aio_context = attached_aio_context,
3984 .detach_aio_context = detach_aio_context,
3985 .opaque = opaque
3988 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3991 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3992 void (*attached_aio_context)(AioContext *,
3993 void *),
3994 void (*detach_aio_context)(void *),
3995 void *opaque)
3997 BdrvAioNotifier *ban, *ban_next;
3999 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4000 if (ban->attached_aio_context == attached_aio_context &&
4001 ban->detach_aio_context == detach_aio_context &&
4002 ban->opaque == opaque)
4004 QLIST_REMOVE(ban, list);
4005 g_free(ban);
4007 return;
4011 abort();
4014 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4015 BlockDriverAmendStatusCB *status_cb)
4017 if (!bs->drv->bdrv_amend_options) {
4018 return -ENOTSUP;
4020 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
4023 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4024 * of block filter and by bdrv_is_first_non_filter.
4025 * It is used to test if the given bs is the candidate or recurse more in the
4026 * node graph.
4028 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4029 BlockDriverState *candidate)
4031 /* return false if basic checks fails */
4032 if (!bs || !bs->drv) {
4033 return false;
4036 /* the code reached a non block filter driver -> check if the bs is
4037 * the same as the candidate. It's the recursion termination condition.
4039 if (!bs->drv->is_filter) {
4040 return bs == candidate;
4042 /* Down this path the driver is a block filter driver */
4044 /* If the block filter recursion method is defined use it to recurse down
4045 * the node graph.
4047 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4048 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4051 /* the driver is a block filter but don't allow to recurse -> return false
4053 return false;
4056 /* This function checks if the candidate is the first non filter bs down it's
4057 * bs chain. Since we don't have pointers to parents it explore all bs chains
4058 * from the top. Some filters can choose not to pass down the recursion.
4060 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4062 BlockDriverState *bs;
4064 /* walk down the bs forest recursively */
4065 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4066 bool perm;
4068 /* try to recurse in this top level bs */
4069 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4071 /* candidate is the first non filter */
4072 if (perm) {
4073 return true;
4077 return false;
4080 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
4082 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4083 AioContext *aio_context;
4085 if (!to_replace_bs) {
4086 error_setg(errp, "Node name '%s' not found", node_name);
4087 return NULL;
4090 aio_context = bdrv_get_aio_context(to_replace_bs);
4091 aio_context_acquire(aio_context);
4093 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4094 to_replace_bs = NULL;
4095 goto out;
4098 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4099 * most non filter in order to prevent data corruption.
4100 * Another benefit is that this tests exclude backing files which are
4101 * blocked by the backing blockers.
4103 if (!bdrv_is_first_non_filter(to_replace_bs)) {
4104 error_setg(errp, "Only top most non filter can be replaced");
4105 to_replace_bs = NULL;
4106 goto out;
4109 out:
4110 aio_context_release(aio_context);
4111 return to_replace_bs;
4114 static bool append_open_options(QDict *d, BlockDriverState *bs)
4116 const QDictEntry *entry;
4117 bool found_any = false;
4119 for (entry = qdict_first(bs->options); entry;
4120 entry = qdict_next(bs->options, entry))
4122 /* Only take options for this level and exclude all non-driver-specific
4123 * options */
4124 if (!strchr(qdict_entry_key(entry), '.') &&
4125 strcmp(qdict_entry_key(entry), "node-name"))
4127 qobject_incref(qdict_entry_value(entry));
4128 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4129 found_any = true;
4133 return found_any;
4136 /* Updates the following BDS fields:
4137 * - exact_filename: A filename which may be used for opening a block device
4138 * which (mostly) equals the given BDS (even without any
4139 * other options; so reading and writing must return the same
4140 * results, but caching etc. may be different)
4141 * - full_open_options: Options which, when given when opening a block device
4142 * (without a filename), result in a BDS (mostly)
4143 * equalling the given one
4144 * - filename: If exact_filename is set, it is copied here. Otherwise,
4145 * full_open_options is converted to a JSON object, prefixed with
4146 * "json:" (for use through the JSON pseudo protocol) and put here.
4148 void bdrv_refresh_filename(BlockDriverState *bs)
4150 BlockDriver *drv = bs->drv;
4151 QDict *opts;
4153 if (!drv) {
4154 return;
4157 /* This BDS's file name will most probably depend on its file's name, so
4158 * refresh that first */
4159 if (bs->file) {
4160 bdrv_refresh_filename(bs->file);
4163 if (drv->bdrv_refresh_filename) {
4164 /* Obsolete information is of no use here, so drop the old file name
4165 * information before refreshing it */
4166 bs->exact_filename[0] = '\0';
4167 if (bs->full_open_options) {
4168 QDECREF(bs->full_open_options);
4169 bs->full_open_options = NULL;
4172 drv->bdrv_refresh_filename(bs);
4173 } else if (bs->file) {
4174 /* Try to reconstruct valid information from the underlying file */
4175 bool has_open_options;
4177 bs->exact_filename[0] = '\0';
4178 if (bs->full_open_options) {
4179 QDECREF(bs->full_open_options);
4180 bs->full_open_options = NULL;
4183 opts = qdict_new();
4184 has_open_options = append_open_options(opts, bs);
4186 /* If no specific options have been given for this BDS, the filename of
4187 * the underlying file should suffice for this one as well */
4188 if (bs->file->exact_filename[0] && !has_open_options) {
4189 strcpy(bs->exact_filename, bs->file->exact_filename);
4191 /* Reconstructing the full options QDict is simple for most format block
4192 * drivers, as long as the full options are known for the underlying
4193 * file BDS. The full options QDict of that file BDS should somehow
4194 * contain a representation of the filename, therefore the following
4195 * suffices without querying the (exact_)filename of this BDS. */
4196 if (bs->file->full_open_options) {
4197 qdict_put_obj(opts, "driver",
4198 QOBJECT(qstring_from_str(drv->format_name)));
4199 QINCREF(bs->file->full_open_options);
4200 qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
4202 bs->full_open_options = opts;
4203 } else {
4204 QDECREF(opts);
4206 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4207 /* There is no underlying file BDS (at least referenced by BDS.file),
4208 * so the full options QDict should be equal to the options given
4209 * specifically for this block device when it was opened (plus the
4210 * driver specification).
4211 * Because those options don't change, there is no need to update
4212 * full_open_options when it's already set. */
4214 opts = qdict_new();
4215 append_open_options(opts, bs);
4216 qdict_put_obj(opts, "driver",
4217 QOBJECT(qstring_from_str(drv->format_name)));
4219 if (bs->exact_filename[0]) {
4220 /* This may not work for all block protocol drivers (some may
4221 * require this filename to be parsed), but we have to find some
4222 * default solution here, so just include it. If some block driver
4223 * does not support pure options without any filename at all or
4224 * needs some special format of the options QDict, it needs to
4225 * implement the driver-specific bdrv_refresh_filename() function.
4227 qdict_put_obj(opts, "filename",
4228 QOBJECT(qstring_from_str(bs->exact_filename)));
4231 bs->full_open_options = opts;
4234 if (bs->exact_filename[0]) {
4235 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4236 } else if (bs->full_open_options) {
4237 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4238 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4239 qstring_get_str(json));
4240 QDECREF(json);
4244 /* This accessor function purpose is to allow the device models to access the
4245 * BlockAcctStats structure embedded inside a BlockDriverState without being
4246 * aware of the BlockDriverState structure layout.
4247 * It will go away when the BlockAcctStats structure will be moved inside
4248 * the device models.
4250 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)
4252 return &bs->stats;