linux-user: Fix TARGET_MTIOCTOP/MTIOCGET/MTIOCPOS values
[qemu/ar7.git] / block.c
blob46eb1728dabad8f7a9353340fd50425fe437ed04
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 "qemu/osdep.h"
25 #include "block/trace.h"
26 #include "block/block_int.h"
27 #include "block/blockjob.h"
28 #include "block/nbd.h"
29 #include "qemu/error-report.h"
30 #include "module_block.h"
31 #include "qemu/module.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/qmp/qbool.h"
34 #include "qapi/qmp/qjson.h"
35 #include "sysemu/block-backend.h"
36 #include "sysemu/sysemu.h"
37 #include "qemu/notify.h"
38 #include "qemu/coroutine.h"
39 #include "block/qapi.h"
40 #include "qmp-commands.h"
41 #include "qemu/timer.h"
42 #include "qapi-event.h"
43 #include "qemu/cutils.h"
44 #include "qemu/id.h"
46 #ifdef CONFIG_BSD
47 #include <sys/ioctl.h>
48 #include <sys/queue.h>
49 #ifndef __DragonFly__
50 #include <sys/disk.h>
51 #endif
52 #endif
54 #ifdef _WIN32
55 #include <windows.h>
56 #endif
58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
60 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
61 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
63 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
64 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
66 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
67 QLIST_HEAD_INITIALIZER(bdrv_drivers);
69 static BlockDriverState *bdrv_open_inherit(const char *filename,
70 const char *reference,
71 QDict *options, int flags,
72 BlockDriverState *parent,
73 const BdrvChildRole *child_role,
74 Error **errp);
76 /* If non-zero, use only whitelisted block drivers */
77 static int use_bdrv_whitelist;
79 #ifdef _WIN32
80 static int is_windows_drive_prefix(const char *filename)
82 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
83 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
84 filename[1] == ':');
87 int is_windows_drive(const char *filename)
89 if (is_windows_drive_prefix(filename) &&
90 filename[2] == '\0')
91 return 1;
92 if (strstart(filename, "\\\\.\\", NULL) ||
93 strstart(filename, "//./", NULL))
94 return 1;
95 return 0;
97 #endif
99 size_t bdrv_opt_mem_align(BlockDriverState *bs)
101 if (!bs || !bs->drv) {
102 /* page size or 4k (hdd sector size) should be on the safe side */
103 return MAX(4096, getpagesize());
106 return bs->bl.opt_mem_alignment;
109 size_t bdrv_min_mem_align(BlockDriverState *bs)
111 if (!bs || !bs->drv) {
112 /* page size or 4k (hdd sector size) should be on the safe side */
113 return MAX(4096, getpagesize());
116 return bs->bl.min_mem_alignment;
119 /* check if the path starts with "<protocol>:" */
120 int path_has_protocol(const char *path)
122 const char *p;
124 #ifdef _WIN32
125 if (is_windows_drive(path) ||
126 is_windows_drive_prefix(path)) {
127 return 0;
129 p = path + strcspn(path, ":/\\");
130 #else
131 p = path + strcspn(path, ":/");
132 #endif
134 return *p == ':';
137 int path_is_absolute(const char *path)
139 #ifdef _WIN32
140 /* specific case for names like: "\\.\d:" */
141 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
142 return 1;
144 return (*path == '/' || *path == '\\');
145 #else
146 return (*path == '/');
147 #endif
150 /* if filename is absolute, just copy it to dest. Otherwise, build a
151 path to it by considering it is relative to base_path. URL are
152 supported. */
153 void path_combine(char *dest, int dest_size,
154 const char *base_path,
155 const char *filename)
157 const char *p, *p1;
158 int len;
160 if (dest_size <= 0)
161 return;
162 if (path_is_absolute(filename)) {
163 pstrcpy(dest, dest_size, filename);
164 } else {
165 const char *protocol_stripped = NULL;
167 if (path_has_protocol(base_path)) {
168 protocol_stripped = strchr(base_path, ':');
169 if (protocol_stripped) {
170 protocol_stripped++;
173 p = protocol_stripped ?: base_path;
175 p1 = strrchr(base_path, '/');
176 #ifdef _WIN32
178 const char *p2;
179 p2 = strrchr(base_path, '\\');
180 if (!p1 || p2 > p1)
181 p1 = p2;
183 #endif
184 if (p1)
185 p1++;
186 else
187 p1 = base_path;
188 if (p1 > p)
189 p = p1;
190 len = p - base_path;
191 if (len > dest_size - 1)
192 len = dest_size - 1;
193 memcpy(dest, base_path, len);
194 dest[len] = '\0';
195 pstrcat(dest, dest_size, filename);
200 * Helper function for bdrv_parse_filename() implementations to remove optional
201 * protocol prefixes (especially "file:") from a filename and for putting the
202 * stripped filename into the options QDict if there is such a prefix.
204 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix,
205 QDict *options)
207 if (strstart(filename, prefix, &filename)) {
208 /* Stripping the explicit protocol prefix may result in a protocol
209 * prefix being (wrongly) detected (if the filename contains a colon) */
210 if (path_has_protocol(filename)) {
211 QString *fat_filename;
213 /* This means there is some colon before the first slash; therefore,
214 * this cannot be an absolute path */
215 assert(!path_is_absolute(filename));
217 /* And we can thus fix the protocol detection issue by prefixing it
218 * by "./" */
219 fat_filename = qstring_from_str("./");
220 qstring_append(fat_filename, filename);
222 assert(!path_has_protocol(qstring_get_str(fat_filename)));
224 qdict_put(options, "filename", fat_filename);
225 } else {
226 /* If no protocol prefix was detected, we can use the shortened
227 * filename as-is */
228 qdict_put_str(options, "filename", filename);
234 /* Returns whether the image file is opened as read-only. Note that this can
235 * return false and writing to the image file is still not possible because the
236 * image is inactivated. */
237 bool bdrv_is_read_only(BlockDriverState *bs)
239 return bs->read_only;
242 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
243 bool ignore_allow_rdw, Error **errp)
245 /* Do not set read_only if copy_on_read is enabled */
246 if (bs->copy_on_read && read_only) {
247 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
248 bdrv_get_device_or_node_name(bs));
249 return -EINVAL;
252 /* Do not clear read_only if it is prohibited */
253 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&
254 !ignore_allow_rdw)
256 error_setg(errp, "Node '%s' is read only",
257 bdrv_get_device_or_node_name(bs));
258 return -EPERM;
261 return 0;
264 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
266 int ret = 0;
268 ret = bdrv_can_set_read_only(bs, read_only, false, errp);
269 if (ret < 0) {
270 return ret;
273 bs->read_only = read_only;
274 return 0;
277 void bdrv_get_full_backing_filename_from_filename(const char *backed,
278 const char *backing,
279 char *dest, size_t sz,
280 Error **errp)
282 if (backing[0] == '\0' || path_has_protocol(backing) ||
283 path_is_absolute(backing))
285 pstrcpy(dest, sz, backing);
286 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
287 error_setg(errp, "Cannot use relative backing file names for '%s'",
288 backed);
289 } else {
290 path_combine(dest, sz, backed, backing);
294 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
295 Error **errp)
297 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
299 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
300 dest, sz, errp);
303 void bdrv_register(BlockDriver *bdrv)
305 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
308 BlockDriverState *bdrv_new(void)
310 BlockDriverState *bs;
311 int i;
313 bs = g_new0(BlockDriverState, 1);
314 QLIST_INIT(&bs->dirty_bitmaps);
315 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
316 QLIST_INIT(&bs->op_blockers[i]);
318 notifier_with_return_list_init(&bs->before_write_notifiers);
319 qemu_co_mutex_init(&bs->reqs_lock);
320 qemu_mutex_init(&bs->dirty_bitmap_mutex);
321 bs->refcnt = 1;
322 bs->aio_context = qemu_get_aio_context();
324 qemu_co_queue_init(&bs->flush_queue);
326 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
328 return bs;
331 static BlockDriver *bdrv_do_find_format(const char *format_name)
333 BlockDriver *drv1;
335 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
336 if (!strcmp(drv1->format_name, format_name)) {
337 return drv1;
341 return NULL;
344 BlockDriver *bdrv_find_format(const char *format_name)
346 BlockDriver *drv1;
347 int i;
349 drv1 = bdrv_do_find_format(format_name);
350 if (drv1) {
351 return drv1;
354 /* The driver isn't registered, maybe we need to load a module */
355 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
356 if (!strcmp(block_driver_modules[i].format_name, format_name)) {
357 block_module_load_one(block_driver_modules[i].library_name);
358 break;
362 return bdrv_do_find_format(format_name);
365 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
367 static const char *whitelist_rw[] = {
368 CONFIG_BDRV_RW_WHITELIST
370 static const char *whitelist_ro[] = {
371 CONFIG_BDRV_RO_WHITELIST
373 const char **p;
375 if (!whitelist_rw[0] && !whitelist_ro[0]) {
376 return 1; /* no whitelist, anything goes */
379 for (p = whitelist_rw; *p; p++) {
380 if (!strcmp(drv->format_name, *p)) {
381 return 1;
384 if (read_only) {
385 for (p = whitelist_ro; *p; p++) {
386 if (!strcmp(drv->format_name, *p)) {
387 return 1;
391 return 0;
394 bool bdrv_uses_whitelist(void)
396 return use_bdrv_whitelist;
399 typedef struct CreateCo {
400 BlockDriver *drv;
401 char *filename;
402 QemuOpts *opts;
403 int ret;
404 Error *err;
405 } CreateCo;
407 static void coroutine_fn bdrv_create_co_entry(void *opaque)
409 Error *local_err = NULL;
410 int ret;
412 CreateCo *cco = opaque;
413 assert(cco->drv);
415 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
416 error_propagate(&cco->err, local_err);
417 cco->ret = ret;
420 int bdrv_create(BlockDriver *drv, const char* filename,
421 QemuOpts *opts, Error **errp)
423 int ret;
425 Coroutine *co;
426 CreateCo cco = {
427 .drv = drv,
428 .filename = g_strdup(filename),
429 .opts = opts,
430 .ret = NOT_DONE,
431 .err = NULL,
434 if (!drv->bdrv_create) {
435 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
436 ret = -ENOTSUP;
437 goto out;
440 if (qemu_in_coroutine()) {
441 /* Fast-path if already in coroutine context */
442 bdrv_create_co_entry(&cco);
443 } else {
444 co = qemu_coroutine_create(bdrv_create_co_entry, &cco);
445 qemu_coroutine_enter(co);
446 while (cco.ret == NOT_DONE) {
447 aio_poll(qemu_get_aio_context(), true);
451 ret = cco.ret;
452 if (ret < 0) {
453 if (cco.err) {
454 error_propagate(errp, cco.err);
455 } else {
456 error_setg_errno(errp, -ret, "Could not create image");
460 out:
461 g_free(cco.filename);
462 return ret;
465 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
467 BlockDriver *drv;
468 Error *local_err = NULL;
469 int ret;
471 drv = bdrv_find_protocol(filename, true, errp);
472 if (drv == NULL) {
473 return -ENOENT;
476 ret = bdrv_create(drv, filename, opts, &local_err);
477 error_propagate(errp, local_err);
478 return ret;
482 * Try to get @bs's logical and physical block size.
483 * On success, store them in @bsz struct and return 0.
484 * On failure return -errno.
485 * @bs must not be empty.
487 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
489 BlockDriver *drv = bs->drv;
491 if (drv && drv->bdrv_probe_blocksizes) {
492 return drv->bdrv_probe_blocksizes(bs, bsz);
493 } else if (drv && drv->is_filter && bs->file) {
494 return bdrv_probe_blocksizes(bs->file->bs, bsz);
497 return -ENOTSUP;
501 * Try to get @bs's geometry (cyls, heads, sectors).
502 * On success, store them in @geo struct and return 0.
503 * On failure return -errno.
504 * @bs must not be empty.
506 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
508 BlockDriver *drv = bs->drv;
510 if (drv && drv->bdrv_probe_geometry) {
511 return drv->bdrv_probe_geometry(bs, geo);
512 } else if (drv && drv->is_filter && bs->file) {
513 return bdrv_probe_geometry(bs->file->bs, geo);
516 return -ENOTSUP;
520 * Create a uniquely-named empty temporary file.
521 * Return 0 upon success, otherwise a negative errno value.
523 int get_tmp_filename(char *filename, int size)
525 #ifdef _WIN32
526 char temp_dir[MAX_PATH];
527 /* GetTempFileName requires that its output buffer (4th param)
528 have length MAX_PATH or greater. */
529 assert(size >= MAX_PATH);
530 return (GetTempPath(MAX_PATH, temp_dir)
531 && GetTempFileName(temp_dir, "qem", 0, filename)
532 ? 0 : -GetLastError());
533 #else
534 int fd;
535 const char *tmpdir;
536 tmpdir = getenv("TMPDIR");
537 if (!tmpdir) {
538 tmpdir = "/var/tmp";
540 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
541 return -EOVERFLOW;
543 fd = mkstemp(filename);
544 if (fd < 0) {
545 return -errno;
547 if (close(fd) != 0) {
548 unlink(filename);
549 return -errno;
551 return 0;
552 #endif
556 * Detect host devices. By convention, /dev/cdrom[N] is always
557 * recognized as a host CDROM.
559 static BlockDriver *find_hdev_driver(const char *filename)
561 int score_max = 0, score;
562 BlockDriver *drv = NULL, *d;
564 QLIST_FOREACH(d, &bdrv_drivers, list) {
565 if (d->bdrv_probe_device) {
566 score = d->bdrv_probe_device(filename);
567 if (score > score_max) {
568 score_max = score;
569 drv = d;
574 return drv;
577 static BlockDriver *bdrv_do_find_protocol(const char *protocol)
579 BlockDriver *drv1;
581 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
582 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) {
583 return drv1;
587 return NULL;
590 BlockDriver *bdrv_find_protocol(const char *filename,
591 bool allow_protocol_prefix,
592 Error **errp)
594 BlockDriver *drv1;
595 char protocol[128];
596 int len;
597 const char *p;
598 int i;
600 /* TODO Drivers without bdrv_file_open must be specified explicitly */
603 * XXX(hch): we really should not let host device detection
604 * override an explicit protocol specification, but moving this
605 * later breaks access to device names with colons in them.
606 * Thanks to the brain-dead persistent naming schemes on udev-
607 * based Linux systems those actually are quite common.
609 drv1 = find_hdev_driver(filename);
610 if (drv1) {
611 return drv1;
614 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
615 return &bdrv_file;
618 p = strchr(filename, ':');
619 assert(p != NULL);
620 len = p - filename;
621 if (len > sizeof(protocol) - 1)
622 len = sizeof(protocol) - 1;
623 memcpy(protocol, filename, len);
624 protocol[len] = '\0';
626 drv1 = bdrv_do_find_protocol(protocol);
627 if (drv1) {
628 return drv1;
631 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) {
632 if (block_driver_modules[i].protocol_name &&
633 !strcmp(block_driver_modules[i].protocol_name, protocol)) {
634 block_module_load_one(block_driver_modules[i].library_name);
635 break;
639 drv1 = bdrv_do_find_protocol(protocol);
640 if (!drv1) {
641 error_setg(errp, "Unknown protocol '%s'", protocol);
643 return drv1;
647 * Guess image format by probing its contents.
648 * This is not a good idea when your image is raw (CVE-2008-2004), but
649 * we do it anyway for backward compatibility.
651 * @buf contains the image's first @buf_size bytes.
652 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
653 * but can be smaller if the image file is smaller)
654 * @filename is its filename.
656 * For all block drivers, call the bdrv_probe() method to get its
657 * probing score.
658 * Return the first block driver with the highest probing score.
660 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
661 const char *filename)
663 int score_max = 0, score;
664 BlockDriver *drv = NULL, *d;
666 QLIST_FOREACH(d, &bdrv_drivers, list) {
667 if (d->bdrv_probe) {
668 score = d->bdrv_probe(buf, buf_size, filename);
669 if (score > score_max) {
670 score_max = score;
671 drv = d;
676 return drv;
679 static int find_image_format(BlockBackend *file, const char *filename,
680 BlockDriver **pdrv, Error **errp)
682 BlockDriver *drv;
683 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
684 int ret = 0;
686 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
687 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
688 *pdrv = &bdrv_raw;
689 return ret;
692 ret = blk_pread(file, 0, buf, sizeof(buf));
693 if (ret < 0) {
694 error_setg_errno(errp, -ret, "Could not read image for determining its "
695 "format");
696 *pdrv = NULL;
697 return ret;
700 drv = bdrv_probe_all(buf, ret, filename);
701 if (!drv) {
702 error_setg(errp, "Could not determine image format: No compatible "
703 "driver found");
704 ret = -ENOENT;
706 *pdrv = drv;
707 return ret;
711 * Set the current 'total_sectors' value
712 * Return 0 on success, -errno on error.
714 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
716 BlockDriver *drv = bs->drv;
718 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
719 if (bdrv_is_sg(bs))
720 return 0;
722 /* query actual device if possible, otherwise just trust the hint */
723 if (drv->bdrv_getlength) {
724 int64_t length = drv->bdrv_getlength(bs);
725 if (length < 0) {
726 return length;
728 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
731 bs->total_sectors = hint;
732 return 0;
736 * Combines a QDict of new block driver @options with any missing options taken
737 * from @old_options, so that leaving out an option defaults to its old value.
739 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
740 QDict *old_options)
742 if (bs->drv && bs->drv->bdrv_join_options) {
743 bs->drv->bdrv_join_options(options, old_options);
744 } else {
745 qdict_join(options, old_options, false);
750 * Set open flags for a given discard mode
752 * Return 0 on success, -1 if the discard mode was invalid.
754 int bdrv_parse_discard_flags(const char *mode, int *flags)
756 *flags &= ~BDRV_O_UNMAP;
758 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
759 /* do nothing */
760 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
761 *flags |= BDRV_O_UNMAP;
762 } else {
763 return -1;
766 return 0;
770 * Set open flags for a given cache mode
772 * Return 0 on success, -1 if the cache mode was invalid.
774 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough)
776 *flags &= ~BDRV_O_CACHE_MASK;
778 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
779 *writethrough = false;
780 *flags |= BDRV_O_NOCACHE;
781 } else if (!strcmp(mode, "directsync")) {
782 *writethrough = true;
783 *flags |= BDRV_O_NOCACHE;
784 } else if (!strcmp(mode, "writeback")) {
785 *writethrough = false;
786 } else if (!strcmp(mode, "unsafe")) {
787 *writethrough = false;
788 *flags |= BDRV_O_NO_FLUSH;
789 } else if (!strcmp(mode, "writethrough")) {
790 *writethrough = true;
791 } else {
792 return -1;
795 return 0;
798 static char *bdrv_child_get_parent_desc(BdrvChild *c)
800 BlockDriverState *parent = c->opaque;
801 return g_strdup(bdrv_get_device_or_node_name(parent));
804 static void bdrv_child_cb_drained_begin(BdrvChild *child)
806 BlockDriverState *bs = child->opaque;
807 bdrv_drained_begin(bs);
810 static void bdrv_child_cb_drained_end(BdrvChild *child)
812 BlockDriverState *bs = child->opaque;
813 bdrv_drained_end(bs);
816 static int bdrv_child_cb_inactivate(BdrvChild *child)
818 BlockDriverState *bs = child->opaque;
819 assert(bs->open_flags & BDRV_O_INACTIVE);
820 return 0;
824 * Returns the options and flags that a temporary snapshot should get, based on
825 * the originally requested flags (the originally requested image will have
826 * flags like a backing file)
828 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
829 int parent_flags, QDict *parent_options)
831 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
833 /* For temporary files, unconditional cache=unsafe is fine */
834 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
835 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
837 /* Copy the read-only option from the parent */
838 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
840 /* aio=native doesn't work for cache.direct=off, so disable it for the
841 * temporary snapshot */
842 *child_flags &= ~BDRV_O_NATIVE_AIO;
846 * Returns the options and flags that bs->file should get if a protocol driver
847 * is expected, based on the given options and flags for the parent BDS
849 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
850 int parent_flags, QDict *parent_options)
852 int flags = parent_flags;
854 /* Enable protocol handling, disable format probing for bs->file */
855 flags |= BDRV_O_PROTOCOL;
857 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
858 * the parent. */
859 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
860 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
861 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
863 /* Inherit the read-only option from the parent if it's not set */
864 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
866 /* Our block drivers take care to send flushes and respect unmap policy,
867 * so we can default to enable both on lower layers regardless of the
868 * corresponding parent options. */
869 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap");
871 /* Clear flags that only apply to the top layer */
872 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ |
873 BDRV_O_NO_IO);
875 *child_flags = flags;
878 const BdrvChildRole child_file = {
879 .get_parent_desc = bdrv_child_get_parent_desc,
880 .inherit_options = bdrv_inherited_options,
881 .drained_begin = bdrv_child_cb_drained_begin,
882 .drained_end = bdrv_child_cb_drained_end,
883 .inactivate = bdrv_child_cb_inactivate,
887 * Returns the options and flags that bs->file should get if the use of formats
888 * (and not only protocols) is permitted for it, based on the given options and
889 * flags for the parent BDS
891 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
892 int parent_flags, QDict *parent_options)
894 child_file.inherit_options(child_flags, child_options,
895 parent_flags, parent_options);
897 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO);
900 const BdrvChildRole child_format = {
901 .get_parent_desc = bdrv_child_get_parent_desc,
902 .inherit_options = bdrv_inherited_fmt_options,
903 .drained_begin = bdrv_child_cb_drained_begin,
904 .drained_end = bdrv_child_cb_drained_end,
905 .inactivate = bdrv_child_cb_inactivate,
908 static void bdrv_backing_attach(BdrvChild *c)
910 BlockDriverState *parent = c->opaque;
911 BlockDriverState *backing_hd = c->bs;
913 assert(!parent->backing_blocker);
914 error_setg(&parent->backing_blocker,
915 "node is used as backing hd of '%s'",
916 bdrv_get_device_or_node_name(parent));
918 parent->open_flags &= ~BDRV_O_NO_BACKING;
919 pstrcpy(parent->backing_file, sizeof(parent->backing_file),
920 backing_hd->filename);
921 pstrcpy(parent->backing_format, sizeof(parent->backing_format),
922 backing_hd->drv ? backing_hd->drv->format_name : "");
924 bdrv_op_block_all(backing_hd, parent->backing_blocker);
925 /* Otherwise we won't be able to commit or stream */
926 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
927 parent->backing_blocker);
928 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM,
929 parent->backing_blocker);
931 * We do backup in 3 ways:
932 * 1. drive backup
933 * The target bs is new opened, and the source is top BDS
934 * 2. blockdev backup
935 * Both the source and the target are top BDSes.
936 * 3. internal backup(used for block replication)
937 * Both the source and the target are backing file
939 * In case 1 and 2, neither the source nor the target is the backing file.
940 * In case 3, we will block the top BDS, so there is only one block job
941 * for the top BDS and its backing chain.
943 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE,
944 parent->backing_blocker);
945 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
946 parent->backing_blocker);
949 static void bdrv_backing_detach(BdrvChild *c)
951 BlockDriverState *parent = c->opaque;
953 assert(parent->backing_blocker);
954 bdrv_op_unblock_all(c->bs, parent->backing_blocker);
955 error_free(parent->backing_blocker);
956 parent->backing_blocker = NULL;
960 * Returns the options and flags that bs->backing should get, based on the
961 * given options and flags for the parent BDS
963 static void bdrv_backing_options(int *child_flags, QDict *child_options,
964 int parent_flags, QDict *parent_options)
966 int flags = parent_flags;
968 /* The cache mode is inherited unmodified for backing files; except WCE,
969 * which is only applied on the top level (BlockBackend) */
970 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
971 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
972 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);
974 /* backing files always opened read-only */
975 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
976 flags &= ~BDRV_O_COPY_ON_READ;
978 /* snapshot=on is handled on the top layer */
979 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
981 *child_flags = flags;
984 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base,
985 const char *filename, Error **errp)
987 BlockDriverState *parent = c->opaque;
988 int orig_flags = bdrv_get_flags(parent);
989 int ret;
991 if (!(orig_flags & BDRV_O_RDWR)) {
992 ret = bdrv_reopen(parent, orig_flags | BDRV_O_RDWR, errp);
993 if (ret < 0) {
994 return ret;
998 ret = bdrv_change_backing_file(parent, filename,
999 base->drv ? base->drv->format_name : "");
1000 if (ret < 0) {
1001 error_setg_errno(errp, ret, "Could not update backing file link");
1004 if (!(orig_flags & BDRV_O_RDWR)) {
1005 bdrv_reopen(parent, orig_flags, NULL);
1008 return ret;
1011 const BdrvChildRole child_backing = {
1012 .get_parent_desc = bdrv_child_get_parent_desc,
1013 .attach = bdrv_backing_attach,
1014 .detach = bdrv_backing_detach,
1015 .inherit_options = bdrv_backing_options,
1016 .drained_begin = bdrv_child_cb_drained_begin,
1017 .drained_end = bdrv_child_cb_drained_end,
1018 .inactivate = bdrv_child_cb_inactivate,
1019 .update_filename = bdrv_backing_update_filename,
1022 static int bdrv_open_flags(BlockDriverState *bs, int flags)
1024 int open_flags = flags;
1027 * Clear flags that are internal to the block layer before opening the
1028 * image.
1030 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
1033 * Snapshots should be writable.
1035 if (flags & BDRV_O_TEMPORARY) {
1036 open_flags |= BDRV_O_RDWR;
1039 return open_flags;
1042 static void update_flags_from_options(int *flags, QemuOpts *opts)
1044 *flags &= ~BDRV_O_CACHE_MASK;
1046 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
1047 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
1048 *flags |= BDRV_O_NO_FLUSH;
1051 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
1052 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
1053 *flags |= BDRV_O_NOCACHE;
1056 *flags &= ~BDRV_O_RDWR;
1058 assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY));
1059 if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) {
1060 *flags |= BDRV_O_RDWR;
1065 static void update_options_from_flags(QDict *options, int flags)
1067 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
1068 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE);
1070 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
1071 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH,
1072 flags & BDRV_O_NO_FLUSH);
1074 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) {
1075 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR));
1079 static void bdrv_assign_node_name(BlockDriverState *bs,
1080 const char *node_name,
1081 Error **errp)
1083 char *gen_node_name = NULL;
1085 if (!node_name) {
1086 node_name = gen_node_name = id_generate(ID_BLOCK);
1087 } else if (!id_wellformed(node_name)) {
1089 * Check for empty string or invalid characters, but not if it is
1090 * generated (generated names use characters not available to the user)
1092 error_setg(errp, "Invalid node name");
1093 return;
1096 /* takes care of avoiding namespaces collisions */
1097 if (blk_by_name(node_name)) {
1098 error_setg(errp, "node-name=%s is conflicting with a device id",
1099 node_name);
1100 goto out;
1103 /* takes care of avoiding duplicates node names */
1104 if (bdrv_find_node(node_name)) {
1105 error_setg(errp, "Duplicate node name");
1106 goto out;
1109 /* copy node name into the bs and insert it into the graph list */
1110 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
1111 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
1112 out:
1113 g_free(gen_node_name);
1116 static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
1117 const char *node_name, QDict *options,
1118 int open_flags, Error **errp)
1120 Error *local_err = NULL;
1121 int ret;
1123 bdrv_assign_node_name(bs, node_name, &local_err);
1124 if (local_err) {
1125 error_propagate(errp, local_err);
1126 return -EINVAL;
1129 bs->drv = drv;
1130 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1131 bs->opaque = g_malloc0(drv->instance_size);
1133 if (drv->bdrv_file_open) {
1134 assert(!drv->bdrv_needs_filename || bs->filename[0]);
1135 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1136 } else if (drv->bdrv_open) {
1137 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1138 } else {
1139 ret = 0;
1142 if (ret < 0) {
1143 if (local_err) {
1144 error_propagate(errp, local_err);
1145 } else if (bs->filename[0]) {
1146 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1147 } else {
1148 error_setg_errno(errp, -ret, "Could not open image");
1150 goto open_failed;
1153 ret = refresh_total_sectors(bs, bs->total_sectors);
1154 if (ret < 0) {
1155 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1156 return ret;
1159 bdrv_refresh_limits(bs, &local_err);
1160 if (local_err) {
1161 error_propagate(errp, local_err);
1162 return -EINVAL;
1165 assert(bdrv_opt_mem_align(bs) != 0);
1166 assert(bdrv_min_mem_align(bs) != 0);
1167 assert(is_power_of_2(bs->bl.request_alignment));
1169 return 0;
1170 open_failed:
1171 bs->drv = NULL;
1172 if (bs->file != NULL) {
1173 bdrv_unref_child(bs, bs->file);
1174 bs->file = NULL;
1176 g_free(bs->opaque);
1177 bs->opaque = NULL;
1178 return ret;
1181 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
1182 int flags, Error **errp)
1184 BlockDriverState *bs;
1185 int ret;
1187 bs = bdrv_new();
1188 bs->open_flags = flags;
1189 bs->explicit_options = qdict_new();
1190 bs->options = qdict_new();
1191 bs->opaque = NULL;
1193 update_options_from_flags(bs->options, flags);
1195 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
1196 if (ret < 0) {
1197 QDECREF(bs->explicit_options);
1198 bs->explicit_options = NULL;
1199 QDECREF(bs->options);
1200 bs->options = NULL;
1201 bdrv_unref(bs);
1202 return NULL;
1205 return bs;
1208 QemuOptsList bdrv_runtime_opts = {
1209 .name = "bdrv_common",
1210 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
1211 .desc = {
1213 .name = "node-name",
1214 .type = QEMU_OPT_STRING,
1215 .help = "Node name of the block device node",
1218 .name = "driver",
1219 .type = QEMU_OPT_STRING,
1220 .help = "Block driver to use for the node",
1223 .name = BDRV_OPT_CACHE_DIRECT,
1224 .type = QEMU_OPT_BOOL,
1225 .help = "Bypass software writeback cache on the host",
1228 .name = BDRV_OPT_CACHE_NO_FLUSH,
1229 .type = QEMU_OPT_BOOL,
1230 .help = "Ignore flush requests",
1233 .name = BDRV_OPT_READ_ONLY,
1234 .type = QEMU_OPT_BOOL,
1235 .help = "Node is opened in read-only mode",
1238 .name = "detect-zeroes",
1239 .type = QEMU_OPT_STRING,
1240 .help = "try to optimize zero writes (off, on, unmap)",
1243 .name = "discard",
1244 .type = QEMU_OPT_STRING,
1245 .help = "discard operation (ignore/off, unmap/on)",
1248 .name = BDRV_OPT_FORCE_SHARE,
1249 .type = QEMU_OPT_BOOL,
1250 .help = "always accept other writers (default: off)",
1252 { /* end of list */ }
1257 * Common part for opening disk images and files
1259 * Removes all processed options from *options.
1261 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
1262 QDict *options, Error **errp)
1264 int ret, open_flags;
1265 const char *filename;
1266 const char *driver_name = NULL;
1267 const char *node_name = NULL;
1268 const char *discard;
1269 const char *detect_zeroes;
1270 QemuOpts *opts;
1271 BlockDriver *drv;
1272 Error *local_err = NULL;
1274 assert(bs->file == NULL);
1275 assert(options != NULL && bs->options != options);
1277 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1278 qemu_opts_absorb_qdict(opts, options, &local_err);
1279 if (local_err) {
1280 error_propagate(errp, local_err);
1281 ret = -EINVAL;
1282 goto fail_opts;
1285 update_flags_from_options(&bs->open_flags, opts);
1287 driver_name = qemu_opt_get(opts, "driver");
1288 drv = bdrv_find_format(driver_name);
1289 assert(drv != NULL);
1291 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);
1293 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {
1294 error_setg(errp,
1295 BDRV_OPT_FORCE_SHARE
1296 "=on can only be used with read-only images");
1297 ret = -EINVAL;
1298 goto fail_opts;
1301 if (file != NULL) {
1302 filename = blk_bs(file)->filename;
1303 } else {
1305 * Caution: while qdict_get_try_str() is fine, getting
1306 * non-string types would require more care. When @options
1307 * come from -blockdev or blockdev_add, its members are typed
1308 * according to the QAPI schema, but when they come from
1309 * -drive, they're all QString.
1311 filename = qdict_get_try_str(options, "filename");
1314 if (drv->bdrv_needs_filename && (!filename || !filename[0])) {
1315 error_setg(errp, "The '%s' block driver requires a file name",
1316 drv->format_name);
1317 ret = -EINVAL;
1318 goto fail_opts;
1321 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
1322 drv->format_name);
1324 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
1326 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
1327 error_setg(errp,
1328 !bs->read_only && bdrv_is_whitelisted(drv, true)
1329 ? "Driver '%s' can only be used for read-only devices"
1330 : "Driver '%s' is not whitelisted",
1331 drv->format_name);
1332 ret = -ENOTSUP;
1333 goto fail_opts;
1336 /* bdrv_new() and bdrv_close() make it so */
1337 assert(atomic_read(&bs->copy_on_read) == 0);
1339 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
1340 if (!bs->read_only) {
1341 bdrv_enable_copy_on_read(bs);
1342 } else {
1343 error_setg(errp, "Can't use copy-on-read on read-only device");
1344 ret = -EINVAL;
1345 goto fail_opts;
1349 discard = qemu_opt_get(opts, "discard");
1350 if (discard != NULL) {
1351 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) {
1352 error_setg(errp, "Invalid discard option");
1353 ret = -EINVAL;
1354 goto fail_opts;
1358 detect_zeroes = qemu_opt_get(opts, "detect-zeroes");
1359 if (detect_zeroes) {
1360 BlockdevDetectZeroesOptions value =
1361 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup,
1362 detect_zeroes,
1363 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
1364 &local_err);
1365 if (local_err) {
1366 error_propagate(errp, local_err);
1367 ret = -EINVAL;
1368 goto fail_opts;
1371 if (value == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP &&
1372 !(bs->open_flags & BDRV_O_UNMAP))
1374 error_setg(errp, "setting detect-zeroes to unmap is not allowed "
1375 "without setting discard operation to unmap");
1376 ret = -EINVAL;
1377 goto fail_opts;
1380 bs->detect_zeroes = value;
1383 if (filename != NULL) {
1384 pstrcpy(bs->filename, sizeof(bs->filename), filename);
1385 } else {
1386 bs->filename[0] = '\0';
1388 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
1390 /* Open the image, either directly or using a protocol */
1391 open_flags = bdrv_open_flags(bs, bs->open_flags);
1392 node_name = qemu_opt_get(opts, "node-name");
1394 assert(!drv->bdrv_file_open || file == NULL);
1395 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
1396 if (ret < 0) {
1397 goto fail_opts;
1400 qemu_opts_del(opts);
1401 return 0;
1403 fail_opts:
1404 qemu_opts_del(opts);
1405 return ret;
1408 static QDict *parse_json_filename(const char *filename, Error **errp)
1410 QObject *options_obj;
1411 QDict *options;
1412 int ret;
1414 ret = strstart(filename, "json:", &filename);
1415 assert(ret);
1417 options_obj = qobject_from_json(filename, errp);
1418 if (!options_obj) {
1419 /* Work around qobject_from_json() lossage TODO fix that */
1420 if (errp && !*errp) {
1421 error_setg(errp, "Could not parse the JSON options");
1422 return NULL;
1424 error_prepend(errp, "Could not parse the JSON options: ");
1425 return NULL;
1428 options = qobject_to_qdict(options_obj);
1429 if (!options) {
1430 qobject_decref(options_obj);
1431 error_setg(errp, "Invalid JSON object given");
1432 return NULL;
1435 qdict_flatten(options);
1437 return options;
1440 static void parse_json_protocol(QDict *options, const char **pfilename,
1441 Error **errp)
1443 QDict *json_options;
1444 Error *local_err = NULL;
1446 /* Parse json: pseudo-protocol */
1447 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1448 return;
1451 json_options = parse_json_filename(*pfilename, &local_err);
1452 if (local_err) {
1453 error_propagate(errp, local_err);
1454 return;
1457 /* Options given in the filename have lower priority than options
1458 * specified directly */
1459 qdict_join(options, json_options, false);
1460 QDECREF(json_options);
1461 *pfilename = NULL;
1465 * Fills in default options for opening images and converts the legacy
1466 * filename/flags pair to option QDict entries.
1467 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1468 * block driver has been specified explicitly.
1470 static int bdrv_fill_options(QDict **options, const char *filename,
1471 int *flags, Error **errp)
1473 const char *drvname;
1474 bool protocol = *flags & BDRV_O_PROTOCOL;
1475 bool parse_filename = false;
1476 BlockDriver *drv = NULL;
1477 Error *local_err = NULL;
1480 * Caution: while qdict_get_try_str() is fine, getting non-string
1481 * types would require more care. When @options come from
1482 * -blockdev or blockdev_add, its members are typed according to
1483 * the QAPI schema, but when they come from -drive, they're all
1484 * QString.
1486 drvname = qdict_get_try_str(*options, "driver");
1487 if (drvname) {
1488 drv = bdrv_find_format(drvname);
1489 if (!drv) {
1490 error_setg(errp, "Unknown driver '%s'", drvname);
1491 return -ENOENT;
1493 /* If the user has explicitly specified the driver, this choice should
1494 * override the BDRV_O_PROTOCOL flag */
1495 protocol = drv->bdrv_file_open;
1498 if (protocol) {
1499 *flags |= BDRV_O_PROTOCOL;
1500 } else {
1501 *flags &= ~BDRV_O_PROTOCOL;
1504 /* Translate cache options from flags into options */
1505 update_options_from_flags(*options, *flags);
1507 /* Fetch the file name from the options QDict if necessary */
1508 if (protocol && filename) {
1509 if (!qdict_haskey(*options, "filename")) {
1510 qdict_put_str(*options, "filename", filename);
1511 parse_filename = true;
1512 } else {
1513 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1514 "the same time");
1515 return -EINVAL;
1519 /* Find the right block driver */
1520 /* See cautionary note on accessing @options above */
1521 filename = qdict_get_try_str(*options, "filename");
1523 if (!drvname && protocol) {
1524 if (filename) {
1525 drv = bdrv_find_protocol(filename, parse_filename, errp);
1526 if (!drv) {
1527 return -EINVAL;
1530 drvname = drv->format_name;
1531 qdict_put_str(*options, "driver", drvname);
1532 } else {
1533 error_setg(errp, "Must specify either driver or file");
1534 return -EINVAL;
1538 assert(drv || !protocol);
1540 /* Driver-specific filename parsing */
1541 if (drv && drv->bdrv_parse_filename && parse_filename) {
1542 drv->bdrv_parse_filename(filename, *options, &local_err);
1543 if (local_err) {
1544 error_propagate(errp, local_err);
1545 return -EINVAL;
1548 if (!drv->bdrv_needs_filename) {
1549 qdict_del(*options, "filename");
1553 return 0;
1556 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1557 uint64_t perm, uint64_t shared,
1558 GSList *ignore_children, Error **errp);
1559 static void bdrv_child_abort_perm_update(BdrvChild *c);
1560 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
1562 typedef struct BlockReopenQueueEntry {
1563 bool prepared;
1564 BDRVReopenState state;
1565 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1566 } BlockReopenQueueEntry;
1569 * Return the flags that @bs will have after the reopens in @q have
1570 * successfully completed. If @q is NULL (or @bs is not contained in @q),
1571 * return the current flags.
1573 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs)
1575 BlockReopenQueueEntry *entry;
1577 if (q != NULL) {
1578 QSIMPLEQ_FOREACH(entry, q, entry) {
1579 if (entry->state.bs == bs) {
1580 return entry->state.flags;
1585 return bs->open_flags;
1588 /* Returns whether the image file can be written to after the reopen queue @q
1589 * has been successfully applied, or right now if @q is NULL. */
1590 static bool bdrv_is_writable(BlockDriverState *bs, BlockReopenQueue *q)
1592 int flags = bdrv_reopen_get_flags(q, bs);
1594 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR;
1597 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,
1598 BdrvChild *c, const BdrvChildRole *role,
1599 BlockReopenQueue *reopen_queue,
1600 uint64_t parent_perm, uint64_t parent_shared,
1601 uint64_t *nperm, uint64_t *nshared)
1603 if (bs->drv && bs->drv->bdrv_child_perm) {
1604 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue,
1605 parent_perm, parent_shared,
1606 nperm, nshared);
1608 /* TODO Take force_share from reopen_queue */
1609 if (child_bs && child_bs->force_share) {
1610 *nshared = BLK_PERM_ALL;
1615 * Check whether permissions on this node can be changed in a way that
1616 * @cumulative_perms and @cumulative_shared_perms are the new cumulative
1617 * permissions of all its parents. This involves checking whether all necessary
1618 * permission changes to child nodes can be performed.
1620 * A call to this function must always be followed by a call to bdrv_set_perm()
1621 * or bdrv_abort_perm_update().
1623 static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q,
1624 uint64_t cumulative_perms,
1625 uint64_t cumulative_shared_perms,
1626 GSList *ignore_children, Error **errp)
1628 BlockDriver *drv = bs->drv;
1629 BdrvChild *c;
1630 int ret;
1632 /* Write permissions never work with read-only images */
1633 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&
1634 !bdrv_is_writable(bs, q))
1636 error_setg(errp, "Block node is read-only");
1637 return -EPERM;
1640 /* Check this node */
1641 if (!drv) {
1642 return 0;
1645 if (drv->bdrv_check_perm) {
1646 return drv->bdrv_check_perm(bs, cumulative_perms,
1647 cumulative_shared_perms, errp);
1650 /* Drivers that never have children can omit .bdrv_child_perm() */
1651 if (!drv->bdrv_child_perm) {
1652 assert(QLIST_EMPTY(&bs->children));
1653 return 0;
1656 /* Check all children */
1657 QLIST_FOREACH(c, &bs->children, next) {
1658 uint64_t cur_perm, cur_shared;
1659 bdrv_child_perm(bs, c->bs, c, c->role, q,
1660 cumulative_perms, cumulative_shared_perms,
1661 &cur_perm, &cur_shared);
1662 ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared,
1663 ignore_children, errp);
1664 if (ret < 0) {
1665 return ret;
1669 return 0;
1673 * Notifies drivers that after a previous bdrv_check_perm() call, the
1674 * permission update is not performed and any preparations made for it (e.g.
1675 * taken file locks) need to be undone.
1677 * This function recursively notifies all child nodes.
1679 static void bdrv_abort_perm_update(BlockDriverState *bs)
1681 BlockDriver *drv = bs->drv;
1682 BdrvChild *c;
1684 if (!drv) {
1685 return;
1688 if (drv->bdrv_abort_perm_update) {
1689 drv->bdrv_abort_perm_update(bs);
1692 QLIST_FOREACH(c, &bs->children, next) {
1693 bdrv_child_abort_perm_update(c);
1697 static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
1698 uint64_t cumulative_shared_perms)
1700 BlockDriver *drv = bs->drv;
1701 BdrvChild *c;
1703 if (!drv) {
1704 return;
1707 /* Update this node */
1708 if (drv->bdrv_set_perm) {
1709 drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms);
1712 /* Drivers that never have children can omit .bdrv_child_perm() */
1713 if (!drv->bdrv_child_perm) {
1714 assert(QLIST_EMPTY(&bs->children));
1715 return;
1718 /* Update all children */
1719 QLIST_FOREACH(c, &bs->children, next) {
1720 uint64_t cur_perm, cur_shared;
1721 bdrv_child_perm(bs, c->bs, c, c->role, NULL,
1722 cumulative_perms, cumulative_shared_perms,
1723 &cur_perm, &cur_shared);
1724 bdrv_child_set_perm(c, cur_perm, cur_shared);
1728 static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
1729 uint64_t *shared_perm)
1731 BdrvChild *c;
1732 uint64_t cumulative_perms = 0;
1733 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
1735 QLIST_FOREACH(c, &bs->parents, next_parent) {
1736 cumulative_perms |= c->perm;
1737 cumulative_shared_perms &= c->shared_perm;
1740 *perm = cumulative_perms;
1741 *shared_perm = cumulative_shared_perms;
1744 static char *bdrv_child_user_desc(BdrvChild *c)
1746 if (c->role->get_parent_desc) {
1747 return c->role->get_parent_desc(c);
1750 return g_strdup("another user");
1753 char *bdrv_perm_names(uint64_t perm)
1755 struct perm_name {
1756 uint64_t perm;
1757 const char *name;
1758 } permissions[] = {
1759 { BLK_PERM_CONSISTENT_READ, "consistent read" },
1760 { BLK_PERM_WRITE, "write" },
1761 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" },
1762 { BLK_PERM_RESIZE, "resize" },
1763 { BLK_PERM_GRAPH_MOD, "change children" },
1764 { 0, NULL }
1767 char *result = g_strdup("");
1768 struct perm_name *p;
1770 for (p = permissions; p->name; p++) {
1771 if (perm & p->perm) {
1772 char *old = result;
1773 result = g_strdup_printf("%s%s%s", old, *old ? ", " : "", p->name);
1774 g_free(old);
1778 return result;
1782 * Checks whether a new reference to @bs can be added if the new user requires
1783 * @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is
1784 * set, the BdrvChild objects in this list are ignored in the calculations;
1785 * this allows checking permission updates for an existing reference.
1787 * Needs to be followed by a call to either bdrv_set_perm() or
1788 * bdrv_abort_perm_update(). */
1789 static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q,
1790 uint64_t new_used_perm,
1791 uint64_t new_shared_perm,
1792 GSList *ignore_children, Error **errp)
1794 BdrvChild *c;
1795 uint64_t cumulative_perms = new_used_perm;
1796 uint64_t cumulative_shared_perms = new_shared_perm;
1798 /* There is no reason why anyone couldn't tolerate write_unchanged */
1799 assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED);
1801 QLIST_FOREACH(c, &bs->parents, next_parent) {
1802 if (g_slist_find(ignore_children, c)) {
1803 continue;
1806 if ((new_used_perm & c->shared_perm) != new_used_perm) {
1807 char *user = bdrv_child_user_desc(c);
1808 char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm);
1809 error_setg(errp, "Conflicts with use by %s as '%s', which does not "
1810 "allow '%s' on %s",
1811 user, c->name, perm_names, bdrv_get_node_name(c->bs));
1812 g_free(user);
1813 g_free(perm_names);
1814 return -EPERM;
1817 if ((c->perm & new_shared_perm) != c->perm) {
1818 char *user = bdrv_child_user_desc(c);
1819 char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm);
1820 error_setg(errp, "Conflicts with use by %s as '%s', which uses "
1821 "'%s' on %s",
1822 user, c->name, perm_names, bdrv_get_node_name(c->bs));
1823 g_free(user);
1824 g_free(perm_names);
1825 return -EPERM;
1828 cumulative_perms |= c->perm;
1829 cumulative_shared_perms &= c->shared_perm;
1832 return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms,
1833 ignore_children, errp);
1836 /* Needs to be followed by a call to either bdrv_child_set_perm() or
1837 * bdrv_child_abort_perm_update(). */
1838 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
1839 uint64_t perm, uint64_t shared,
1840 GSList *ignore_children, Error **errp)
1842 int ret;
1844 ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c);
1845 ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, errp);
1846 g_slist_free(ignore_children);
1848 return ret;
1851 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared)
1853 uint64_t cumulative_perms, cumulative_shared_perms;
1855 c->perm = perm;
1856 c->shared_perm = shared;
1858 bdrv_get_cumulative_perm(c->bs, &cumulative_perms,
1859 &cumulative_shared_perms);
1860 bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms);
1863 static void bdrv_child_abort_perm_update(BdrvChild *c)
1865 bdrv_abort_perm_update(c->bs);
1868 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
1869 Error **errp)
1871 int ret;
1873 ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, errp);
1874 if (ret < 0) {
1875 bdrv_child_abort_perm_update(c);
1876 return ret;
1879 bdrv_child_set_perm(c, perm, shared);
1881 return 0;
1884 #define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
1885 | BLK_PERM_WRITE \
1886 | BLK_PERM_WRITE_UNCHANGED \
1887 | BLK_PERM_RESIZE)
1888 #define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
1890 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
1891 const BdrvChildRole *role,
1892 BlockReopenQueue *reopen_queue,
1893 uint64_t perm, uint64_t shared,
1894 uint64_t *nperm, uint64_t *nshared)
1896 if (c == NULL) {
1897 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
1898 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
1899 return;
1902 *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
1903 (c->perm & DEFAULT_PERM_UNCHANGED);
1904 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
1905 (c->shared_perm & DEFAULT_PERM_UNCHANGED);
1908 void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
1909 const BdrvChildRole *role,
1910 BlockReopenQueue *reopen_queue,
1911 uint64_t perm, uint64_t shared,
1912 uint64_t *nperm, uint64_t *nshared)
1914 bool backing = (role == &child_backing);
1915 assert(role == &child_backing || role == &child_file);
1917 if (!backing) {
1918 /* Apart from the modifications below, the same permissions are
1919 * forwarded and left alone as for filters */
1920 bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
1921 &perm, &shared);
1923 /* Format drivers may touch metadata even if the guest doesn't write */
1924 if (bdrv_is_writable(bs, reopen_queue)) {
1925 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1928 /* bs->file always needs to be consistent because of the metadata. We
1929 * can never allow other users to resize or write to it. */
1930 perm |= BLK_PERM_CONSISTENT_READ;
1931 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
1932 } else {
1933 /* We want consistent read from backing files if the parent needs it.
1934 * No other operations are performed on backing files. */
1935 perm &= BLK_PERM_CONSISTENT_READ;
1937 /* If the parent can deal with changing data, we're okay with a
1938 * writable and resizable backing file. */
1939 /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
1940 if (shared & BLK_PERM_WRITE) {
1941 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
1942 } else {
1943 shared = 0;
1946 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
1947 BLK_PERM_WRITE_UNCHANGED;
1950 if (bs->open_flags & BDRV_O_INACTIVE) {
1951 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
1954 *nperm = perm;
1955 *nshared = shared;
1958 static void bdrv_replace_child_noperm(BdrvChild *child,
1959 BlockDriverState *new_bs)
1961 BlockDriverState *old_bs = child->bs;
1963 if (old_bs && new_bs) {
1964 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
1966 if (old_bs) {
1967 if (old_bs->quiesce_counter && child->role->drained_end) {
1968 child->role->drained_end(child);
1970 if (child->role->detach) {
1971 child->role->detach(child);
1973 QLIST_REMOVE(child, next_parent);
1976 child->bs = new_bs;
1978 if (new_bs) {
1979 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
1980 if (new_bs->quiesce_counter && child->role->drained_begin) {
1981 child->role->drained_begin(child);
1984 if (child->role->attach) {
1985 child->role->attach(child);
1991 * Updates @child to change its reference to point to @new_bs, including
1992 * checking and applying the necessary permisson updates both to the old node
1993 * and to @new_bs.
1995 * NULL is passed as @new_bs for removing the reference before freeing @child.
1997 * If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this
1998 * function uses bdrv_set_perm() to update the permissions according to the new
1999 * reference that @new_bs gets.
2001 static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)
2003 BlockDriverState *old_bs = child->bs;
2004 uint64_t perm, shared_perm;
2006 bdrv_replace_child_noperm(child, new_bs);
2008 if (old_bs) {
2009 /* Update permissions for old node. This is guaranteed to succeed
2010 * because we're just taking a parent away, so we're loosening
2011 * restrictions. */
2012 bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm);
2013 bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort);
2014 bdrv_set_perm(old_bs, perm, shared_perm);
2017 if (new_bs) {
2018 bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);
2019 bdrv_set_perm(new_bs, perm, shared_perm);
2023 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
2024 const char *child_name,
2025 const BdrvChildRole *child_role,
2026 uint64_t perm, uint64_t shared_perm,
2027 void *opaque, Error **errp)
2029 BdrvChild *child;
2030 int ret;
2032 ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp);
2033 if (ret < 0) {
2034 bdrv_abort_perm_update(child_bs);
2035 return NULL;
2038 child = g_new(BdrvChild, 1);
2039 *child = (BdrvChild) {
2040 .bs = NULL,
2041 .name = g_strdup(child_name),
2042 .role = child_role,
2043 .perm = perm,
2044 .shared_perm = shared_perm,
2045 .opaque = opaque,
2048 /* This performs the matching bdrv_set_perm() for the above check. */
2049 bdrv_replace_child(child, child_bs);
2051 return child;
2054 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
2055 BlockDriverState *child_bs,
2056 const char *child_name,
2057 const BdrvChildRole *child_role,
2058 Error **errp)
2060 BdrvChild *child;
2061 uint64_t perm, shared_perm;
2063 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
2065 assert(parent_bs->drv);
2066 assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs));
2067 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
2068 perm, shared_perm, &perm, &shared_perm);
2070 child = bdrv_root_attach_child(child_bs, child_name, child_role,
2071 perm, shared_perm, parent_bs, errp);
2072 if (child == NULL) {
2073 return NULL;
2076 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
2077 return child;
2080 static void bdrv_detach_child(BdrvChild *child)
2082 if (child->next.le_prev) {
2083 QLIST_REMOVE(child, next);
2084 child->next.le_prev = NULL;
2087 bdrv_replace_child(child, NULL);
2089 g_free(child->name);
2090 g_free(child);
2093 void bdrv_root_unref_child(BdrvChild *child)
2095 BlockDriverState *child_bs;
2097 child_bs = child->bs;
2098 bdrv_detach_child(child);
2099 bdrv_unref(child_bs);
2102 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
2104 if (child == NULL) {
2105 return;
2108 if (child->bs->inherits_from == parent) {
2109 BdrvChild *c;
2111 /* Remove inherits_from only when the last reference between parent and
2112 * child->bs goes away. */
2113 QLIST_FOREACH(c, &parent->children, next) {
2114 if (c != child && c->bs == child->bs) {
2115 break;
2118 if (c == NULL) {
2119 child->bs->inherits_from = NULL;
2123 bdrv_root_unref_child(child);
2127 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load)
2129 BdrvChild *c;
2130 QLIST_FOREACH(c, &bs->parents, next_parent) {
2131 if (c->role->change_media) {
2132 c->role->change_media(c, load);
2137 static void bdrv_parent_cb_resize(BlockDriverState *bs)
2139 BdrvChild *c;
2140 QLIST_FOREACH(c, &bs->parents, next_parent) {
2141 if (c->role->resize) {
2142 c->role->resize(c);
2148 * Sets the backing file link of a BDS. A new reference is created; callers
2149 * which don't need their own reference any more must call bdrv_unref().
2151 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
2152 Error **errp)
2154 if (backing_hd) {
2155 bdrv_ref(backing_hd);
2158 if (bs->backing) {
2159 bdrv_unref_child(bs, bs->backing);
2162 if (!backing_hd) {
2163 bs->backing = NULL;
2164 goto out;
2167 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing,
2168 errp);
2169 if (!bs->backing) {
2170 bdrv_unref(backing_hd);
2173 bdrv_refresh_filename(bs);
2175 out:
2176 bdrv_refresh_limits(bs, NULL);
2180 * Opens the backing file for a BlockDriverState if not yet open
2182 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
2183 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2184 * itself, all options starting with "${bdref_key}." are considered part of the
2185 * BlockdevRef.
2187 * TODO Can this be unified with bdrv_open_image()?
2189 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
2190 const char *bdref_key, Error **errp)
2192 char *backing_filename = g_malloc0(PATH_MAX);
2193 char *bdref_key_dot;
2194 const char *reference = NULL;
2195 int ret = 0;
2196 BlockDriverState *backing_hd;
2197 QDict *options;
2198 QDict *tmp_parent_options = NULL;
2199 Error *local_err = NULL;
2201 if (bs->backing != NULL) {
2202 goto free_exit;
2205 /* NULL means an empty set of options */
2206 if (parent_options == NULL) {
2207 tmp_parent_options = qdict_new();
2208 parent_options = tmp_parent_options;
2211 bs->open_flags &= ~BDRV_O_NO_BACKING;
2213 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2214 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
2215 g_free(bdref_key_dot);
2218 * Caution: while qdict_get_try_str() is fine, getting non-string
2219 * types would require more care. When @parent_options come from
2220 * -blockdev or blockdev_add, its members are typed according to
2221 * the QAPI schema, but when they come from -drive, they're all
2222 * QString.
2224 reference = qdict_get_try_str(parent_options, bdref_key);
2225 if (reference || qdict_haskey(options, "file.filename")) {
2226 backing_filename[0] = '\0';
2227 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
2228 QDECREF(options);
2229 goto free_exit;
2230 } else {
2231 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
2232 &local_err);
2233 if (local_err) {
2234 ret = -EINVAL;
2235 error_propagate(errp, local_err);
2236 QDECREF(options);
2237 goto free_exit;
2241 if (!bs->drv || !bs->drv->supports_backing) {
2242 ret = -EINVAL;
2243 error_setg(errp, "Driver doesn't support backing files");
2244 QDECREF(options);
2245 goto free_exit;
2248 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
2249 qdict_put_str(options, "driver", bs->backing_format);
2252 backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL,
2253 reference, options, 0, bs, &child_backing,
2254 errp);
2255 if (!backing_hd) {
2256 bs->open_flags |= BDRV_O_NO_BACKING;
2257 error_prepend(errp, "Could not open backing file: ");
2258 ret = -EINVAL;
2259 goto free_exit;
2261 bdrv_set_aio_context(backing_hd, bdrv_get_aio_context(bs));
2263 /* Hook up the backing file link; drop our reference, bs owns the
2264 * backing_hd reference now */
2265 bdrv_set_backing_hd(bs, backing_hd, &local_err);
2266 bdrv_unref(backing_hd);
2267 if (local_err) {
2268 error_propagate(errp, local_err);
2269 ret = -EINVAL;
2270 goto free_exit;
2273 qdict_del(parent_options, bdref_key);
2275 free_exit:
2276 g_free(backing_filename);
2277 QDECREF(tmp_parent_options);
2278 return ret;
2281 static BlockDriverState *
2282 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
2283 BlockDriverState *parent, const BdrvChildRole *child_role,
2284 bool allow_none, Error **errp)
2286 BlockDriverState *bs = NULL;
2287 QDict *image_options;
2288 char *bdref_key_dot;
2289 const char *reference;
2291 assert(child_role != NULL);
2293 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
2294 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
2295 g_free(bdref_key_dot);
2298 * Caution: while qdict_get_try_str() is fine, getting non-string
2299 * types would require more care. When @options come from
2300 * -blockdev or blockdev_add, its members are typed according to
2301 * the QAPI schema, but when they come from -drive, they're all
2302 * QString.
2304 reference = qdict_get_try_str(options, bdref_key);
2305 if (!filename && !reference && !qdict_size(image_options)) {
2306 if (!allow_none) {
2307 error_setg(errp, "A block device must be specified for \"%s\"",
2308 bdref_key);
2310 QDECREF(image_options);
2311 goto done;
2314 bs = bdrv_open_inherit(filename, reference, image_options, 0,
2315 parent, child_role, errp);
2316 if (!bs) {
2317 goto done;
2320 done:
2321 qdict_del(options, bdref_key);
2322 return bs;
2326 * Opens a disk image whose options are given as BlockdevRef in another block
2327 * device's options.
2329 * If allow_none is true, no image will be opened if filename is false and no
2330 * BlockdevRef is given. NULL will be returned, but errp remains unset.
2332 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
2333 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
2334 * itself, all options starting with "${bdref_key}." are considered part of the
2335 * BlockdevRef.
2337 * The BlockdevRef will be removed from the options QDict.
2339 BdrvChild *bdrv_open_child(const char *filename,
2340 QDict *options, const char *bdref_key,
2341 BlockDriverState *parent,
2342 const BdrvChildRole *child_role,
2343 bool allow_none, Error **errp)
2345 BdrvChild *c;
2346 BlockDriverState *bs;
2348 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
2349 allow_none, errp);
2350 if (bs == NULL) {
2351 return NULL;
2354 c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp);
2355 if (!c) {
2356 bdrv_unref(bs);
2357 return NULL;
2360 return c;
2363 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
2364 int flags,
2365 QDict *snapshot_options,
2366 Error **errp)
2368 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
2369 char *tmp_filename = g_malloc0(PATH_MAX + 1);
2370 int64_t total_size;
2371 QemuOpts *opts = NULL;
2372 BlockDriverState *bs_snapshot = NULL;
2373 Error *local_err = NULL;
2374 int ret;
2376 /* if snapshot, we create a temporary backing file and open it
2377 instead of opening 'filename' directly */
2379 /* Get the required size from the image */
2380 total_size = bdrv_getlength(bs);
2381 if (total_size < 0) {
2382 error_setg_errno(errp, -total_size, "Could not get image size");
2383 goto out;
2386 /* Create the temporary image */
2387 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
2388 if (ret < 0) {
2389 error_setg_errno(errp, -ret, "Could not get temporary filename");
2390 goto out;
2393 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
2394 &error_abort);
2395 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
2396 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
2397 qemu_opts_del(opts);
2398 if (ret < 0) {
2399 error_prepend(errp, "Could not create temporary overlay '%s': ",
2400 tmp_filename);
2401 goto out;
2404 /* Prepare options QDict for the temporary file */
2405 qdict_put_str(snapshot_options, "file.driver", "file");
2406 qdict_put_str(snapshot_options, "file.filename", tmp_filename);
2407 qdict_put_str(snapshot_options, "driver", "qcow2");
2409 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp);
2410 snapshot_options = NULL;
2411 if (!bs_snapshot) {
2412 goto out;
2415 /* bdrv_append() consumes a strong reference to bs_snapshot
2416 * (i.e. it will call bdrv_unref() on it) even on error, so in
2417 * order to be able to return one, we have to increase
2418 * bs_snapshot's refcount here */
2419 bdrv_ref(bs_snapshot);
2420 bdrv_append(bs_snapshot, bs, &local_err);
2421 if (local_err) {
2422 error_propagate(errp, local_err);
2423 bs_snapshot = NULL;
2424 goto out;
2427 out:
2428 QDECREF(snapshot_options);
2429 g_free(tmp_filename);
2430 return bs_snapshot;
2434 * Opens a disk image (raw, qcow2, vmdk, ...)
2436 * options is a QDict of options to pass to the block drivers, or NULL for an
2437 * empty set of options. The reference to the QDict belongs to the block layer
2438 * after the call (even on failure), so if the caller intends to reuse the
2439 * dictionary, it needs to use QINCREF() before calling bdrv_open.
2441 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
2442 * If it is not NULL, the referenced BDS will be reused.
2444 * The reference parameter may be used to specify an existing block device which
2445 * should be opened. If specified, neither options nor a filename may be given,
2446 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
2448 static BlockDriverState *bdrv_open_inherit(const char *filename,
2449 const char *reference,
2450 QDict *options, int flags,
2451 BlockDriverState *parent,
2452 const BdrvChildRole *child_role,
2453 Error **errp)
2455 int ret;
2456 BlockBackend *file = NULL;
2457 BlockDriverState *bs;
2458 BlockDriver *drv = NULL;
2459 const char *drvname;
2460 const char *backing;
2461 Error *local_err = NULL;
2462 QDict *snapshot_options = NULL;
2463 int snapshot_flags = 0;
2465 assert(!child_role || !flags);
2466 assert(!child_role == !parent);
2468 if (reference) {
2469 bool options_non_empty = options ? qdict_size(options) : false;
2470 QDECREF(options);
2472 if (filename || options_non_empty) {
2473 error_setg(errp, "Cannot reference an existing block device with "
2474 "additional options or a new filename");
2475 return NULL;
2478 bs = bdrv_lookup_bs(reference, reference, errp);
2479 if (!bs) {
2480 return NULL;
2483 bdrv_ref(bs);
2484 return bs;
2487 bs = bdrv_new();
2489 /* NULL means an empty set of options */
2490 if (options == NULL) {
2491 options = qdict_new();
2494 /* json: syntax counts as explicit options, as if in the QDict */
2495 parse_json_protocol(options, &filename, &local_err);
2496 if (local_err) {
2497 goto fail;
2500 bs->explicit_options = qdict_clone_shallow(options);
2502 if (child_role) {
2503 bs->inherits_from = parent;
2504 child_role->inherit_options(&flags, options,
2505 parent->open_flags, parent->options);
2508 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
2509 if (local_err) {
2510 goto fail;
2514 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags.
2515 * Caution: getting a boolean member of @options requires care.
2516 * When @options come from -blockdev or blockdev_add, members are
2517 * typed according to the QAPI schema, but when they come from
2518 * -drive, they're all QString.
2520 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") &&
2521 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) {
2522 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR);
2523 } else {
2524 flags &= ~BDRV_O_RDWR;
2527 if (flags & BDRV_O_SNAPSHOT) {
2528 snapshot_options = qdict_new();
2529 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
2530 flags, options);
2531 /* Let bdrv_backing_options() override "read-only" */
2532 qdict_del(options, BDRV_OPT_READ_ONLY);
2533 bdrv_backing_options(&flags, options, flags, options);
2536 bs->open_flags = flags;
2537 bs->options = options;
2538 options = qdict_clone_shallow(options);
2540 /* Find the right image format driver */
2541 /* See cautionary note on accessing @options above */
2542 drvname = qdict_get_try_str(options, "driver");
2543 if (drvname) {
2544 drv = bdrv_find_format(drvname);
2545 if (!drv) {
2546 error_setg(errp, "Unknown driver: '%s'", drvname);
2547 goto fail;
2551 assert(drvname || !(flags & BDRV_O_PROTOCOL));
2553 /* See cautionary note on accessing @options above */
2554 backing = qdict_get_try_str(options, "backing");
2555 if (backing && *backing == '\0') {
2556 flags |= BDRV_O_NO_BACKING;
2557 qdict_del(options, "backing");
2560 /* Open image file without format layer. This BlockBackend is only used for
2561 * probing, the block drivers will do their own bdrv_open_child() for the
2562 * same BDS, which is why we put the node name back into options. */
2563 if ((flags & BDRV_O_PROTOCOL) == 0) {
2564 BlockDriverState *file_bs;
2566 file_bs = bdrv_open_child_bs(filename, options, "file", bs,
2567 &child_file, true, &local_err);
2568 if (local_err) {
2569 goto fail;
2571 if (file_bs != NULL) {
2572 file = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
2573 blk_insert_bs(file, file_bs, &local_err);
2574 bdrv_unref(file_bs);
2575 if (local_err) {
2576 goto fail;
2579 qdict_put_str(options, "file", bdrv_get_node_name(file_bs));
2583 /* Image format probing */
2584 bs->probed = !drv;
2585 if (!drv && file) {
2586 ret = find_image_format(file, filename, &drv, &local_err);
2587 if (ret < 0) {
2588 goto fail;
2591 * This option update would logically belong in bdrv_fill_options(),
2592 * but we first need to open bs->file for the probing to work, while
2593 * opening bs->file already requires the (mostly) final set of options
2594 * so that cache mode etc. can be inherited.
2596 * Adding the driver later is somewhat ugly, but it's not an option
2597 * that would ever be inherited, so it's correct. We just need to make
2598 * sure to update both bs->options (which has the full effective
2599 * options for bs) and options (which has file.* already removed).
2601 qdict_put_str(bs->options, "driver", drv->format_name);
2602 qdict_put_str(options, "driver", drv->format_name);
2603 } else if (!drv) {
2604 error_setg(errp, "Must specify either driver or file");
2605 goto fail;
2608 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
2609 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
2610 /* file must be NULL if a protocol BDS is about to be created
2611 * (the inverse results in an error message from bdrv_open_common()) */
2612 assert(!(flags & BDRV_O_PROTOCOL) || !file);
2614 /* Open the image */
2615 ret = bdrv_open_common(bs, file, options, &local_err);
2616 if (ret < 0) {
2617 goto fail;
2620 if (file) {
2621 blk_unref(file);
2622 file = NULL;
2625 /* If there is a backing file, use it */
2626 if ((flags & BDRV_O_NO_BACKING) == 0) {
2627 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
2628 if (ret < 0) {
2629 goto close_and_fail;
2633 bdrv_refresh_filename(bs);
2635 /* Check if any unknown options were used */
2636 if (qdict_size(options) != 0) {
2637 const QDictEntry *entry = qdict_first(options);
2638 if (flags & BDRV_O_PROTOCOL) {
2639 error_setg(errp, "Block protocol '%s' doesn't support the option "
2640 "'%s'", drv->format_name, entry->key);
2641 } else {
2642 error_setg(errp,
2643 "Block format '%s' does not support the option '%s'",
2644 drv->format_name, entry->key);
2647 goto close_and_fail;
2650 bdrv_parent_cb_change_media(bs, true);
2652 QDECREF(options);
2654 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
2655 * temporary snapshot afterwards. */
2656 if (snapshot_flags) {
2657 BlockDriverState *snapshot_bs;
2658 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags,
2659 snapshot_options, &local_err);
2660 snapshot_options = NULL;
2661 if (local_err) {
2662 goto close_and_fail;
2664 /* We are not going to return bs but the overlay on top of it
2665 * (snapshot_bs); thus, we have to drop the strong reference to bs
2666 * (which we obtained by calling bdrv_new()). bs will not be deleted,
2667 * though, because the overlay still has a reference to it. */
2668 bdrv_unref(bs);
2669 bs = snapshot_bs;
2672 return bs;
2674 fail:
2675 blk_unref(file);
2676 QDECREF(snapshot_options);
2677 QDECREF(bs->explicit_options);
2678 QDECREF(bs->options);
2679 QDECREF(options);
2680 bs->options = NULL;
2681 bs->explicit_options = NULL;
2682 bdrv_unref(bs);
2683 error_propagate(errp, local_err);
2684 return NULL;
2686 close_and_fail:
2687 bdrv_unref(bs);
2688 QDECREF(snapshot_options);
2689 QDECREF(options);
2690 error_propagate(errp, local_err);
2691 return NULL;
2694 BlockDriverState *bdrv_open(const char *filename, const char *reference,
2695 QDict *options, int flags, Error **errp)
2697 return bdrv_open_inherit(filename, reference, options, flags, NULL,
2698 NULL, errp);
2702 * Adds a BlockDriverState to a simple queue for an atomic, transactional
2703 * reopen of multiple devices.
2705 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
2706 * already performed, or alternatively may be NULL a new BlockReopenQueue will
2707 * be created and initialized. This newly created BlockReopenQueue should be
2708 * passed back in for subsequent calls that are intended to be of the same
2709 * atomic 'set'.
2711 * bs is the BlockDriverState to add to the reopen queue.
2713 * options contains the changed options for the associated bs
2714 * (the BlockReopenQueue takes ownership)
2716 * flags contains the open flags for the associated bs
2718 * returns a pointer to bs_queue, which is either the newly allocated
2719 * bs_queue, or the existing bs_queue being used.
2722 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
2723 BlockDriverState *bs,
2724 QDict *options,
2725 int flags,
2726 const BdrvChildRole *role,
2727 QDict *parent_options,
2728 int parent_flags)
2730 assert(bs != NULL);
2732 BlockReopenQueueEntry *bs_entry;
2733 BdrvChild *child;
2734 QDict *old_options, *explicit_options;
2736 if (bs_queue == NULL) {
2737 bs_queue = g_new0(BlockReopenQueue, 1);
2738 QSIMPLEQ_INIT(bs_queue);
2741 if (!options) {
2742 options = qdict_new();
2745 /* Check if this BlockDriverState is already in the queue */
2746 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2747 if (bs == bs_entry->state.bs) {
2748 break;
2753 * Precedence of options:
2754 * 1. Explicitly passed in options (highest)
2755 * 2. Set in flags (only for top level)
2756 * 3. Retained from explicitly set options of bs
2757 * 4. Inherited from parent node
2758 * 5. Retained from effective options of bs
2761 if (!parent_options) {
2763 * Any setting represented by flags is always updated. If the
2764 * corresponding QDict option is set, it takes precedence. Otherwise
2765 * the flag is translated into a QDict option. The old setting of bs is
2766 * not considered.
2768 update_options_from_flags(options, flags);
2771 /* Old explicitly set values (don't overwrite by inherited value) */
2772 if (bs_entry) {
2773 old_options = qdict_clone_shallow(bs_entry->state.explicit_options);
2774 } else {
2775 old_options = qdict_clone_shallow(bs->explicit_options);
2777 bdrv_join_options(bs, options, old_options);
2778 QDECREF(old_options);
2780 explicit_options = qdict_clone_shallow(options);
2782 /* Inherit from parent node */
2783 if (parent_options) {
2784 assert(!flags);
2785 role->inherit_options(&flags, options, parent_flags, parent_options);
2788 /* Old values are used for options that aren't set yet */
2789 old_options = qdict_clone_shallow(bs->options);
2790 bdrv_join_options(bs, options, old_options);
2791 QDECREF(old_options);
2793 /* bdrv_open_inherit() sets and clears some additional flags internally */
2794 flags &= ~BDRV_O_PROTOCOL;
2795 if (flags & BDRV_O_RDWR) {
2796 flags |= BDRV_O_ALLOW_RDWR;
2799 if (!bs_entry) {
2800 bs_entry = g_new0(BlockReopenQueueEntry, 1);
2801 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
2802 } else {
2803 QDECREF(bs_entry->state.options);
2804 QDECREF(bs_entry->state.explicit_options);
2807 bs_entry->state.bs = bs;
2808 bs_entry->state.options = options;
2809 bs_entry->state.explicit_options = explicit_options;
2810 bs_entry->state.flags = flags;
2812 /* This needs to be overwritten in bdrv_reopen_prepare() */
2813 bs_entry->state.perm = UINT64_MAX;
2814 bs_entry->state.shared_perm = 0;
2816 QLIST_FOREACH(child, &bs->children, next) {
2817 QDict *new_child_options;
2818 char *child_key_dot;
2820 /* reopen can only change the options of block devices that were
2821 * implicitly created and inherited options. For other (referenced)
2822 * block devices, a syntax like "backing.foo" results in an error. */
2823 if (child->bs->inherits_from != bs) {
2824 continue;
2827 child_key_dot = g_strdup_printf("%s.", child->name);
2828 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
2829 g_free(child_key_dot);
2831 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
2832 child->role, options, flags);
2835 return bs_queue;
2838 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
2839 BlockDriverState *bs,
2840 QDict *options, int flags)
2842 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
2843 NULL, NULL, 0);
2847 * Reopen multiple BlockDriverStates atomically & transactionally.
2849 * The queue passed in (bs_queue) must have been built up previous
2850 * via bdrv_reopen_queue().
2852 * Reopens all BDS specified in the queue, with the appropriate
2853 * flags. All devices are prepared for reopen, and failure of any
2854 * device will cause all device changes to be abandonded, and intermediate
2855 * data cleaned up.
2857 * If all devices prepare successfully, then the changes are committed
2858 * to all devices.
2861 int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
2863 int ret = -1;
2864 BlockReopenQueueEntry *bs_entry, *next;
2865 Error *local_err = NULL;
2867 assert(bs_queue != NULL);
2869 aio_context_release(ctx);
2870 bdrv_drain_all_begin();
2871 aio_context_acquire(ctx);
2873 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2874 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
2875 error_propagate(errp, local_err);
2876 goto cleanup;
2878 bs_entry->prepared = true;
2881 /* If we reach this point, we have success and just need to apply the
2882 * changes
2884 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
2885 bdrv_reopen_commit(&bs_entry->state);
2888 ret = 0;
2890 cleanup:
2891 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
2892 if (ret && bs_entry->prepared) {
2893 bdrv_reopen_abort(&bs_entry->state);
2894 } else if (ret) {
2895 QDECREF(bs_entry->state.explicit_options);
2897 QDECREF(bs_entry->state.options);
2898 g_free(bs_entry);
2900 g_free(bs_queue);
2902 bdrv_drain_all_end();
2904 return ret;
2908 /* Reopen a single BlockDriverState with the specified flags. */
2909 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
2911 int ret = -1;
2912 Error *local_err = NULL;
2913 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
2915 ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
2916 if (local_err != NULL) {
2917 error_propagate(errp, local_err);
2919 return ret;
2922 static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q,
2923 BdrvChild *c)
2925 BlockReopenQueueEntry *entry;
2927 QSIMPLEQ_FOREACH(entry, q, entry) {
2928 BlockDriverState *bs = entry->state.bs;
2929 BdrvChild *child;
2931 QLIST_FOREACH(child, &bs->children, next) {
2932 if (child == c) {
2933 return entry;
2938 return NULL;
2941 static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs,
2942 uint64_t *perm, uint64_t *shared)
2944 BdrvChild *c;
2945 BlockReopenQueueEntry *parent;
2946 uint64_t cumulative_perms = 0;
2947 uint64_t cumulative_shared_perms = BLK_PERM_ALL;
2949 QLIST_FOREACH(c, &bs->parents, next_parent) {
2950 parent = find_parent_in_reopen_queue(q, c);
2951 if (!parent) {
2952 cumulative_perms |= c->perm;
2953 cumulative_shared_perms &= c->shared_perm;
2954 } else {
2955 uint64_t nperm, nshared;
2957 bdrv_child_perm(parent->state.bs, bs, c, c->role, q,
2958 parent->state.perm, parent->state.shared_perm,
2959 &nperm, &nshared);
2961 cumulative_perms |= nperm;
2962 cumulative_shared_perms &= nshared;
2965 *perm = cumulative_perms;
2966 *shared = cumulative_shared_perms;
2970 * Prepares a BlockDriverState for reopen. All changes are staged in the
2971 * 'opaque' field of the BDRVReopenState, which is used and allocated by
2972 * the block driver layer .bdrv_reopen_prepare()
2974 * bs is the BlockDriverState to reopen
2975 * flags are the new open flags
2976 * queue is the reopen queue
2978 * Returns 0 on success, non-zero on error. On error errp will be set
2979 * as well.
2981 * On failure, bdrv_reopen_abort() will be called to clean up any data.
2982 * It is the responsibility of the caller to then call the abort() or
2983 * commit() for any other BDS that have been left in a prepare() state
2986 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
2987 Error **errp)
2989 int ret = -1;
2990 Error *local_err = NULL;
2991 BlockDriver *drv;
2992 QemuOpts *opts;
2993 const char *value;
2994 bool read_only;
2996 assert(reopen_state != NULL);
2997 assert(reopen_state->bs->drv != NULL);
2998 drv = reopen_state->bs->drv;
3000 /* Process generic block layer options */
3001 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
3002 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
3003 if (local_err) {
3004 error_propagate(errp, local_err);
3005 ret = -EINVAL;
3006 goto error;
3009 update_flags_from_options(&reopen_state->flags, opts);
3011 /* node-name and driver must be unchanged. Put them back into the QDict, so
3012 * that they are checked at the end of this function. */
3013 value = qemu_opt_get(opts, "node-name");
3014 if (value) {
3015 qdict_put_str(reopen_state->options, "node-name", value);
3018 value = qemu_opt_get(opts, "driver");
3019 if (value) {
3020 qdict_put_str(reopen_state->options, "driver", value);
3023 /* If we are to stay read-only, do not allow permission change
3024 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
3025 * not set, or if the BDS still has copy_on_read enabled */
3026 read_only = !(reopen_state->flags & BDRV_O_RDWR);
3027 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);
3028 if (local_err) {
3029 error_propagate(errp, local_err);
3030 goto error;
3033 /* Calculate required permissions after reopening */
3034 bdrv_reopen_perm(queue, reopen_state->bs,
3035 &reopen_state->perm, &reopen_state->shared_perm);
3037 ret = bdrv_flush(reopen_state->bs);
3038 if (ret) {
3039 error_setg_errno(errp, -ret, "Error flushing drive");
3040 goto error;
3043 if (drv->bdrv_reopen_prepare) {
3044 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
3045 if (ret) {
3046 if (local_err != NULL) {
3047 error_propagate(errp, local_err);
3048 } else {
3049 error_setg(errp, "failed while preparing to reopen image '%s'",
3050 reopen_state->bs->filename);
3052 goto error;
3054 } else {
3055 /* It is currently mandatory to have a bdrv_reopen_prepare()
3056 * handler for each supported drv. */
3057 error_setg(errp, "Block format '%s' used by node '%s' "
3058 "does not support reopening files", drv->format_name,
3059 bdrv_get_device_or_node_name(reopen_state->bs));
3060 ret = -1;
3061 goto error;
3064 /* Options that are not handled are only okay if they are unchanged
3065 * compared to the old state. It is expected that some options are only
3066 * used for the initial open, but not reopen (e.g. filename) */
3067 if (qdict_size(reopen_state->options)) {
3068 const QDictEntry *entry = qdict_first(reopen_state->options);
3070 do {
3071 QString *new_obj = qobject_to_qstring(entry->value);
3072 const char *new = qstring_get_str(new_obj);
3074 * Caution: while qdict_get_try_str() is fine, getting
3075 * non-string types would require more care. When
3076 * bs->options come from -blockdev or blockdev_add, its
3077 * members are typed according to the QAPI schema, but
3078 * when they come from -drive, they're all QString.
3080 const char *old = qdict_get_try_str(reopen_state->bs->options,
3081 entry->key);
3083 if (!old || strcmp(new, old)) {
3084 error_setg(errp, "Cannot change the option '%s'", entry->key);
3085 ret = -EINVAL;
3086 goto error;
3088 } while ((entry = qdict_next(reopen_state->options, entry)));
3091 ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,
3092 reopen_state->shared_perm, NULL, errp);
3093 if (ret < 0) {
3094 goto error;
3097 ret = 0;
3099 error:
3100 qemu_opts_del(opts);
3101 return ret;
3105 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
3106 * makes them final by swapping the staging BlockDriverState contents into
3107 * the active BlockDriverState contents.
3109 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
3111 BlockDriver *drv;
3112 BlockDriverState *bs;
3113 bool old_can_write, new_can_write;
3115 assert(reopen_state != NULL);
3116 bs = reopen_state->bs;
3117 drv = bs->drv;
3118 assert(drv != NULL);
3120 old_can_write =
3121 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3123 /* If there are any driver level actions to take */
3124 if (drv->bdrv_reopen_commit) {
3125 drv->bdrv_reopen_commit(reopen_state);
3128 /* set BDS specific flags now */
3129 QDECREF(bs->explicit_options);
3131 bs->explicit_options = reopen_state->explicit_options;
3132 bs->open_flags = reopen_state->flags;
3133 bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
3135 bdrv_refresh_limits(bs, NULL);
3137 bdrv_set_perm(reopen_state->bs, reopen_state->perm,
3138 reopen_state->shared_perm);
3140 new_can_write =
3141 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
3142 if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) {
3143 Error *local_err = NULL;
3144 if (drv->bdrv_reopen_bitmaps_rw(bs, &local_err) < 0) {
3145 /* This is not fatal, bitmaps just left read-only, so all following
3146 * writes will fail. User can remove read-only bitmaps to unblock
3147 * writes.
3149 error_reportf_err(local_err,
3150 "%s: Failed to make dirty bitmaps writable: ",
3151 bdrv_get_node_name(bs));
3157 * Abort the reopen, and delete and free the staged changes in
3158 * reopen_state
3160 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
3162 BlockDriver *drv;
3164 assert(reopen_state != NULL);
3165 drv = reopen_state->bs->drv;
3166 assert(drv != NULL);
3168 if (drv->bdrv_reopen_abort) {
3169 drv->bdrv_reopen_abort(reopen_state);
3172 QDECREF(reopen_state->explicit_options);
3174 bdrv_abort_perm_update(reopen_state->bs);
3178 static void bdrv_close(BlockDriverState *bs)
3180 BdrvAioNotifier *ban, *ban_next;
3182 assert(!bs->job);
3183 assert(!bs->refcnt);
3185 bdrv_drained_begin(bs); /* complete I/O */
3186 bdrv_flush(bs);
3187 bdrv_drain(bs); /* in case flush left pending I/O */
3189 if (bs->drv) {
3190 BdrvChild *child, *next;
3192 bs->drv->bdrv_close(bs);
3193 bs->drv = NULL;
3195 bdrv_set_backing_hd(bs, NULL, &error_abort);
3197 if (bs->file != NULL) {
3198 bdrv_unref_child(bs, bs->file);
3199 bs->file = NULL;
3202 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
3203 /* TODO Remove bdrv_unref() from drivers' close function and use
3204 * bdrv_unref_child() here */
3205 if (child->bs->inherits_from == bs) {
3206 child->bs->inherits_from = NULL;
3208 bdrv_detach_child(child);
3211 g_free(bs->opaque);
3212 bs->opaque = NULL;
3213 atomic_set(&bs->copy_on_read, 0);
3214 bs->backing_file[0] = '\0';
3215 bs->backing_format[0] = '\0';
3216 bs->total_sectors = 0;
3217 bs->encrypted = false;
3218 bs->sg = false;
3219 QDECREF(bs->options);
3220 QDECREF(bs->explicit_options);
3221 bs->options = NULL;
3222 bs->explicit_options = NULL;
3223 QDECREF(bs->full_open_options);
3224 bs->full_open_options = NULL;
3227 bdrv_release_named_dirty_bitmaps(bs);
3228 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
3230 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3231 g_free(ban);
3233 QLIST_INIT(&bs->aio_notifiers);
3234 bdrv_drained_end(bs);
3237 void bdrv_close_all(void)
3239 block_job_cancel_sync_all();
3240 nbd_export_close_all();
3242 /* Drop references from requests still in flight, such as canceled block
3243 * jobs whose AIO context has not been polled yet */
3244 bdrv_drain_all();
3246 blk_remove_all_bs();
3247 blockdev_close_all_bdrv_states();
3249 assert(QTAILQ_EMPTY(&all_bdrv_states));
3252 static bool should_update_child(BdrvChild *c, BlockDriverState *to)
3254 BdrvChild *to_c;
3256 if (c->role->stay_at_node) {
3257 return false;
3260 if (c->role == &child_backing) {
3261 /* If @from is a backing file of @to, ignore the child to avoid
3262 * creating a loop. We only want to change the pointer of other
3263 * parents. */
3264 QLIST_FOREACH(to_c, &to->children, next) {
3265 if (to_c == c) {
3266 break;
3269 if (to_c) {
3270 return false;
3274 return true;
3277 void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
3278 Error **errp)
3280 BdrvChild *c, *next;
3281 GSList *list = NULL, *p;
3282 uint64_t old_perm, old_shared;
3283 uint64_t perm = 0, shared = BLK_PERM_ALL;
3284 int ret;
3286 assert(!atomic_read(&from->in_flight));
3287 assert(!atomic_read(&to->in_flight));
3289 /* Make sure that @from doesn't go away until we have successfully attached
3290 * all of its parents to @to. */
3291 bdrv_ref(from);
3293 /* Put all parents into @list and calculate their cumulative permissions */
3294 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
3295 if (!should_update_child(c, to)) {
3296 continue;
3298 list = g_slist_prepend(list, c);
3299 perm |= c->perm;
3300 shared &= c->shared_perm;
3303 /* Check whether the required permissions can be granted on @to, ignoring
3304 * all BdrvChild in @list so that they can't block themselves. */
3305 ret = bdrv_check_update_perm(to, NULL, perm, shared, list, errp);
3306 if (ret < 0) {
3307 bdrv_abort_perm_update(to);
3308 goto out;
3311 /* Now actually perform the change. We performed the permission check for
3312 * all elements of @list at once, so set the permissions all at once at the
3313 * very end. */
3314 for (p = list; p != NULL; p = p->next) {
3315 c = p->data;
3317 bdrv_ref(to);
3318 bdrv_replace_child_noperm(c, to);
3319 bdrv_unref(from);
3322 bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
3323 bdrv_set_perm(to, old_perm | perm, old_shared | shared);
3325 out:
3326 g_slist_free(list);
3327 bdrv_unref(from);
3331 * Add new bs contents at the top of an image chain while the chain is
3332 * live, while keeping required fields on the top layer.
3334 * This will modify the BlockDriverState fields, and swap contents
3335 * between bs_new and bs_top. Both bs_new and bs_top are modified.
3337 * bs_new must not be attached to a BlockBackend.
3339 * This function does not create any image files.
3341 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
3342 * that's what the callers commonly need. bs_new will be referenced by the old
3343 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
3344 * reference of its own, it must call bdrv_ref().
3346 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
3347 Error **errp)
3349 Error *local_err = NULL;
3351 bdrv_set_backing_hd(bs_new, bs_top, &local_err);
3352 if (local_err) {
3353 error_propagate(errp, local_err);
3354 goto out;
3357 bdrv_replace_node(bs_top, bs_new, &local_err);
3358 if (local_err) {
3359 error_propagate(errp, local_err);
3360 bdrv_set_backing_hd(bs_new, NULL, &error_abort);
3361 goto out;
3364 /* bs_new is now referenced by its new parents, we don't need the
3365 * additional reference any more. */
3366 out:
3367 bdrv_unref(bs_new);
3370 static void bdrv_delete(BlockDriverState *bs)
3372 assert(!bs->job);
3373 assert(bdrv_op_blocker_is_empty(bs));
3374 assert(!bs->refcnt);
3376 bdrv_close(bs);
3378 /* remove from list, if necessary */
3379 if (bs->node_name[0] != '\0') {
3380 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
3382 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
3384 g_free(bs);
3388 * Run consistency checks on an image
3390 * Returns 0 if the check could be completed (it doesn't mean that the image is
3391 * free of errors) or -errno when an internal error occurred. The results of the
3392 * check are stored in res.
3394 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
3396 if (bs->drv == NULL) {
3397 return -ENOMEDIUM;
3399 if (bs->drv->bdrv_check == NULL) {
3400 return -ENOTSUP;
3403 memset(res, 0, sizeof(*res));
3404 return bs->drv->bdrv_check(bs, res, fix);
3408 * Return values:
3409 * 0 - success
3410 * -EINVAL - backing format specified, but no file
3411 * -ENOSPC - can't update the backing file because no space is left in the
3412 * image file header
3413 * -ENOTSUP - format driver doesn't support changing the backing file
3415 int bdrv_change_backing_file(BlockDriverState *bs,
3416 const char *backing_file, const char *backing_fmt)
3418 BlockDriver *drv = bs->drv;
3419 int ret;
3421 /* Backing file format doesn't make sense without a backing file */
3422 if (backing_fmt && !backing_file) {
3423 return -EINVAL;
3426 if (drv->bdrv_change_backing_file != NULL) {
3427 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
3428 } else {
3429 ret = -ENOTSUP;
3432 if (ret == 0) {
3433 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3434 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3436 return ret;
3440 * Finds the image layer in the chain that has 'bs' as its backing file.
3442 * active is the current topmost image.
3444 * Returns NULL if bs is not found in active's image chain,
3445 * or if active == bs.
3447 * Returns the bottommost base image if bs == NULL.
3449 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
3450 BlockDriverState *bs)
3452 while (active && bs != backing_bs(active)) {
3453 active = backing_bs(active);
3456 return active;
3459 /* Given a BDS, searches for the base layer. */
3460 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3462 return bdrv_find_overlay(bs, NULL);
3466 * Drops images above 'base' up to and including 'top', and sets the image
3467 * above 'top' to have base as its backing file.
3469 * Requires that the overlay to 'top' is opened r/w, so that the backing file
3470 * information in 'bs' can be properly updated.
3472 * E.g., this will convert the following chain:
3473 * bottom <- base <- intermediate <- top <- active
3475 * to
3477 * bottom <- base <- active
3479 * It is allowed for bottom==base, in which case it converts:
3481 * base <- intermediate <- top <- active
3483 * to
3485 * base <- active
3487 * If backing_file_str is non-NULL, it will be used when modifying top's
3488 * overlay image metadata.
3490 * Error conditions:
3491 * if active == top, that is considered an error
3494 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
3495 const char *backing_file_str)
3497 BdrvChild *c, *next;
3498 Error *local_err = NULL;
3499 int ret = -EIO;
3501 bdrv_ref(top);
3503 if (!top->drv || !base->drv) {
3504 goto exit;
3507 /* Make sure that base is in the backing chain of top */
3508 if (!bdrv_chain_contains(top, base)) {
3509 goto exit;
3512 /* success - we can delete the intermediate states, and link top->base */
3513 /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once
3514 * we've figured out how they should work. */
3515 backing_file_str = backing_file_str ? backing_file_str : base->filename;
3517 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) {
3518 /* Check whether we are allowed to switch c from top to base */
3519 GSList *ignore_children = g_slist_prepend(NULL, c);
3520 bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm,
3521 ignore_children, &local_err);
3522 if (local_err) {
3523 ret = -EPERM;
3524 error_report_err(local_err);
3525 goto exit;
3527 g_slist_free(ignore_children);
3529 /* If so, update the backing file path in the image file */
3530 if (c->role->update_filename) {
3531 ret = c->role->update_filename(c, base, backing_file_str,
3532 &local_err);
3533 if (ret < 0) {
3534 bdrv_abort_perm_update(base);
3535 error_report_err(local_err);
3536 goto exit;
3540 /* Do the actual switch in the in-memory graph.
3541 * Completes bdrv_check_update_perm() transaction internally. */
3542 bdrv_ref(base);
3543 bdrv_replace_child(c, base);
3544 bdrv_unref(top);
3547 ret = 0;
3548 exit:
3549 bdrv_unref(top);
3550 return ret;
3554 * Truncate file to 'offset' bytes (needed only for file protocols)
3556 int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
3557 Error **errp)
3559 BlockDriverState *bs = child->bs;
3560 BlockDriver *drv = bs->drv;
3561 int ret;
3563 assert(child->perm & BLK_PERM_RESIZE);
3565 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
3566 if (!drv) {
3567 error_setg(errp, "No medium inserted");
3568 return -ENOMEDIUM;
3570 if (!drv->bdrv_truncate) {
3571 if (bs->file && drv->is_filter) {
3572 return bdrv_truncate(bs->file, offset, prealloc, errp);
3574 error_setg(errp, "Image format driver does not support resize");
3575 return -ENOTSUP;
3577 if (bs->read_only) {
3578 error_setg(errp, "Image is read-only");
3579 return -EACCES;
3582 assert(!(bs->open_flags & BDRV_O_INACTIVE));
3584 ret = drv->bdrv_truncate(bs, offset, prealloc, errp);
3585 if (ret < 0) {
3586 return ret;
3588 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3589 if (ret < 0) {
3590 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3591 } else {
3592 offset = bs->total_sectors * BDRV_SECTOR_SIZE;
3594 bdrv_dirty_bitmap_truncate(bs, offset);
3595 bdrv_parent_cb_resize(bs);
3596 atomic_inc(&bs->write_gen);
3597 return ret;
3601 * Length of a allocated file in bytes. Sparse files are counted by actual
3602 * allocated space. Return < 0 if error or unknown.
3604 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3606 BlockDriver *drv = bs->drv;
3607 if (!drv) {
3608 return -ENOMEDIUM;
3610 if (drv->bdrv_get_allocated_file_size) {
3611 return drv->bdrv_get_allocated_file_size(bs);
3613 if (bs->file) {
3614 return bdrv_get_allocated_file_size(bs->file->bs);
3616 return -ENOTSUP;
3620 * bdrv_measure:
3621 * @drv: Format driver
3622 * @opts: Creation options for new image
3623 * @in_bs: Existing image containing data for new image (may be NULL)
3624 * @errp: Error object
3625 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo())
3626 * or NULL on error
3628 * Calculate file size required to create a new image.
3630 * If @in_bs is given then space for allocated clusters and zero clusters
3631 * from that image are included in the calculation. If @opts contains a
3632 * backing file that is shared by @in_bs then backing clusters may be omitted
3633 * from the calculation.
3635 * If @in_bs is NULL then the calculation includes no allocated clusters
3636 * unless a preallocation option is given in @opts.
3638 * Note that @in_bs may use a different BlockDriver from @drv.
3640 * If an error occurs the @errp pointer is set.
3642 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts,
3643 BlockDriverState *in_bs, Error **errp)
3645 if (!drv->bdrv_measure) {
3646 error_setg(errp, "Block driver '%s' does not support size measurement",
3647 drv->format_name);
3648 return NULL;
3651 return drv->bdrv_measure(opts, in_bs, errp);
3655 * Return number of sectors on success, -errno on error.
3657 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3659 BlockDriver *drv = bs->drv;
3661 if (!drv)
3662 return -ENOMEDIUM;
3664 if (drv->has_variable_length) {
3665 int ret = refresh_total_sectors(bs, bs->total_sectors);
3666 if (ret < 0) {
3667 return ret;
3670 return bs->total_sectors;
3674 * Return length in bytes on success, -errno on error.
3675 * The length is always a multiple of BDRV_SECTOR_SIZE.
3677 int64_t bdrv_getlength(BlockDriverState *bs)
3679 int64_t ret = bdrv_nb_sectors(bs);
3681 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
3682 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3685 /* return 0 as number of sectors if no device present or error */
3686 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3688 int64_t nb_sectors = bdrv_nb_sectors(bs);
3690 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3693 bool bdrv_is_sg(BlockDriverState *bs)
3695 return bs->sg;
3698 bool bdrv_is_encrypted(BlockDriverState *bs)
3700 if (bs->backing && bs->backing->bs->encrypted) {
3701 return true;
3703 return bs->encrypted;
3706 const char *bdrv_get_format_name(BlockDriverState *bs)
3708 return bs->drv ? bs->drv->format_name : NULL;
3711 static int qsort_strcmp(const void *a, const void *b)
3713 return strcmp(*(char *const *)a, *(char *const *)b);
3716 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3717 void *opaque)
3719 BlockDriver *drv;
3720 int count = 0;
3721 int i;
3722 const char **formats = NULL;
3724 QLIST_FOREACH(drv, &bdrv_drivers, list) {
3725 if (drv->format_name) {
3726 bool found = false;
3727 int i = count;
3728 while (formats && i && !found) {
3729 found = !strcmp(formats[--i], drv->format_name);
3732 if (!found) {
3733 formats = g_renew(const char *, formats, count + 1);
3734 formats[count++] = drv->format_name;
3739 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) {
3740 const char *format_name = block_driver_modules[i].format_name;
3742 if (format_name) {
3743 bool found = false;
3744 int j = count;
3746 while (formats && j && !found) {
3747 found = !strcmp(formats[--j], format_name);
3750 if (!found) {
3751 formats = g_renew(const char *, formats, count + 1);
3752 formats[count++] = format_name;
3757 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
3759 for (i = 0; i < count; i++) {
3760 it(opaque, formats[i]);
3763 g_free(formats);
3766 /* This function is to find a node in the bs graph */
3767 BlockDriverState *bdrv_find_node(const char *node_name)
3769 BlockDriverState *bs;
3771 assert(node_name);
3773 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3774 if (!strcmp(node_name, bs->node_name)) {
3775 return bs;
3778 return NULL;
3781 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3782 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
3784 BlockDeviceInfoList *list, *entry;
3785 BlockDriverState *bs;
3787 list = NULL;
3788 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3789 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
3790 if (!info) {
3791 qapi_free_BlockDeviceInfoList(list);
3792 return NULL;
3794 entry = g_malloc0(sizeof(*entry));
3795 entry->value = info;
3796 entry->next = list;
3797 list = entry;
3800 return list;
3803 BlockDriverState *bdrv_lookup_bs(const char *device,
3804 const char *node_name,
3805 Error **errp)
3807 BlockBackend *blk;
3808 BlockDriverState *bs;
3810 if (device) {
3811 blk = blk_by_name(device);
3813 if (blk) {
3814 bs = blk_bs(blk);
3815 if (!bs) {
3816 error_setg(errp, "Device '%s' has no medium", device);
3819 return bs;
3823 if (node_name) {
3824 bs = bdrv_find_node(node_name);
3826 if (bs) {
3827 return bs;
3831 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3832 device ? device : "",
3833 node_name ? node_name : "");
3834 return NULL;
3837 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3838 * return false. If either argument is NULL, return false. */
3839 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3841 while (top && top != base) {
3842 top = backing_bs(top);
3845 return top != NULL;
3848 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
3850 if (!bs) {
3851 return QTAILQ_FIRST(&graph_bdrv_states);
3853 return QTAILQ_NEXT(bs, node_list);
3856 const char *bdrv_get_node_name(const BlockDriverState *bs)
3858 return bs->node_name;
3861 const char *bdrv_get_parent_name(const BlockDriverState *bs)
3863 BdrvChild *c;
3864 const char *name;
3866 /* If multiple parents have a name, just pick the first one. */
3867 QLIST_FOREACH(c, &bs->parents, next_parent) {
3868 if (c->role->get_name) {
3869 name = c->role->get_name(c);
3870 if (name && *name) {
3871 return name;
3876 return NULL;
3879 /* TODO check what callers really want: bs->node_name or blk_name() */
3880 const char *bdrv_get_device_name(const BlockDriverState *bs)
3882 return bdrv_get_parent_name(bs) ?: "";
3885 /* This can be used to identify nodes that might not have a device
3886 * name associated. Since node and device names live in the same
3887 * namespace, the result is unambiguous. The exception is if both are
3888 * absent, then this returns an empty (non-null) string. */
3889 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
3891 return bdrv_get_parent_name(bs) ?: bs->node_name;
3894 int bdrv_get_flags(BlockDriverState *bs)
3896 return bs->open_flags;
3899 int bdrv_has_zero_init_1(BlockDriverState *bs)
3901 return 1;
3904 int bdrv_has_zero_init(BlockDriverState *bs)
3906 assert(bs->drv);
3908 /* If BS is a copy on write image, it is initialized to
3909 the contents of the base image, which may not be zeroes. */
3910 if (bs->backing) {
3911 return 0;
3913 if (bs->drv->bdrv_has_zero_init) {
3914 return bs->drv->bdrv_has_zero_init(bs);
3916 if (bs->file && bs->drv->is_filter) {
3917 return bdrv_has_zero_init(bs->file->bs);
3920 /* safe default */
3921 return 0;
3924 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3926 BlockDriverInfo bdi;
3928 if (bs->backing) {
3929 return false;
3932 if (bdrv_get_info(bs, &bdi) == 0) {
3933 return bdi.unallocated_blocks_are_zero;
3936 return false;
3939 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3941 BlockDriverInfo bdi;
3943 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3944 return false;
3947 if (bdrv_get_info(bs, &bdi) == 0) {
3948 return bdi.can_write_zeroes_with_unmap;
3951 return false;
3954 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3956 if (bs->backing && bs->backing->bs->encrypted)
3957 return bs->backing_file;
3958 else if (bs->encrypted)
3959 return bs->filename;
3960 else
3961 return NULL;
3964 void bdrv_get_backing_filename(BlockDriverState *bs,
3965 char *filename, int filename_size)
3967 pstrcpy(filename, filename_size, bs->backing_file);
3970 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3972 BlockDriver *drv = bs->drv;
3973 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
3974 if (!drv) {
3975 return -ENOMEDIUM;
3977 if (!drv->bdrv_get_info) {
3978 if (bs->file && drv->is_filter) {
3979 return bdrv_get_info(bs->file->bs, bdi);
3981 return -ENOTSUP;
3983 memset(bdi, 0, sizeof(*bdi));
3984 return drv->bdrv_get_info(bs, bdi);
3987 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3989 BlockDriver *drv = bs->drv;
3990 if (drv && drv->bdrv_get_specific_info) {
3991 return drv->bdrv_get_specific_info(bs);
3993 return NULL;
3996 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
3998 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3999 return;
4002 bs->drv->bdrv_debug_event(bs, event);
4005 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4006 const char *tag)
4008 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4009 bs = bs->file ? bs->file->bs : NULL;
4012 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4013 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4016 return -ENOTSUP;
4019 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4021 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4022 bs = bs->file ? bs->file->bs : NULL;
4025 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4026 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4029 return -ENOTSUP;
4032 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4034 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4035 bs = bs->file ? bs->file->bs : NULL;
4038 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4039 return bs->drv->bdrv_debug_resume(bs, tag);
4042 return -ENOTSUP;
4045 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4047 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4048 bs = bs->file ? bs->file->bs : NULL;
4051 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4052 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4055 return false;
4058 /* backing_file can either be relative, or absolute, or a protocol. If it is
4059 * relative, it must be relative to the chain. So, passing in bs->filename
4060 * from a BDS as backing_file should not be done, as that may be relative to
4061 * the CWD rather than the chain. */
4062 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4063 const char *backing_file)
4065 char *filename_full = NULL;
4066 char *backing_file_full = NULL;
4067 char *filename_tmp = NULL;
4068 int is_protocol = 0;
4069 BlockDriverState *curr_bs = NULL;
4070 BlockDriverState *retval = NULL;
4071 Error *local_error = NULL;
4073 if (!bs || !bs->drv || !backing_file) {
4074 return NULL;
4077 filename_full = g_malloc(PATH_MAX);
4078 backing_file_full = g_malloc(PATH_MAX);
4079 filename_tmp = g_malloc(PATH_MAX);
4081 is_protocol = path_has_protocol(backing_file);
4083 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
4085 /* If either of the filename paths is actually a protocol, then
4086 * compare unmodified paths; otherwise make paths relative */
4087 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4088 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4089 retval = curr_bs->backing->bs;
4090 break;
4092 /* Also check against the full backing filename for the image */
4093 bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX,
4094 &local_error);
4095 if (local_error == NULL) {
4096 if (strcmp(backing_file, backing_file_full) == 0) {
4097 retval = curr_bs->backing->bs;
4098 break;
4100 } else {
4101 error_free(local_error);
4102 local_error = NULL;
4104 } else {
4105 /* If not an absolute filename path, make it relative to the current
4106 * image's filename path */
4107 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4108 backing_file);
4110 /* We are going to compare absolute pathnames */
4111 if (!realpath(filename_tmp, filename_full)) {
4112 continue;
4115 /* We need to make sure the backing filename we are comparing against
4116 * is relative to the current image filename (or absolute) */
4117 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4118 curr_bs->backing_file);
4120 if (!realpath(filename_tmp, backing_file_full)) {
4121 continue;
4124 if (strcmp(backing_file_full, filename_full) == 0) {
4125 retval = curr_bs->backing->bs;
4126 break;
4131 g_free(filename_full);
4132 g_free(backing_file_full);
4133 g_free(filename_tmp);
4134 return retval;
4137 void bdrv_init(void)
4139 module_call_init(MODULE_INIT_BLOCK);
4142 void bdrv_init_with_whitelist(void)
4144 use_bdrv_whitelist = 1;
4145 bdrv_init();
4148 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4150 BdrvChild *child, *parent;
4151 uint64_t perm, shared_perm;
4152 Error *local_err = NULL;
4153 int ret;
4155 if (!bs->drv) {
4156 return;
4159 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
4160 return;
4163 QLIST_FOREACH(child, &bs->children, next) {
4164 bdrv_invalidate_cache(child->bs, &local_err);
4165 if (local_err) {
4166 error_propagate(errp, local_err);
4167 return;
4171 bs->open_flags &= ~BDRV_O_INACTIVE;
4172 if (bs->drv->bdrv_invalidate_cache) {
4173 bs->drv->bdrv_invalidate_cache(bs, &local_err);
4174 if (local_err) {
4175 bs->open_flags |= BDRV_O_INACTIVE;
4176 error_propagate(errp, local_err);
4177 return;
4181 ret = refresh_total_sectors(bs, bs->total_sectors);
4182 if (ret < 0) {
4183 bs->open_flags |= BDRV_O_INACTIVE;
4184 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4185 return;
4188 /* Update permissions, they may differ for inactive nodes */
4189 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4190 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err);
4191 if (ret < 0) {
4192 bs->open_flags |= BDRV_O_INACTIVE;
4193 error_propagate(errp, local_err);
4194 return;
4196 bdrv_set_perm(bs, perm, shared_perm);
4198 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4199 if (parent->role->activate) {
4200 parent->role->activate(parent, &local_err);
4201 if (local_err) {
4202 error_propagate(errp, local_err);
4203 return;
4209 void bdrv_invalidate_cache_all(Error **errp)
4211 BlockDriverState *bs;
4212 Error *local_err = NULL;
4213 BdrvNextIterator it;
4215 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4216 AioContext *aio_context = bdrv_get_aio_context(bs);
4218 aio_context_acquire(aio_context);
4219 bdrv_invalidate_cache(bs, &local_err);
4220 aio_context_release(aio_context);
4221 if (local_err) {
4222 error_propagate(errp, local_err);
4223 return;
4228 static int bdrv_inactivate_recurse(BlockDriverState *bs,
4229 bool setting_flag)
4231 BdrvChild *child, *parent;
4232 int ret;
4234 if (!setting_flag && bs->drv->bdrv_inactivate) {
4235 ret = bs->drv->bdrv_inactivate(bs);
4236 if (ret < 0) {
4237 return ret;
4241 if (setting_flag && !(bs->open_flags & BDRV_O_INACTIVE)) {
4242 uint64_t perm, shared_perm;
4244 QLIST_FOREACH(parent, &bs->parents, next_parent) {
4245 if (parent->role->inactivate) {
4246 ret = parent->role->inactivate(parent);
4247 if (ret < 0) {
4248 return ret;
4253 bs->open_flags |= BDRV_O_INACTIVE;
4255 /* Update permissions, they may differ for inactive nodes */
4256 bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
4257 bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort);
4258 bdrv_set_perm(bs, perm, shared_perm);
4261 QLIST_FOREACH(child, &bs->children, next) {
4262 ret = bdrv_inactivate_recurse(child->bs, setting_flag);
4263 if (ret < 0) {
4264 return ret;
4268 /* At this point persistent bitmaps should be already stored by the format
4269 * driver */
4270 bdrv_release_persistent_dirty_bitmaps(bs);
4272 return 0;
4275 int bdrv_inactivate_all(void)
4277 BlockDriverState *bs = NULL;
4278 BdrvNextIterator it;
4279 int ret = 0;
4280 int pass;
4282 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4283 aio_context_acquire(bdrv_get_aio_context(bs));
4286 /* We do two passes of inactivation. The first pass calls to drivers'
4287 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk;
4288 * the second pass sets the BDRV_O_INACTIVE flag so that no further write
4289 * is allowed. */
4290 for (pass = 0; pass < 2; pass++) {
4291 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4292 ret = bdrv_inactivate_recurse(bs, pass);
4293 if (ret < 0) {
4294 goto out;
4299 out:
4300 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4301 aio_context_release(bdrv_get_aio_context(bs));
4304 return ret;
4307 /**************************************************************/
4308 /* removable device support */
4311 * Return TRUE if the media is present
4313 bool bdrv_is_inserted(BlockDriverState *bs)
4315 BlockDriver *drv = bs->drv;
4316 BdrvChild *child;
4318 if (!drv) {
4319 return false;
4321 if (drv->bdrv_is_inserted) {
4322 return drv->bdrv_is_inserted(bs);
4324 QLIST_FOREACH(child, &bs->children, next) {
4325 if (!bdrv_is_inserted(child->bs)) {
4326 return false;
4329 return true;
4333 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4335 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4337 BlockDriver *drv = bs->drv;
4339 if (drv && drv->bdrv_eject) {
4340 drv->bdrv_eject(bs, eject_flag);
4345 * Lock or unlock the media (if it is locked, the user won't be able
4346 * to eject it manually).
4348 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4350 BlockDriver *drv = bs->drv;
4352 trace_bdrv_lock_medium(bs, locked);
4354 if (drv && drv->bdrv_lock_medium) {
4355 drv->bdrv_lock_medium(bs, locked);
4359 /* Get a reference to bs */
4360 void bdrv_ref(BlockDriverState *bs)
4362 bs->refcnt++;
4365 /* Release a previously grabbed reference to bs.
4366 * If after releasing, reference count is zero, the BlockDriverState is
4367 * deleted. */
4368 void bdrv_unref(BlockDriverState *bs)
4370 if (!bs) {
4371 return;
4373 assert(bs->refcnt > 0);
4374 if (--bs->refcnt == 0) {
4375 bdrv_delete(bs);
4379 struct BdrvOpBlocker {
4380 Error *reason;
4381 QLIST_ENTRY(BdrvOpBlocker) list;
4384 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
4386 BdrvOpBlocker *blocker;
4387 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4388 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
4389 blocker = QLIST_FIRST(&bs->op_blockers[op]);
4390 error_propagate(errp, error_copy(blocker->reason));
4391 error_prepend(errp, "Node '%s' is busy: ",
4392 bdrv_get_device_or_node_name(bs));
4393 return true;
4395 return false;
4398 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
4400 BdrvOpBlocker *blocker;
4401 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4403 blocker = g_new0(BdrvOpBlocker, 1);
4404 blocker->reason = reason;
4405 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
4408 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
4410 BdrvOpBlocker *blocker, *next;
4411 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
4412 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
4413 if (blocker->reason == reason) {
4414 QLIST_REMOVE(blocker, list);
4415 g_free(blocker);
4420 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
4422 int i;
4423 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4424 bdrv_op_block(bs, i, reason);
4428 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
4430 int i;
4431 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4432 bdrv_op_unblock(bs, i, reason);
4436 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
4438 int i;
4440 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
4441 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
4442 return false;
4445 return true;
4448 void bdrv_img_create(const char *filename, const char *fmt,
4449 const char *base_filename, const char *base_fmt,
4450 char *options, uint64_t img_size, int flags, bool quiet,
4451 Error **errp)
4453 QemuOptsList *create_opts = NULL;
4454 QemuOpts *opts = NULL;
4455 const char *backing_fmt, *backing_file;
4456 int64_t size;
4457 BlockDriver *drv, *proto_drv;
4458 Error *local_err = NULL;
4459 int ret = 0;
4461 /* Find driver and parse its options */
4462 drv = bdrv_find_format(fmt);
4463 if (!drv) {
4464 error_setg(errp, "Unknown file format '%s'", fmt);
4465 return;
4468 proto_drv = bdrv_find_protocol(filename, true, errp);
4469 if (!proto_drv) {
4470 return;
4473 if (!drv->create_opts) {
4474 error_setg(errp, "Format driver '%s' does not support image creation",
4475 drv->format_name);
4476 return;
4479 if (!proto_drv->create_opts) {
4480 error_setg(errp, "Protocol driver '%s' does not support image creation",
4481 proto_drv->format_name);
4482 return;
4485 create_opts = qemu_opts_append(create_opts, drv->create_opts);
4486 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
4488 /* Create parameter list with default values */
4489 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
4490 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
4492 /* Parse -o options */
4493 if (options) {
4494 qemu_opts_do_parse(opts, options, NULL, &local_err);
4495 if (local_err) {
4496 error_report_err(local_err);
4497 local_err = NULL;
4498 error_setg(errp, "Invalid options for file format '%s'", fmt);
4499 goto out;
4503 if (base_filename) {
4504 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
4505 if (local_err) {
4506 error_setg(errp, "Backing file not supported for file format '%s'",
4507 fmt);
4508 goto out;
4512 if (base_fmt) {
4513 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
4514 if (local_err) {
4515 error_setg(errp, "Backing file format not supported for file "
4516 "format '%s'", fmt);
4517 goto out;
4521 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
4522 if (backing_file) {
4523 if (!strcmp(filename, backing_file)) {
4524 error_setg(errp, "Error: Trying to create an image with the "
4525 "same filename as the backing file");
4526 goto out;
4530 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
4532 /* The size for the image must always be specified, unless we have a backing
4533 * file and we have not been forbidden from opening it. */
4534 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size);
4535 if (backing_file && !(flags & BDRV_O_NO_BACKING)) {
4536 BlockDriverState *bs;
4537 char *full_backing = g_new0(char, PATH_MAX);
4538 int back_flags;
4539 QDict *backing_options = NULL;
4541 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
4542 full_backing, PATH_MAX,
4543 &local_err);
4544 if (local_err) {
4545 g_free(full_backing);
4546 goto out;
4549 /* backing files always opened read-only */
4550 back_flags = flags;
4551 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4553 if (backing_fmt) {
4554 backing_options = qdict_new();
4555 qdict_put_str(backing_options, "driver", backing_fmt);
4558 bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
4559 &local_err);
4560 g_free(full_backing);
4561 if (!bs && size != -1) {
4562 /* Couldn't open BS, but we have a size, so it's nonfatal */
4563 warn_reportf_err(local_err,
4564 "Could not verify backing image. "
4565 "This may become an error in future versions.\n");
4566 local_err = NULL;
4567 } else if (!bs) {
4568 /* Couldn't open bs, do not have size */
4569 error_append_hint(&local_err,
4570 "Could not open backing image to determine size.\n");
4571 goto out;
4572 } else {
4573 if (size == -1) {
4574 /* Opened BS, have no size */
4575 size = bdrv_getlength(bs);
4576 if (size < 0) {
4577 error_setg_errno(errp, -size, "Could not get size of '%s'",
4578 backing_file);
4579 bdrv_unref(bs);
4580 goto out;
4582 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
4584 bdrv_unref(bs);
4586 } /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */
4588 if (size == -1) {
4589 error_setg(errp, "Image creation needs a size parameter");
4590 goto out;
4593 if (!quiet) {
4594 printf("Formatting '%s', fmt=%s ", filename, fmt);
4595 qemu_opts_print(opts, " ");
4596 puts("");
4599 ret = bdrv_create(drv, filename, opts, &local_err);
4601 if (ret == -EFBIG) {
4602 /* This is generally a better message than whatever the driver would
4603 * deliver (especially because of the cluster_size_hint), since that
4604 * is most probably not much different from "image too large". */
4605 const char *cluster_size_hint = "";
4606 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
4607 cluster_size_hint = " (try using a larger cluster size)";
4609 error_setg(errp, "The image size is too large for file format '%s'"
4610 "%s", fmt, cluster_size_hint);
4611 error_free(local_err);
4612 local_err = NULL;
4615 out:
4616 qemu_opts_del(opts);
4617 qemu_opts_free(create_opts);
4618 error_propagate(errp, local_err);
4621 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
4623 return bs->aio_context;
4626 void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)
4628 aio_co_enter(bdrv_get_aio_context(bs), co);
4631 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban)
4633 QLIST_REMOVE(ban, list);
4634 g_free(ban);
4637 void bdrv_detach_aio_context(BlockDriverState *bs)
4639 BdrvAioNotifier *baf, *baf_tmp;
4640 BdrvChild *child;
4642 if (!bs->drv) {
4643 return;
4646 assert(!bs->walking_aio_notifiers);
4647 bs->walking_aio_notifiers = true;
4648 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) {
4649 if (baf->deleted) {
4650 bdrv_do_remove_aio_context_notifier(baf);
4651 } else {
4652 baf->detach_aio_context(baf->opaque);
4655 /* Never mind iterating again to check for ->deleted. bdrv_close() will
4656 * remove remaining aio notifiers if we aren't called again.
4658 bs->walking_aio_notifiers = false;
4660 if (bs->drv->bdrv_detach_aio_context) {
4661 bs->drv->bdrv_detach_aio_context(bs);
4663 QLIST_FOREACH(child, &bs->children, next) {
4664 bdrv_detach_aio_context(child->bs);
4667 bs->aio_context = NULL;
4670 void bdrv_attach_aio_context(BlockDriverState *bs,
4671 AioContext *new_context)
4673 BdrvAioNotifier *ban, *ban_tmp;
4674 BdrvChild *child;
4676 if (!bs->drv) {
4677 return;
4680 bs->aio_context = new_context;
4682 QLIST_FOREACH(child, &bs->children, next) {
4683 bdrv_attach_aio_context(child->bs, new_context);
4685 if (bs->drv->bdrv_attach_aio_context) {
4686 bs->drv->bdrv_attach_aio_context(bs, new_context);
4689 assert(!bs->walking_aio_notifiers);
4690 bs->walking_aio_notifiers = true;
4691 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) {
4692 if (ban->deleted) {
4693 bdrv_do_remove_aio_context_notifier(ban);
4694 } else {
4695 ban->attached_aio_context(new_context, ban->opaque);
4698 bs->walking_aio_notifiers = false;
4701 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4703 AioContext *ctx = bdrv_get_aio_context(bs);
4705 aio_disable_external(ctx);
4706 bdrv_parent_drained_begin(bs);
4707 bdrv_drain(bs); /* ensure there are no in-flight requests */
4709 while (aio_poll(ctx, false)) {
4710 /* wait for all bottom halves to execute */
4713 bdrv_detach_aio_context(bs);
4715 /* This function executes in the old AioContext so acquire the new one in
4716 * case it runs in a different thread.
4718 aio_context_acquire(new_context);
4719 bdrv_attach_aio_context(bs, new_context);
4720 bdrv_parent_drained_end(bs);
4721 aio_enable_external(ctx);
4722 aio_context_release(new_context);
4725 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4726 void (*attached_aio_context)(AioContext *new_context, void *opaque),
4727 void (*detach_aio_context)(void *opaque), void *opaque)
4729 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4730 *ban = (BdrvAioNotifier){
4731 .attached_aio_context = attached_aio_context,
4732 .detach_aio_context = detach_aio_context,
4733 .opaque = opaque
4736 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4739 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4740 void (*attached_aio_context)(AioContext *,
4741 void *),
4742 void (*detach_aio_context)(void *),
4743 void *opaque)
4745 BdrvAioNotifier *ban, *ban_next;
4747 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4748 if (ban->attached_aio_context == attached_aio_context &&
4749 ban->detach_aio_context == detach_aio_context &&
4750 ban->opaque == opaque &&
4751 ban->deleted == false)
4753 if (bs->walking_aio_notifiers) {
4754 ban->deleted = true;
4755 } else {
4756 bdrv_do_remove_aio_context_notifier(ban);
4758 return;
4762 abort();
4765 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4766 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
4768 if (!bs->drv->bdrv_amend_options) {
4769 return -ENOTSUP;
4771 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
4774 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4775 * of block filter and by bdrv_is_first_non_filter.
4776 * It is used to test if the given bs is the candidate or recurse more in the
4777 * node graph.
4779 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4780 BlockDriverState *candidate)
4782 /* return false if basic checks fails */
4783 if (!bs || !bs->drv) {
4784 return false;
4787 /* the code reached a non block filter driver -> check if the bs is
4788 * the same as the candidate. It's the recursion termination condition.
4790 if (!bs->drv->is_filter) {
4791 return bs == candidate;
4793 /* Down this path the driver is a block filter driver */
4795 /* If the block filter recursion method is defined use it to recurse down
4796 * the node graph.
4798 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4799 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4802 /* the driver is a block filter but don't allow to recurse -> return false
4804 return false;
4807 /* This function checks if the candidate is the first non filter bs down it's
4808 * bs chain. Since we don't have pointers to parents it explore all bs chains
4809 * from the top. Some filters can choose not to pass down the recursion.
4811 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4813 BlockDriverState *bs;
4814 BdrvNextIterator it;
4816 /* walk down the bs forest recursively */
4817 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
4818 bool perm;
4820 /* try to recurse in this top level bs */
4821 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4823 /* candidate is the first non filter */
4824 if (perm) {
4825 return true;
4829 return false;
4832 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4833 const char *node_name, Error **errp)
4835 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4836 AioContext *aio_context;
4838 if (!to_replace_bs) {
4839 error_setg(errp, "Node name '%s' not found", node_name);
4840 return NULL;
4843 aio_context = bdrv_get_aio_context(to_replace_bs);
4844 aio_context_acquire(aio_context);
4846 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4847 to_replace_bs = NULL;
4848 goto out;
4851 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4852 * most non filter in order to prevent data corruption.
4853 * Another benefit is that this tests exclude backing files which are
4854 * blocked by the backing blockers.
4856 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4857 error_setg(errp, "Only top most non filter can be replaced");
4858 to_replace_bs = NULL;
4859 goto out;
4862 out:
4863 aio_context_release(aio_context);
4864 return to_replace_bs;
4867 static bool append_open_options(QDict *d, BlockDriverState *bs)
4869 const QDictEntry *entry;
4870 QemuOptDesc *desc;
4871 BdrvChild *child;
4872 bool found_any = false;
4873 const char *p;
4875 for (entry = qdict_first(bs->options); entry;
4876 entry = qdict_next(bs->options, entry))
4878 /* Exclude options for children */
4879 QLIST_FOREACH(child, &bs->children, next) {
4880 if (strstart(qdict_entry_key(entry), child->name, &p)
4881 && (!*p || *p == '.'))
4883 break;
4886 if (child) {
4887 continue;
4890 /* And exclude all non-driver-specific options */
4891 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
4892 if (!strcmp(qdict_entry_key(entry), desc->name)) {
4893 break;
4896 if (desc->name) {
4897 continue;
4900 qobject_incref(qdict_entry_value(entry));
4901 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4902 found_any = true;
4905 return found_any;
4908 /* Updates the following BDS fields:
4909 * - exact_filename: A filename which may be used for opening a block device
4910 * which (mostly) equals the given BDS (even without any
4911 * other options; so reading and writing must return the same
4912 * results, but caching etc. may be different)
4913 * - full_open_options: Options which, when given when opening a block device
4914 * (without a filename), result in a BDS (mostly)
4915 * equalling the given one
4916 * - filename: If exact_filename is set, it is copied here. Otherwise,
4917 * full_open_options is converted to a JSON object, prefixed with
4918 * "json:" (for use through the JSON pseudo protocol) and put here.
4920 void bdrv_refresh_filename(BlockDriverState *bs)
4922 BlockDriver *drv = bs->drv;
4923 QDict *opts;
4925 if (!drv) {
4926 return;
4929 /* This BDS's file name will most probably depend on its file's name, so
4930 * refresh that first */
4931 if (bs->file) {
4932 bdrv_refresh_filename(bs->file->bs);
4935 if (drv->bdrv_refresh_filename) {
4936 /* Obsolete information is of no use here, so drop the old file name
4937 * information before refreshing it */
4938 bs->exact_filename[0] = '\0';
4939 if (bs->full_open_options) {
4940 QDECREF(bs->full_open_options);
4941 bs->full_open_options = NULL;
4944 opts = qdict_new();
4945 append_open_options(opts, bs);
4946 drv->bdrv_refresh_filename(bs, opts);
4947 QDECREF(opts);
4948 } else if (bs->file) {
4949 /* Try to reconstruct valid information from the underlying file */
4950 bool has_open_options;
4952 bs->exact_filename[0] = '\0';
4953 if (bs->full_open_options) {
4954 QDECREF(bs->full_open_options);
4955 bs->full_open_options = NULL;
4958 opts = qdict_new();
4959 has_open_options = append_open_options(opts, bs);
4961 /* If no specific options have been given for this BDS, the filename of
4962 * the underlying file should suffice for this one as well */
4963 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4964 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4966 /* Reconstructing the full options QDict is simple for most format block
4967 * drivers, as long as the full options are known for the underlying
4968 * file BDS. The full options QDict of that file BDS should somehow
4969 * contain a representation of the filename, therefore the following
4970 * suffices without querying the (exact_)filename of this BDS. */
4971 if (bs->file->bs->full_open_options) {
4972 qdict_put_str(opts, "driver", drv->format_name);
4973 QINCREF(bs->file->bs->full_open_options);
4974 qdict_put(opts, "file", bs->file->bs->full_open_options);
4976 bs->full_open_options = opts;
4977 } else {
4978 QDECREF(opts);
4980 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4981 /* There is no underlying file BDS (at least referenced by BDS.file),
4982 * so the full options QDict should be equal to the options given
4983 * specifically for this block device when it was opened (plus the
4984 * driver specification).
4985 * Because those options don't change, there is no need to update
4986 * full_open_options when it's already set. */
4988 opts = qdict_new();
4989 append_open_options(opts, bs);
4990 qdict_put_str(opts, "driver", drv->format_name);
4992 if (bs->exact_filename[0]) {
4993 /* This may not work for all block protocol drivers (some may
4994 * require this filename to be parsed), but we have to find some
4995 * default solution here, so just include it. If some block driver
4996 * does not support pure options without any filename at all or
4997 * needs some special format of the options QDict, it needs to
4998 * implement the driver-specific bdrv_refresh_filename() function.
5000 qdict_put_str(opts, "filename", bs->exact_filename);
5003 bs->full_open_options = opts;
5006 if (bs->exact_filename[0]) {
5007 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
5008 } else if (bs->full_open_options) {
5009 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
5010 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
5011 qstring_get_str(json));
5012 QDECREF(json);
5017 * Hot add/remove a BDS's child. So the user can take a child offline when
5018 * it is broken and take a new child online
5020 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
5021 Error **errp)
5024 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) {
5025 error_setg(errp, "The node %s does not support adding a child",
5026 bdrv_get_device_or_node_name(parent_bs));
5027 return;
5030 if (!QLIST_EMPTY(&child_bs->parents)) {
5031 error_setg(errp, "The node %s already has a parent",
5032 child_bs->node_name);
5033 return;
5036 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp);
5039 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp)
5041 BdrvChild *tmp;
5043 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) {
5044 error_setg(errp, "The node %s does not support removing a child",
5045 bdrv_get_device_or_node_name(parent_bs));
5046 return;
5049 QLIST_FOREACH(tmp, &parent_bs->children, next) {
5050 if (tmp == child) {
5051 break;
5055 if (!tmp) {
5056 error_setg(errp, "The node %s does not have a child named %s",
5057 bdrv_get_device_or_node_name(parent_bs),
5058 bdrv_get_device_or_node_name(child->bs));
5059 return;
5062 parent_bs->drv->bdrv_del_child(parent_bs, child, errp);
5065 bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
5066 uint32_t granularity, Error **errp)
5068 BlockDriver *drv = bs->drv;
5070 if (!drv) {
5071 error_setg_errno(errp, ENOMEDIUM,
5072 "Can't store persistent bitmaps to %s",
5073 bdrv_get_device_or_node_name(bs));
5074 return false;
5077 if (!drv->bdrv_can_store_new_dirty_bitmap) {
5078 error_setg_errno(errp, ENOTSUP,
5079 "Can't store persistent bitmaps to %s",
5080 bdrv_get_device_or_node_name(bs));
5081 return false;
5084 return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp);