wxx: Add support for ncurses
[qemu/ar7.git] / block.c
blobb4107fcd4c568fcc2cb2511f6ae779acc5709b06
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 "qemu-common.h"
26 #include "trace.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/qmp/qjson.h"
34 #include "sysemu/block-backend.h"
35 #include "sysemu/sysemu.h"
36 #include "qemu/notify.h"
37 #include "qemu/coroutine.h"
38 #include "block/qapi.h"
39 #include "qmp-commands.h"
40 #include "qemu/timer.h"
41 #include "qapi-event.h"
42 #include "block/throttle-groups.h"
44 #ifdef CONFIG_BSD
45 #include <sys/ioctl.h>
46 #include <sys/queue.h>
47 #ifndef __DragonFly__
48 #include <sys/disk.h>
49 #endif
50 #endif
52 #ifdef _WIN32
53 #include <windows.h>
54 #endif
56 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
58 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
61 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states =
62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states);
64 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
65 QLIST_HEAD_INITIALIZER(bdrv_drivers);
67 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
68 const char *reference, QDict *options, int flags,
69 BlockDriverState *parent,
70 const BdrvChildRole *child_role, Error **errp);
72 /* If non-zero, use only whitelisted block drivers */
73 static int use_bdrv_whitelist;
75 static void bdrv_close(BlockDriverState *bs);
77 #ifdef _WIN32
78 static int is_windows_drive_prefix(const char *filename)
80 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
81 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
82 filename[1] == ':');
85 int is_windows_drive(const char *filename)
87 if (is_windows_drive_prefix(filename) &&
88 filename[2] == '\0')
89 return 1;
90 if (strstart(filename, "\\\\.\\", NULL) ||
91 strstart(filename, "//./", NULL))
92 return 1;
93 return 0;
95 #endif
97 size_t bdrv_opt_mem_align(BlockDriverState *bs)
99 if (!bs || !bs->drv) {
100 /* page size or 4k (hdd sector size) should be on the safe side */
101 return MAX(4096, getpagesize());
104 return bs->bl.opt_mem_alignment;
107 size_t bdrv_min_mem_align(BlockDriverState *bs)
109 if (!bs || !bs->drv) {
110 /* page size or 4k (hdd sector size) should be on the safe side */
111 return MAX(4096, getpagesize());
114 return bs->bl.min_mem_alignment;
117 /* check if the path starts with "<protocol>:" */
118 int path_has_protocol(const char *path)
120 const char *p;
122 #ifdef _WIN32
123 if (is_windows_drive(path) ||
124 is_windows_drive_prefix(path)) {
125 return 0;
127 p = path + strcspn(path, ":/\\");
128 #else
129 p = path + strcspn(path, ":/");
130 #endif
132 return *p == ':';
135 int path_is_absolute(const char *path)
137 #ifdef _WIN32
138 /* specific case for names like: "\\.\d:" */
139 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
140 return 1;
142 return (*path == '/' || *path == '\\');
143 #else
144 return (*path == '/');
145 #endif
148 /* if filename is absolute, just copy it to dest. Otherwise, build a
149 path to it by considering it is relative to base_path. URL are
150 supported. */
151 void path_combine(char *dest, int dest_size,
152 const char *base_path,
153 const char *filename)
155 const char *p, *p1;
156 int len;
158 if (dest_size <= 0)
159 return;
160 if (path_is_absolute(filename)) {
161 pstrcpy(dest, dest_size, filename);
162 } else {
163 p = strchr(base_path, ':');
164 if (p)
165 p++;
166 else
167 p = base_path;
168 p1 = strrchr(base_path, '/');
169 #ifdef _WIN32
171 const char *p2;
172 p2 = strrchr(base_path, '\\');
173 if (!p1 || p2 > p1)
174 p1 = p2;
176 #endif
177 if (p1)
178 p1++;
179 else
180 p1 = base_path;
181 if (p1 > p)
182 p = p1;
183 len = p - base_path;
184 if (len > dest_size - 1)
185 len = dest_size - 1;
186 memcpy(dest, base_path, len);
187 dest[len] = '\0';
188 pstrcat(dest, dest_size, filename);
192 void bdrv_get_full_backing_filename_from_filename(const char *backed,
193 const char *backing,
194 char *dest, size_t sz,
195 Error **errp)
197 if (backing[0] == '\0' || path_has_protocol(backing) ||
198 path_is_absolute(backing))
200 pstrcpy(dest, sz, backing);
201 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
202 error_setg(errp, "Cannot use relative backing file names for '%s'",
203 backed);
204 } else {
205 path_combine(dest, sz, backed, backing);
209 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
210 Error **errp)
212 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
214 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
215 dest, sz, errp);
218 void bdrv_register(BlockDriver *bdrv)
220 bdrv_setup_io_funcs(bdrv);
222 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
225 BlockDriverState *bdrv_new_root(void)
227 return bdrv_new();
230 BlockDriverState *bdrv_new(void)
232 BlockDriverState *bs;
233 int i;
235 bs = g_new0(BlockDriverState, 1);
236 QLIST_INIT(&bs->dirty_bitmaps);
237 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
238 QLIST_INIT(&bs->op_blockers[i]);
240 notifier_with_return_list_init(&bs->before_write_notifiers);
241 qemu_co_queue_init(&bs->throttled_reqs[0]);
242 qemu_co_queue_init(&bs->throttled_reqs[1]);
243 bs->refcnt = 1;
244 bs->aio_context = qemu_get_aio_context();
246 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list);
248 return bs;
251 BlockDriver *bdrv_find_format(const char *format_name)
253 BlockDriver *drv1;
254 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
255 if (!strcmp(drv1->format_name, format_name)) {
256 return drv1;
259 return NULL;
262 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
264 static const char *whitelist_rw[] = {
265 CONFIG_BDRV_RW_WHITELIST
267 static const char *whitelist_ro[] = {
268 CONFIG_BDRV_RO_WHITELIST
270 const char **p;
272 if (!whitelist_rw[0] && !whitelist_ro[0]) {
273 return 1; /* no whitelist, anything goes */
276 for (p = whitelist_rw; *p; p++) {
277 if (!strcmp(drv->format_name, *p)) {
278 return 1;
281 if (read_only) {
282 for (p = whitelist_ro; *p; p++) {
283 if (!strcmp(drv->format_name, *p)) {
284 return 1;
288 return 0;
291 typedef struct CreateCo {
292 BlockDriver *drv;
293 char *filename;
294 QemuOpts *opts;
295 int ret;
296 Error *err;
297 } CreateCo;
299 static void coroutine_fn bdrv_create_co_entry(void *opaque)
301 Error *local_err = NULL;
302 int ret;
304 CreateCo *cco = opaque;
305 assert(cco->drv);
307 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
308 if (local_err) {
309 error_propagate(&cco->err, local_err);
311 cco->ret = ret;
314 int bdrv_create(BlockDriver *drv, const char* filename,
315 QemuOpts *opts, Error **errp)
317 int ret;
319 Coroutine *co;
320 CreateCo cco = {
321 .drv = drv,
322 .filename = g_strdup(filename),
323 .opts = opts,
324 .ret = NOT_DONE,
325 .err = NULL,
328 if (!drv->bdrv_create) {
329 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
330 ret = -ENOTSUP;
331 goto out;
334 if (qemu_in_coroutine()) {
335 /* Fast-path if already in coroutine context */
336 bdrv_create_co_entry(&cco);
337 } else {
338 co = qemu_coroutine_create(bdrv_create_co_entry);
339 qemu_coroutine_enter(co, &cco);
340 while (cco.ret == NOT_DONE) {
341 aio_poll(qemu_get_aio_context(), true);
345 ret = cco.ret;
346 if (ret < 0) {
347 if (cco.err) {
348 error_propagate(errp, cco.err);
349 } else {
350 error_setg_errno(errp, -ret, "Could not create image");
354 out:
355 g_free(cco.filename);
356 return ret;
359 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
361 BlockDriver *drv;
362 Error *local_err = NULL;
363 int ret;
365 drv = bdrv_find_protocol(filename, true, errp);
366 if (drv == NULL) {
367 return -ENOENT;
370 ret = bdrv_create(drv, filename, opts, &local_err);
371 if (local_err) {
372 error_propagate(errp, local_err);
374 return ret;
378 * Try to get @bs's logical and physical block size.
379 * On success, store them in @bsz struct and return 0.
380 * On failure return -errno.
381 * @bs must not be empty.
383 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
385 BlockDriver *drv = bs->drv;
387 if (drv && drv->bdrv_probe_blocksizes) {
388 return drv->bdrv_probe_blocksizes(bs, bsz);
391 return -ENOTSUP;
395 * Try to get @bs's geometry (cyls, heads, sectors).
396 * On success, store them in @geo struct and return 0.
397 * On failure return -errno.
398 * @bs must not be empty.
400 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
402 BlockDriver *drv = bs->drv;
404 if (drv && drv->bdrv_probe_geometry) {
405 return drv->bdrv_probe_geometry(bs, geo);
408 return -ENOTSUP;
412 * Create a uniquely-named empty temporary file.
413 * Return 0 upon success, otherwise a negative errno value.
415 int get_tmp_filename(char *filename, int size)
417 #ifdef _WIN32
418 char temp_dir[MAX_PATH];
419 /* GetTempFileName requires that its output buffer (4th param)
420 have length MAX_PATH or greater. */
421 assert(size >= MAX_PATH);
422 return (GetTempPath(MAX_PATH, temp_dir)
423 && GetTempFileName(temp_dir, "qem", 0, filename)
424 ? 0 : -GetLastError());
425 #else
426 int fd;
427 const char *tmpdir;
428 tmpdir = getenv("TMPDIR");
429 if (!tmpdir) {
430 tmpdir = "/var/tmp";
432 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
433 return -EOVERFLOW;
435 fd = mkstemp(filename);
436 if (fd < 0) {
437 return -errno;
439 if (close(fd) != 0) {
440 unlink(filename);
441 return -errno;
443 return 0;
444 #endif
448 * Detect host devices. By convention, /dev/cdrom[N] is always
449 * recognized as a host CDROM.
451 static BlockDriver *find_hdev_driver(const char *filename)
453 int score_max = 0, score;
454 BlockDriver *drv = NULL, *d;
456 QLIST_FOREACH(d, &bdrv_drivers, list) {
457 if (d->bdrv_probe_device) {
458 score = d->bdrv_probe_device(filename);
459 if (score > score_max) {
460 score_max = score;
461 drv = d;
466 return drv;
469 BlockDriver *bdrv_find_protocol(const char *filename,
470 bool allow_protocol_prefix,
471 Error **errp)
473 BlockDriver *drv1;
474 char protocol[128];
475 int len;
476 const char *p;
478 /* TODO Drivers without bdrv_file_open must be specified explicitly */
481 * XXX(hch): we really should not let host device detection
482 * override an explicit protocol specification, but moving this
483 * later breaks access to device names with colons in them.
484 * Thanks to the brain-dead persistent naming schemes on udev-
485 * based Linux systems those actually are quite common.
487 drv1 = find_hdev_driver(filename);
488 if (drv1) {
489 return drv1;
492 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
493 return &bdrv_file;
496 p = strchr(filename, ':');
497 assert(p != NULL);
498 len = p - filename;
499 if (len > sizeof(protocol) - 1)
500 len = sizeof(protocol) - 1;
501 memcpy(protocol, filename, len);
502 protocol[len] = '\0';
503 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
504 if (drv1->protocol_name &&
505 !strcmp(drv1->protocol_name, protocol)) {
506 return drv1;
510 error_setg(errp, "Unknown protocol '%s'", protocol);
511 return NULL;
515 * Guess image format by probing its contents.
516 * This is not a good idea when your image is raw (CVE-2008-2004), but
517 * we do it anyway for backward compatibility.
519 * @buf contains the image's first @buf_size bytes.
520 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
521 * but can be smaller if the image file is smaller)
522 * @filename is its filename.
524 * For all block drivers, call the bdrv_probe() method to get its
525 * probing score.
526 * Return the first block driver with the highest probing score.
528 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
529 const char *filename)
531 int score_max = 0, score;
532 BlockDriver *drv = NULL, *d;
534 QLIST_FOREACH(d, &bdrv_drivers, list) {
535 if (d->bdrv_probe) {
536 score = d->bdrv_probe(buf, buf_size, filename);
537 if (score > score_max) {
538 score_max = score;
539 drv = d;
544 return drv;
547 static int find_image_format(BlockDriverState *bs, const char *filename,
548 BlockDriver **pdrv, Error **errp)
550 BlockDriver *drv;
551 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
552 int ret = 0;
554 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
555 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
556 *pdrv = &bdrv_raw;
557 return ret;
560 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
561 if (ret < 0) {
562 error_setg_errno(errp, -ret, "Could not read image for determining its "
563 "format");
564 *pdrv = NULL;
565 return ret;
568 drv = bdrv_probe_all(buf, ret, filename);
569 if (!drv) {
570 error_setg(errp, "Could not determine image format: No compatible "
571 "driver found");
572 ret = -ENOENT;
574 *pdrv = drv;
575 return ret;
579 * Set the current 'total_sectors' value
580 * Return 0 on success, -errno on error.
582 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
584 BlockDriver *drv = bs->drv;
586 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
587 if (bdrv_is_sg(bs))
588 return 0;
590 /* query actual device if possible, otherwise just trust the hint */
591 if (drv->bdrv_getlength) {
592 int64_t length = drv->bdrv_getlength(bs);
593 if (length < 0) {
594 return length;
596 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
599 bs->total_sectors = hint;
600 return 0;
604 * Combines a QDict of new block driver @options with any missing options taken
605 * from @old_options, so that leaving out an option defaults to its old value.
607 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
608 QDict *old_options)
610 if (bs->drv && bs->drv->bdrv_join_options) {
611 bs->drv->bdrv_join_options(options, old_options);
612 } else {
613 qdict_join(options, old_options, false);
618 * Set open flags for a given discard mode
620 * Return 0 on success, -1 if the discard mode was invalid.
622 int bdrv_parse_discard_flags(const char *mode, int *flags)
624 *flags &= ~BDRV_O_UNMAP;
626 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
627 /* do nothing */
628 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
629 *flags |= BDRV_O_UNMAP;
630 } else {
631 return -1;
634 return 0;
638 * Set open flags for a given cache mode
640 * Return 0 on success, -1 if the cache mode was invalid.
642 int bdrv_parse_cache_flags(const char *mode, int *flags)
644 *flags &= ~BDRV_O_CACHE_MASK;
646 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
647 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
648 } else if (!strcmp(mode, "directsync")) {
649 *flags |= BDRV_O_NOCACHE;
650 } else if (!strcmp(mode, "writeback")) {
651 *flags |= BDRV_O_CACHE_WB;
652 } else if (!strcmp(mode, "unsafe")) {
653 *flags |= BDRV_O_CACHE_WB;
654 *flags |= BDRV_O_NO_FLUSH;
655 } else if (!strcmp(mode, "writethrough")) {
656 /* this is the default */
657 } else {
658 return -1;
661 return 0;
665 * Returns the options and flags that a temporary snapshot should get, based on
666 * the originally requested flags (the originally requested image will have
667 * flags like a backing file)
669 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options,
670 int parent_flags, QDict *parent_options)
672 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
674 /* For temporary files, unconditional cache=unsafe is fine */
675 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on");
676 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");
677 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");
681 * Returns the options and flags that bs->file should get if a protocol driver
682 * is expected, based on the given options and flags for the parent BDS
684 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
685 int parent_flags, QDict *parent_options)
687 int flags = parent_flags;
689 /* Enable protocol handling, disable format probing for bs->file */
690 flags |= BDRV_O_PROTOCOL;
692 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
693 * the parent. */
694 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
695 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
697 /* Our block drivers take care to send flushes and respect unmap policy,
698 * so we can default to enable both on lower layers regardless of the
699 * corresponding parent options. */
700 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on");
701 flags |= BDRV_O_UNMAP;
703 /* Clear flags that only apply to the top layer */
704 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
706 *child_flags = flags;
709 const BdrvChildRole child_file = {
710 .inherit_options = bdrv_inherited_options,
714 * Returns the options and flags that bs->file should get if the use of formats
715 * (and not only protocols) is permitted for it, based on the given options and
716 * flags for the parent BDS
718 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
719 int parent_flags, QDict *parent_options)
721 child_file.inherit_options(child_flags, child_options,
722 parent_flags, parent_options);
724 *child_flags &= ~BDRV_O_PROTOCOL;
727 const BdrvChildRole child_format = {
728 .inherit_options = bdrv_inherited_fmt_options,
732 * Returns the options and flags that bs->backing should get, based on the
733 * given options and flags for the parent BDS
735 static void bdrv_backing_options(int *child_flags, QDict *child_options,
736 int parent_flags, QDict *parent_options)
738 int flags = parent_flags;
740 /* The cache mode is inherited unmodified for backing files */
741 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_WB);
742 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
743 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
745 /* backing files always opened read-only */
746 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
748 /* snapshot=on is handled on the top layer */
749 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
751 *child_flags = flags;
754 static const BdrvChildRole child_backing = {
755 .inherit_options = bdrv_backing_options,
758 static int bdrv_open_flags(BlockDriverState *bs, int flags)
760 int open_flags = flags | BDRV_O_CACHE_WB;
763 * Clear flags that are internal to the block layer before opening the
764 * image.
766 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
769 * Snapshots should be writable.
771 if (flags & BDRV_O_TEMPORARY) {
772 open_flags |= BDRV_O_RDWR;
775 return open_flags;
778 static void update_flags_from_options(int *flags, QemuOpts *opts)
780 *flags &= ~BDRV_O_CACHE_MASK;
782 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_WB));
783 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, false)) {
784 *flags |= BDRV_O_CACHE_WB;
787 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
788 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
789 *flags |= BDRV_O_NO_FLUSH;
792 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
793 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
794 *flags |= BDRV_O_NOCACHE;
798 static void update_options_from_flags(QDict *options, int flags)
800 if (!qdict_haskey(options, BDRV_OPT_CACHE_WB)) {
801 qdict_put(options, BDRV_OPT_CACHE_WB,
802 qbool_from_bool(flags & BDRV_O_CACHE_WB));
804 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
805 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
806 qbool_from_bool(flags & BDRV_O_NOCACHE));
808 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
809 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
810 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
814 static void bdrv_assign_node_name(BlockDriverState *bs,
815 const char *node_name,
816 Error **errp)
818 char *gen_node_name = NULL;
820 if (!node_name) {
821 node_name = gen_node_name = id_generate(ID_BLOCK);
822 } else if (!id_wellformed(node_name)) {
824 * Check for empty string or invalid characters, but not if it is
825 * generated (generated names use characters not available to the user)
827 error_setg(errp, "Invalid node name");
828 return;
831 /* takes care of avoiding namespaces collisions */
832 if (blk_by_name(node_name)) {
833 error_setg(errp, "node-name=%s is conflicting with a device id",
834 node_name);
835 goto out;
838 /* takes care of avoiding duplicates node names */
839 if (bdrv_find_node(node_name)) {
840 error_setg(errp, "Duplicate node name");
841 goto out;
844 /* copy node name into the bs and insert it into the graph list */
845 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
846 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
847 out:
848 g_free(gen_node_name);
851 static QemuOptsList bdrv_runtime_opts = {
852 .name = "bdrv_common",
853 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
854 .desc = {
856 .name = "node-name",
857 .type = QEMU_OPT_STRING,
858 .help = "Node name of the block device node",
861 .name = "driver",
862 .type = QEMU_OPT_STRING,
863 .help = "Block driver to use for the node",
866 .name = BDRV_OPT_CACHE_WB,
867 .type = QEMU_OPT_BOOL,
868 .help = "Enable writeback mode",
871 .name = BDRV_OPT_CACHE_DIRECT,
872 .type = QEMU_OPT_BOOL,
873 .help = "Bypass software writeback cache on the host",
876 .name = BDRV_OPT_CACHE_NO_FLUSH,
877 .type = QEMU_OPT_BOOL,
878 .help = "Ignore flush requests",
880 { /* end of list */ }
885 * Common part for opening disk images and files
887 * Removes all processed options from *options.
889 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
890 QDict *options, Error **errp)
892 int ret, open_flags;
893 const char *filename;
894 const char *driver_name = NULL;
895 const char *node_name = NULL;
896 QemuOpts *opts;
897 BlockDriver *drv;
898 Error *local_err = NULL;
900 assert(bs->file == NULL);
901 assert(options != NULL && bs->options != options);
903 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
904 qemu_opts_absorb_qdict(opts, options, &local_err);
905 if (local_err) {
906 error_propagate(errp, local_err);
907 ret = -EINVAL;
908 goto fail_opts;
911 driver_name = qemu_opt_get(opts, "driver");
912 drv = bdrv_find_format(driver_name);
913 assert(drv != NULL);
915 if (file != NULL) {
916 filename = file->bs->filename;
917 } else {
918 filename = qdict_get_try_str(options, "filename");
921 if (drv->bdrv_needs_filename && !filename) {
922 error_setg(errp, "The '%s' block driver requires a file name",
923 drv->format_name);
924 ret = -EINVAL;
925 goto fail_opts;
928 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
929 drv->format_name);
931 node_name = qemu_opt_get(opts, "node-name");
932 bdrv_assign_node_name(bs, node_name, &local_err);
933 if (local_err) {
934 error_propagate(errp, local_err);
935 ret = -EINVAL;
936 goto fail_opts;
939 bs->request_alignment = 512;
940 bs->zero_beyond_eof = true;
941 bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
943 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
944 error_setg(errp,
945 !bs->read_only && bdrv_is_whitelisted(drv, true)
946 ? "Driver '%s' can only be used for read-only devices"
947 : "Driver '%s' is not whitelisted",
948 drv->format_name);
949 ret = -ENOTSUP;
950 goto fail_opts;
953 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
954 if (bs->open_flags & BDRV_O_COPY_ON_READ) {
955 if (!bs->read_only) {
956 bdrv_enable_copy_on_read(bs);
957 } else {
958 error_setg(errp, "Can't use copy-on-read on read-only device");
959 ret = -EINVAL;
960 goto fail_opts;
964 if (filename != NULL) {
965 pstrcpy(bs->filename, sizeof(bs->filename), filename);
966 } else {
967 bs->filename[0] = '\0';
969 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
971 bs->drv = drv;
972 bs->opaque = g_malloc0(drv->instance_size);
974 /* Apply cache mode options */
975 update_flags_from_options(&bs->open_flags, opts);
976 bdrv_set_enable_write_cache(bs, bs->open_flags & BDRV_O_CACHE_WB);
978 /* Open the image, either directly or using a protocol */
979 open_flags = bdrv_open_flags(bs, bs->open_flags);
980 if (drv->bdrv_file_open) {
981 assert(file == NULL);
982 assert(!drv->bdrv_needs_filename || filename != NULL);
983 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
984 } else {
985 if (file == NULL) {
986 error_setg(errp, "Can't use '%s' as a block driver for the "
987 "protocol level", drv->format_name);
988 ret = -EINVAL;
989 goto free_and_fail;
991 bs->file = file;
992 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
995 if (ret < 0) {
996 if (local_err) {
997 error_propagate(errp, local_err);
998 } else if (bs->filename[0]) {
999 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1000 } else {
1001 error_setg_errno(errp, -ret, "Could not open image");
1003 goto free_and_fail;
1006 if (bs->encrypted) {
1007 error_report("Encrypted images are deprecated");
1008 error_printf("Support for them will be removed in a future release.\n"
1009 "You can use 'qemu-img convert' to convert your image"
1010 " to an unencrypted one.\n");
1013 ret = refresh_total_sectors(bs, bs->total_sectors);
1014 if (ret < 0) {
1015 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1016 goto free_and_fail;
1019 bdrv_refresh_limits(bs, &local_err);
1020 if (local_err) {
1021 error_propagate(errp, local_err);
1022 ret = -EINVAL;
1023 goto free_and_fail;
1026 assert(bdrv_opt_mem_align(bs) != 0);
1027 assert(bdrv_min_mem_align(bs) != 0);
1028 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
1030 qemu_opts_del(opts);
1031 return 0;
1033 free_and_fail:
1034 bs->file = NULL;
1035 g_free(bs->opaque);
1036 bs->opaque = NULL;
1037 bs->drv = NULL;
1038 fail_opts:
1039 qemu_opts_del(opts);
1040 return ret;
1043 static QDict *parse_json_filename(const char *filename, Error **errp)
1045 QObject *options_obj;
1046 QDict *options;
1047 int ret;
1049 ret = strstart(filename, "json:", &filename);
1050 assert(ret);
1052 options_obj = qobject_from_json(filename);
1053 if (!options_obj) {
1054 error_setg(errp, "Could not parse the JSON options");
1055 return NULL;
1058 if (qobject_type(options_obj) != QTYPE_QDICT) {
1059 qobject_decref(options_obj);
1060 error_setg(errp, "Invalid JSON object given");
1061 return NULL;
1064 options = qobject_to_qdict(options_obj);
1065 qdict_flatten(options);
1067 return options;
1070 static void parse_json_protocol(QDict *options, const char **pfilename,
1071 Error **errp)
1073 QDict *json_options;
1074 Error *local_err = NULL;
1076 /* Parse json: pseudo-protocol */
1077 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1078 return;
1081 json_options = parse_json_filename(*pfilename, &local_err);
1082 if (local_err) {
1083 error_propagate(errp, local_err);
1084 return;
1087 /* Options given in the filename have lower priority than options
1088 * specified directly */
1089 qdict_join(options, json_options, false);
1090 QDECREF(json_options);
1091 *pfilename = NULL;
1095 * Fills in default options for opening images and converts the legacy
1096 * filename/flags pair to option QDict entries.
1097 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1098 * block driver has been specified explicitly.
1100 static int bdrv_fill_options(QDict **options, const char *filename,
1101 int *flags, Error **errp)
1103 const char *drvname;
1104 bool protocol = *flags & BDRV_O_PROTOCOL;
1105 bool parse_filename = false;
1106 BlockDriver *drv = NULL;
1107 Error *local_err = NULL;
1109 drvname = qdict_get_try_str(*options, "driver");
1110 if (drvname) {
1111 drv = bdrv_find_format(drvname);
1112 if (!drv) {
1113 error_setg(errp, "Unknown driver '%s'", drvname);
1114 return -ENOENT;
1116 /* If the user has explicitly specified the driver, this choice should
1117 * override the BDRV_O_PROTOCOL flag */
1118 protocol = drv->bdrv_file_open;
1121 if (protocol) {
1122 *flags |= BDRV_O_PROTOCOL;
1123 } else {
1124 *flags &= ~BDRV_O_PROTOCOL;
1127 /* Translate cache options from flags into options */
1128 update_options_from_flags(*options, *flags);
1130 /* Fetch the file name from the options QDict if necessary */
1131 if (protocol && filename) {
1132 if (!qdict_haskey(*options, "filename")) {
1133 qdict_put(*options, "filename", qstring_from_str(filename));
1134 parse_filename = true;
1135 } else {
1136 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1137 "the same time");
1138 return -EINVAL;
1142 /* Find the right block driver */
1143 filename = qdict_get_try_str(*options, "filename");
1145 if (!drvname && protocol) {
1146 if (filename) {
1147 drv = bdrv_find_protocol(filename, parse_filename, errp);
1148 if (!drv) {
1149 return -EINVAL;
1152 drvname = drv->format_name;
1153 qdict_put(*options, "driver", qstring_from_str(drvname));
1154 } else {
1155 error_setg(errp, "Must specify either driver or file");
1156 return -EINVAL;
1160 assert(drv || !protocol);
1162 /* Driver-specific filename parsing */
1163 if (drv && drv->bdrv_parse_filename && parse_filename) {
1164 drv->bdrv_parse_filename(filename, *options, &local_err);
1165 if (local_err) {
1166 error_propagate(errp, local_err);
1167 return -EINVAL;
1170 if (!drv->bdrv_needs_filename) {
1171 qdict_del(*options, "filename");
1175 return 0;
1178 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
1179 const char *child_name,
1180 const BdrvChildRole *child_role)
1182 BdrvChild *child = g_new(BdrvChild, 1);
1183 *child = (BdrvChild) {
1184 .bs = child_bs,
1185 .name = g_strdup(child_name),
1186 .role = child_role,
1189 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1191 return child;
1194 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1195 BlockDriverState *child_bs,
1196 const char *child_name,
1197 const BdrvChildRole *child_role)
1199 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role);
1200 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1201 return child;
1204 static void bdrv_detach_child(BdrvChild *child)
1206 if (child->next.le_prev) {
1207 QLIST_REMOVE(child, next);
1208 child->next.le_prev = NULL;
1210 QLIST_REMOVE(child, next_parent);
1211 g_free(child->name);
1212 g_free(child);
1215 void bdrv_root_unref_child(BdrvChild *child)
1217 BlockDriverState *child_bs;
1219 child_bs = child->bs;
1220 bdrv_detach_child(child);
1221 bdrv_unref(child_bs);
1224 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1226 if (child == NULL) {
1227 return;
1230 if (child->bs->inherits_from == parent) {
1231 child->bs->inherits_from = NULL;
1234 bdrv_root_unref_child(child);
1238 * Sets the backing file link of a BDS. A new reference is created; callers
1239 * which don't need their own reference any more must call bdrv_unref().
1241 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1243 if (backing_hd) {
1244 bdrv_ref(backing_hd);
1247 if (bs->backing) {
1248 assert(bs->backing_blocker);
1249 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1250 bdrv_unref_child(bs, bs->backing);
1251 } else if (backing_hd) {
1252 error_setg(&bs->backing_blocker,
1253 "node is used as backing hd of '%s'",
1254 bdrv_get_device_or_node_name(bs));
1257 if (!backing_hd) {
1258 error_free(bs->backing_blocker);
1259 bs->backing_blocker = NULL;
1260 bs->backing = NULL;
1261 goto out;
1263 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
1264 bs->open_flags &= ~BDRV_O_NO_BACKING;
1265 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1266 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1267 backing_hd->drv ? backing_hd->drv->format_name : "");
1269 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1270 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1271 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1272 bs->backing_blocker);
1273 out:
1274 bdrv_refresh_limits(bs, NULL);
1278 * Opens the backing file for a BlockDriverState if not yet open
1280 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1281 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1282 * itself, all options starting with "${bdref_key}." are considered part of the
1283 * BlockdevRef.
1285 * TODO Can this be unified with bdrv_open_image()?
1287 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1288 const char *bdref_key, Error **errp)
1290 char *backing_filename = g_malloc0(PATH_MAX);
1291 char *bdref_key_dot;
1292 const char *reference = NULL;
1293 int ret = 0;
1294 BlockDriverState *backing_hd;
1295 QDict *options;
1296 QDict *tmp_parent_options = NULL;
1297 Error *local_err = NULL;
1299 if (bs->backing != NULL) {
1300 goto free_exit;
1303 /* NULL means an empty set of options */
1304 if (parent_options == NULL) {
1305 tmp_parent_options = qdict_new();
1306 parent_options = tmp_parent_options;
1309 bs->open_flags &= ~BDRV_O_NO_BACKING;
1311 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1312 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1313 g_free(bdref_key_dot);
1315 reference = qdict_get_try_str(parent_options, bdref_key);
1316 if (reference || qdict_haskey(options, "file.filename")) {
1317 backing_filename[0] = '\0';
1318 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1319 QDECREF(options);
1320 goto free_exit;
1321 } else {
1322 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1323 &local_err);
1324 if (local_err) {
1325 ret = -EINVAL;
1326 error_propagate(errp, local_err);
1327 QDECREF(options);
1328 goto free_exit;
1332 if (!bs->drv || !bs->drv->supports_backing) {
1333 ret = -EINVAL;
1334 error_setg(errp, "Driver doesn't support backing files");
1335 QDECREF(options);
1336 goto free_exit;
1339 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1340 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1343 backing_hd = NULL;
1344 ret = bdrv_open_inherit(&backing_hd,
1345 *backing_filename ? backing_filename : NULL,
1346 reference, options, 0, bs, &child_backing,
1347 errp);
1348 if (ret < 0) {
1349 bs->open_flags |= BDRV_O_NO_BACKING;
1350 error_prepend(errp, "Could not open backing file: ");
1351 goto free_exit;
1354 /* Hook up the backing file link; drop our reference, bs owns the
1355 * backing_hd reference now */
1356 bdrv_set_backing_hd(bs, backing_hd);
1357 bdrv_unref(backing_hd);
1359 qdict_del(parent_options, bdref_key);
1361 free_exit:
1362 g_free(backing_filename);
1363 QDECREF(tmp_parent_options);
1364 return ret;
1368 * Opens a disk image whose options are given as BlockdevRef in another block
1369 * device's options.
1371 * If allow_none is true, no image will be opened if filename is false and no
1372 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1374 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1375 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1376 * itself, all options starting with "${bdref_key}." are considered part of the
1377 * BlockdevRef.
1379 * The BlockdevRef will be removed from the options QDict.
1381 BdrvChild *bdrv_open_child(const char *filename,
1382 QDict *options, const char *bdref_key,
1383 BlockDriverState* parent,
1384 const BdrvChildRole *child_role,
1385 bool allow_none, Error **errp)
1387 BdrvChild *c = NULL;
1388 BlockDriverState *bs;
1389 QDict *image_options;
1390 int ret;
1391 char *bdref_key_dot;
1392 const char *reference;
1394 assert(child_role != NULL);
1396 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1397 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1398 g_free(bdref_key_dot);
1400 reference = qdict_get_try_str(options, bdref_key);
1401 if (!filename && !reference && !qdict_size(image_options)) {
1402 if (!allow_none) {
1403 error_setg(errp, "A block device must be specified for \"%s\"",
1404 bdref_key);
1406 QDECREF(image_options);
1407 goto done;
1410 bs = NULL;
1411 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1412 parent, child_role, errp);
1413 if (ret < 0) {
1414 goto done;
1417 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
1419 done:
1420 qdict_del(options, bdref_key);
1421 return c;
1424 static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags,
1425 QDict *snapshot_options, Error **errp)
1427 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1428 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1429 int64_t total_size;
1430 QemuOpts *opts = NULL;
1431 BlockDriverState *bs_snapshot;
1432 Error *local_err = NULL;
1433 int ret;
1435 /* if snapshot, we create a temporary backing file and open it
1436 instead of opening 'filename' directly */
1438 /* Get the required size from the image */
1439 total_size = bdrv_getlength(bs);
1440 if (total_size < 0) {
1441 ret = total_size;
1442 error_setg_errno(errp, -total_size, "Could not get image size");
1443 goto out;
1446 /* Create the temporary image */
1447 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1448 if (ret < 0) {
1449 error_setg_errno(errp, -ret, "Could not get temporary filename");
1450 goto out;
1453 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1454 &error_abort);
1455 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1456 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
1457 qemu_opts_del(opts);
1458 if (ret < 0) {
1459 error_prepend(errp, "Could not create temporary overlay '%s': ",
1460 tmp_filename);
1461 goto out;
1464 /* Prepare options QDict for the temporary file */
1465 qdict_put(snapshot_options, "file.driver",
1466 qstring_from_str("file"));
1467 qdict_put(snapshot_options, "file.filename",
1468 qstring_from_str(tmp_filename));
1469 qdict_put(snapshot_options, "driver",
1470 qstring_from_str("qcow2"));
1472 bs_snapshot = bdrv_new();
1474 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1475 flags, &local_err);
1476 snapshot_options = NULL;
1477 if (ret < 0) {
1478 error_propagate(errp, local_err);
1479 goto out;
1482 bdrv_append(bs_snapshot, bs);
1484 out:
1485 QDECREF(snapshot_options);
1486 g_free(tmp_filename);
1487 return ret;
1491 * Opens a disk image (raw, qcow2, vmdk, ...)
1493 * options is a QDict of options to pass to the block drivers, or NULL for an
1494 * empty set of options. The reference to the QDict belongs to the block layer
1495 * after the call (even on failure), so if the caller intends to reuse the
1496 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1498 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1499 * If it is not NULL, the referenced BDS will be reused.
1501 * The reference parameter may be used to specify an existing block device which
1502 * should be opened. If specified, neither options nor a filename may be given,
1503 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1505 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1506 const char *reference, QDict *options, int flags,
1507 BlockDriverState *parent,
1508 const BdrvChildRole *child_role, Error **errp)
1510 int ret;
1511 BdrvChild *file = NULL;
1512 BlockDriverState *bs;
1513 BlockDriver *drv = NULL;
1514 const char *drvname;
1515 const char *backing;
1516 Error *local_err = NULL;
1517 QDict *snapshot_options = NULL;
1518 int snapshot_flags = 0;
1520 assert(pbs);
1521 assert(!child_role || !flags);
1522 assert(!child_role == !parent);
1524 if (reference) {
1525 bool options_non_empty = options ? qdict_size(options) : false;
1526 QDECREF(options);
1528 if (*pbs) {
1529 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1530 "another block device");
1531 return -EINVAL;
1534 if (filename || options_non_empty) {
1535 error_setg(errp, "Cannot reference an existing block device with "
1536 "additional options or a new filename");
1537 return -EINVAL;
1540 bs = bdrv_lookup_bs(reference, reference, errp);
1541 if (!bs) {
1542 return -ENODEV;
1544 bdrv_ref(bs);
1545 *pbs = bs;
1546 return 0;
1549 if (*pbs) {
1550 bs = *pbs;
1551 } else {
1552 bs = bdrv_new();
1555 /* NULL means an empty set of options */
1556 if (options == NULL) {
1557 options = qdict_new();
1560 /* json: syntax counts as explicit options, as if in the QDict */
1561 parse_json_protocol(options, &filename, &local_err);
1562 if (local_err) {
1563 ret = -EINVAL;
1564 goto fail;
1567 bs->explicit_options = qdict_clone_shallow(options);
1569 if (child_role) {
1570 bs->inherits_from = parent;
1571 child_role->inherit_options(&flags, options,
1572 parent->open_flags, parent->options);
1575 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
1576 if (local_err) {
1577 goto fail;
1580 bs->open_flags = flags;
1581 bs->options = options;
1582 options = qdict_clone_shallow(options);
1584 /* Find the right image format driver */
1585 drvname = qdict_get_try_str(options, "driver");
1586 if (drvname) {
1587 drv = bdrv_find_format(drvname);
1588 if (!drv) {
1589 error_setg(errp, "Unknown driver: '%s'", drvname);
1590 ret = -EINVAL;
1591 goto fail;
1595 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1597 backing = qdict_get_try_str(options, "backing");
1598 if (backing && *backing == '\0') {
1599 flags |= BDRV_O_NO_BACKING;
1600 qdict_del(options, "backing");
1603 /* Open image file without format layer */
1604 if ((flags & BDRV_O_PROTOCOL) == 0) {
1605 if (flags & BDRV_O_RDWR) {
1606 flags |= BDRV_O_ALLOW_RDWR;
1608 if (flags & BDRV_O_SNAPSHOT) {
1609 snapshot_options = qdict_new();
1610 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options,
1611 flags, options);
1612 bdrv_backing_options(&flags, options, flags, options);
1615 bs->open_flags = flags;
1617 file = bdrv_open_child(filename, options, "file", bs,
1618 &child_file, true, &local_err);
1619 if (local_err) {
1620 ret = -EINVAL;
1621 goto fail;
1625 /* Image format probing */
1626 bs->probed = !drv;
1627 if (!drv && file) {
1628 ret = find_image_format(file->bs, filename, &drv, &local_err);
1629 if (ret < 0) {
1630 goto fail;
1633 * This option update would logically belong in bdrv_fill_options(),
1634 * but we first need to open bs->file for the probing to work, while
1635 * opening bs->file already requires the (mostly) final set of options
1636 * so that cache mode etc. can be inherited.
1638 * Adding the driver later is somewhat ugly, but it's not an option
1639 * that would ever be inherited, so it's correct. We just need to make
1640 * sure to update both bs->options (which has the full effective
1641 * options for bs) and options (which has file.* already removed).
1643 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1644 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1645 } else if (!drv) {
1646 error_setg(errp, "Must specify either driver or file");
1647 ret = -EINVAL;
1648 goto fail;
1651 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1652 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1653 /* file must be NULL if a protocol BDS is about to be created
1654 * (the inverse results in an error message from bdrv_open_common()) */
1655 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1657 /* Open the image */
1658 ret = bdrv_open_common(bs, file, options, &local_err);
1659 if (ret < 0) {
1660 goto fail;
1663 if (file && (bs->file != file)) {
1664 bdrv_unref_child(bs, file);
1665 file = NULL;
1668 /* If there is a backing file, use it */
1669 if ((flags & BDRV_O_NO_BACKING) == 0) {
1670 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
1671 if (ret < 0) {
1672 goto close_and_fail;
1676 bdrv_refresh_filename(bs);
1678 /* Check if any unknown options were used */
1679 if (options && (qdict_size(options) != 0)) {
1680 const QDictEntry *entry = qdict_first(options);
1681 if (flags & BDRV_O_PROTOCOL) {
1682 error_setg(errp, "Block protocol '%s' doesn't support the option "
1683 "'%s'", drv->format_name, entry->key);
1684 } else {
1685 error_setg(errp,
1686 "Block format '%s' does not support the option '%s'",
1687 drv->format_name, entry->key);
1690 ret = -EINVAL;
1691 goto close_and_fail;
1694 if (!bdrv_key_required(bs)) {
1695 if (bs->blk) {
1696 blk_dev_change_media_cb(bs->blk, true);
1698 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1699 && !runstate_check(RUN_STATE_INMIGRATE)
1700 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1701 error_setg(errp,
1702 "Guest must be stopped for opening of encrypted image");
1703 ret = -EBUSY;
1704 goto close_and_fail;
1707 QDECREF(options);
1708 *pbs = bs;
1710 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1711 * temporary snapshot afterwards. */
1712 if (snapshot_flags) {
1713 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options,
1714 &local_err);
1715 snapshot_options = NULL;
1716 if (local_err) {
1717 goto close_and_fail;
1721 return 0;
1723 fail:
1724 if (file != NULL) {
1725 bdrv_unref_child(bs, file);
1727 QDECREF(snapshot_options);
1728 QDECREF(bs->explicit_options);
1729 QDECREF(bs->options);
1730 QDECREF(options);
1731 bs->options = NULL;
1732 if (!*pbs) {
1733 /* If *pbs is NULL, a new BDS has been created in this function and
1734 needs to be freed now. Otherwise, it does not need to be closed,
1735 since it has not really been opened yet. */
1736 bdrv_unref(bs);
1738 if (local_err) {
1739 error_propagate(errp, local_err);
1741 return ret;
1743 close_and_fail:
1744 /* See fail path, but now the BDS has to be always closed */
1745 if (*pbs) {
1746 bdrv_close(bs);
1747 } else {
1748 bdrv_unref(bs);
1750 QDECREF(snapshot_options);
1751 QDECREF(options);
1752 if (local_err) {
1753 error_propagate(errp, local_err);
1755 return ret;
1758 int bdrv_open(BlockDriverState **pbs, const char *filename,
1759 const char *reference, QDict *options, int flags, Error **errp)
1761 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1762 NULL, errp);
1765 typedef struct BlockReopenQueueEntry {
1766 bool prepared;
1767 BDRVReopenState state;
1768 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1769 } BlockReopenQueueEntry;
1772 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1773 * reopen of multiple devices.
1775 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1776 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1777 * be created and initialized. This newly created BlockReopenQueue should be
1778 * passed back in for subsequent calls that are intended to be of the same
1779 * atomic 'set'.
1781 * bs is the BlockDriverState to add to the reopen queue.
1783 * options contains the changed options for the associated bs
1784 * (the BlockReopenQueue takes ownership)
1786 * flags contains the open flags for the associated bs
1788 * returns a pointer to bs_queue, which is either the newly allocated
1789 * bs_queue, or the existing bs_queue being used.
1792 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1793 BlockDriverState *bs,
1794 QDict *options,
1795 int flags,
1796 const BdrvChildRole *role,
1797 QDict *parent_options,
1798 int parent_flags)
1800 assert(bs != NULL);
1802 BlockReopenQueueEntry *bs_entry;
1803 BdrvChild *child;
1804 QDict *old_options, *explicit_options;
1806 if (bs_queue == NULL) {
1807 bs_queue = g_new0(BlockReopenQueue, 1);
1808 QSIMPLEQ_INIT(bs_queue);
1811 if (!options) {
1812 options = qdict_new();
1816 * Precedence of options:
1817 * 1. Explicitly passed in options (highest)
1818 * 2. Set in flags (only for top level)
1819 * 3. Retained from explicitly set options of bs
1820 * 4. Inherited from parent node
1821 * 5. Retained from effective options of bs
1824 if (!parent_options) {
1826 * Any setting represented by flags is always updated. If the
1827 * corresponding QDict option is set, it takes precedence. Otherwise
1828 * the flag is translated into a QDict option. The old setting of bs is
1829 * not considered.
1831 update_options_from_flags(options, flags);
1834 /* Old explicitly set values (don't overwrite by inherited value) */
1835 old_options = qdict_clone_shallow(bs->explicit_options);
1836 bdrv_join_options(bs, options, old_options);
1837 QDECREF(old_options);
1839 explicit_options = qdict_clone_shallow(options);
1841 /* Inherit from parent node */
1842 if (parent_options) {
1843 assert(!flags);
1844 role->inherit_options(&flags, options, parent_flags, parent_options);
1847 /* Old values are used for options that aren't set yet */
1848 old_options = qdict_clone_shallow(bs->options);
1849 bdrv_join_options(bs, options, old_options);
1850 QDECREF(old_options);
1852 /* bdrv_open() masks this flag out */
1853 flags &= ~BDRV_O_PROTOCOL;
1855 QLIST_FOREACH(child, &bs->children, next) {
1856 QDict *new_child_options;
1857 char *child_key_dot;
1859 /* reopen can only change the options of block devices that were
1860 * implicitly created and inherited options. For other (referenced)
1861 * block devices, a syntax like "backing.foo" results in an error. */
1862 if (child->bs->inherits_from != bs) {
1863 continue;
1866 child_key_dot = g_strdup_printf("%s.", child->name);
1867 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1868 g_free(child_key_dot);
1870 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1871 child->role, options, flags);
1874 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1875 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1877 bs_entry->state.bs = bs;
1878 bs_entry->state.options = options;
1879 bs_entry->state.explicit_options = explicit_options;
1880 bs_entry->state.flags = flags;
1882 return bs_queue;
1885 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1886 BlockDriverState *bs,
1887 QDict *options, int flags)
1889 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1890 NULL, NULL, 0);
1894 * Reopen multiple BlockDriverStates atomically & transactionally.
1896 * The queue passed in (bs_queue) must have been built up previous
1897 * via bdrv_reopen_queue().
1899 * Reopens all BDS specified in the queue, with the appropriate
1900 * flags. All devices are prepared for reopen, and failure of any
1901 * device will cause all device changes to be abandonded, and intermediate
1902 * data cleaned up.
1904 * If all devices prepare successfully, then the changes are committed
1905 * to all devices.
1908 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1910 int ret = -1;
1911 BlockReopenQueueEntry *bs_entry, *next;
1912 Error *local_err = NULL;
1914 assert(bs_queue != NULL);
1916 bdrv_drain_all();
1918 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1919 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1920 error_propagate(errp, local_err);
1921 goto cleanup;
1923 bs_entry->prepared = true;
1926 /* If we reach this point, we have success and just need to apply the
1927 * changes
1929 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1930 bdrv_reopen_commit(&bs_entry->state);
1933 ret = 0;
1935 cleanup:
1936 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1937 if (ret && bs_entry->prepared) {
1938 bdrv_reopen_abort(&bs_entry->state);
1939 } else if (ret) {
1940 QDECREF(bs_entry->state.explicit_options);
1942 QDECREF(bs_entry->state.options);
1943 g_free(bs_entry);
1945 g_free(bs_queue);
1946 return ret;
1950 /* Reopen a single BlockDriverState with the specified flags. */
1951 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1953 int ret = -1;
1954 Error *local_err = NULL;
1955 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1957 ret = bdrv_reopen_multiple(queue, &local_err);
1958 if (local_err != NULL) {
1959 error_propagate(errp, local_err);
1961 return ret;
1966 * Prepares a BlockDriverState for reopen. All changes are staged in the
1967 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1968 * the block driver layer .bdrv_reopen_prepare()
1970 * bs is the BlockDriverState to reopen
1971 * flags are the new open flags
1972 * queue is the reopen queue
1974 * Returns 0 on success, non-zero on error. On error errp will be set
1975 * as well.
1977 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1978 * It is the responsibility of the caller to then call the abort() or
1979 * commit() for any other BDS that have been left in a prepare() state
1982 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1983 Error **errp)
1985 int ret = -1;
1986 Error *local_err = NULL;
1987 BlockDriver *drv;
1988 QemuOpts *opts;
1989 const char *value;
1991 assert(reopen_state != NULL);
1992 assert(reopen_state->bs->drv != NULL);
1993 drv = reopen_state->bs->drv;
1995 /* Process generic block layer options */
1996 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1997 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
1998 if (local_err) {
1999 error_propagate(errp, local_err);
2000 ret = -EINVAL;
2001 goto error;
2004 update_flags_from_options(&reopen_state->flags, opts);
2006 /* If a guest device is attached, it owns WCE */
2007 if (reopen_state->bs->blk && blk_get_attached_dev(reopen_state->bs->blk)) {
2008 bool old_wce = bdrv_enable_write_cache(reopen_state->bs);
2009 bool new_wce = (reopen_state->flags & BDRV_O_CACHE_WB);
2010 if (old_wce != new_wce) {
2011 error_setg(errp, "Cannot change cache.writeback: Device attached");
2012 ret = -EINVAL;
2013 goto error;
2017 /* node-name and driver must be unchanged. Put them back into the QDict, so
2018 * that they are checked at the end of this function. */
2019 value = qemu_opt_get(opts, "node-name");
2020 if (value) {
2021 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2024 value = qemu_opt_get(opts, "driver");
2025 if (value) {
2026 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2029 /* if we are to stay read-only, do not allow permission change
2030 * to r/w */
2031 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2032 reopen_state->flags & BDRV_O_RDWR) {
2033 error_setg(errp, "Node '%s' is read only",
2034 bdrv_get_device_or_node_name(reopen_state->bs));
2035 goto error;
2039 ret = bdrv_flush(reopen_state->bs);
2040 if (ret) {
2041 error_setg_errno(errp, -ret, "Error flushing drive");
2042 goto error;
2045 if (drv->bdrv_reopen_prepare) {
2046 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2047 if (ret) {
2048 if (local_err != NULL) {
2049 error_propagate(errp, local_err);
2050 } else {
2051 error_setg(errp, "failed while preparing to reopen image '%s'",
2052 reopen_state->bs->filename);
2054 goto error;
2056 } else {
2057 /* It is currently mandatory to have a bdrv_reopen_prepare()
2058 * handler for each supported drv. */
2059 error_setg(errp, "Block format '%s' used by node '%s' "
2060 "does not support reopening files", drv->format_name,
2061 bdrv_get_device_or_node_name(reopen_state->bs));
2062 ret = -1;
2063 goto error;
2066 /* Options that are not handled are only okay if they are unchanged
2067 * compared to the old state. It is expected that some options are only
2068 * used for the initial open, but not reopen (e.g. filename) */
2069 if (qdict_size(reopen_state->options)) {
2070 const QDictEntry *entry = qdict_first(reopen_state->options);
2072 do {
2073 QString *new_obj = qobject_to_qstring(entry->value);
2074 const char *new = qstring_get_str(new_obj);
2075 const char *old = qdict_get_try_str(reopen_state->bs->options,
2076 entry->key);
2078 if (!old || strcmp(new, old)) {
2079 error_setg(errp, "Cannot change the option '%s'", entry->key);
2080 ret = -EINVAL;
2081 goto error;
2083 } while ((entry = qdict_next(reopen_state->options, entry)));
2086 ret = 0;
2088 error:
2089 qemu_opts_del(opts);
2090 return ret;
2094 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2095 * makes them final by swapping the staging BlockDriverState contents into
2096 * the active BlockDriverState contents.
2098 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2100 BlockDriver *drv;
2102 assert(reopen_state != NULL);
2103 drv = reopen_state->bs->drv;
2104 assert(drv != NULL);
2106 /* If there are any driver level actions to take */
2107 if (drv->bdrv_reopen_commit) {
2108 drv->bdrv_reopen_commit(reopen_state);
2111 /* set BDS specific flags now */
2112 QDECREF(reopen_state->bs->explicit_options);
2114 reopen_state->bs->explicit_options = reopen_state->explicit_options;
2115 reopen_state->bs->open_flags = reopen_state->flags;
2116 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
2117 BDRV_O_CACHE_WB);
2118 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
2120 bdrv_refresh_limits(reopen_state->bs, NULL);
2124 * Abort the reopen, and delete and free the staged changes in
2125 * reopen_state
2127 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2129 BlockDriver *drv;
2131 assert(reopen_state != NULL);
2132 drv = reopen_state->bs->drv;
2133 assert(drv != NULL);
2135 if (drv->bdrv_reopen_abort) {
2136 drv->bdrv_reopen_abort(reopen_state);
2139 QDECREF(reopen_state->explicit_options);
2143 static void bdrv_close(BlockDriverState *bs)
2145 BdrvAioNotifier *ban, *ban_next;
2147 assert(!bs->job);
2149 /* Disable I/O limits and drain all pending throttled requests */
2150 if (bs->throttle_state) {
2151 bdrv_io_limits_disable(bs);
2154 bdrv_drained_begin(bs); /* complete I/O */
2155 bdrv_flush(bs);
2156 bdrv_drain(bs); /* in case flush left pending I/O */
2158 bdrv_release_named_dirty_bitmaps(bs);
2159 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2161 if (bs->blk) {
2162 blk_dev_change_media_cb(bs->blk, false);
2165 if (bs->drv) {
2166 BdrvChild *child, *next;
2168 bs->drv->bdrv_close(bs);
2169 bs->drv = NULL;
2171 bdrv_set_backing_hd(bs, NULL);
2173 if (bs->file != NULL) {
2174 bdrv_unref_child(bs, bs->file);
2175 bs->file = NULL;
2178 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
2179 /* TODO Remove bdrv_unref() from drivers' close function and use
2180 * bdrv_unref_child() here */
2181 if (child->bs->inherits_from == bs) {
2182 child->bs->inherits_from = NULL;
2184 bdrv_detach_child(child);
2187 g_free(bs->opaque);
2188 bs->opaque = NULL;
2189 bs->copy_on_read = 0;
2190 bs->backing_file[0] = '\0';
2191 bs->backing_format[0] = '\0';
2192 bs->total_sectors = 0;
2193 bs->encrypted = 0;
2194 bs->valid_key = 0;
2195 bs->sg = 0;
2196 bs->zero_beyond_eof = false;
2197 QDECREF(bs->options);
2198 QDECREF(bs->explicit_options);
2199 bs->options = NULL;
2200 QDECREF(bs->full_open_options);
2201 bs->full_open_options = NULL;
2204 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2205 g_free(ban);
2207 QLIST_INIT(&bs->aio_notifiers);
2208 bdrv_drained_end(bs);
2211 void bdrv_close_all(void)
2213 BlockDriverState *bs;
2214 AioContext *aio_context;
2216 /* Drop references from requests still in flight, such as canceled block
2217 * jobs whose AIO context has not been polled yet */
2218 bdrv_drain_all();
2220 blk_remove_all_bs();
2221 blockdev_close_all_bdrv_states();
2223 /* Cancel all block jobs */
2224 while (!QTAILQ_EMPTY(&all_bdrv_states)) {
2225 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) {
2226 aio_context = bdrv_get_aio_context(bs);
2228 aio_context_acquire(aio_context);
2229 if (bs->job) {
2230 block_job_cancel_sync(bs->job);
2231 aio_context_release(aio_context);
2232 break;
2234 aio_context_release(aio_context);
2237 /* All the remaining BlockDriverStates are referenced directly or
2238 * indirectly from block jobs, so there needs to be at least one BDS
2239 * directly used by a block job */
2240 assert(bs);
2244 /* make a BlockDriverState anonymous by removing from graph_bdrv_state list.
2245 * Also, NULL terminate the device_name to prevent double remove */
2246 void bdrv_make_anon(BlockDriverState *bs)
2248 if (bs->node_name[0] != '\0') {
2249 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2251 bs->node_name[0] = '\0';
2254 /* Fields that need to stay with the top-level BDS */
2255 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2256 BlockDriverState *bs_src)
2258 /* move some fields that need to stay attached to the device */
2260 /* dev info */
2261 bs_dest->copy_on_read = bs_src->copy_on_read;
2263 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2265 /* dirty bitmap */
2266 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2269 static void change_parent_backing_link(BlockDriverState *from,
2270 BlockDriverState *to)
2272 BdrvChild *c, *next;
2274 if (from->blk) {
2275 /* FIXME We bypass blk_set_bs(), so we need to make these updates
2276 * manually. The root problem is not in this change function, but the
2277 * existence of BlockDriverState.blk. */
2278 to->blk = from->blk;
2279 from->blk = NULL;
2282 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2283 assert(c->role != &child_backing);
2284 c->bs = to;
2285 QLIST_REMOVE(c, next_parent);
2286 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2287 bdrv_ref(to);
2288 bdrv_unref(from);
2292 static void swap_feature_fields(BlockDriverState *bs_top,
2293 BlockDriverState *bs_new)
2295 BlockDriverState tmp;
2297 bdrv_move_feature_fields(&tmp, bs_top);
2298 bdrv_move_feature_fields(bs_top, bs_new);
2299 bdrv_move_feature_fields(bs_new, &tmp);
2301 assert(!bs_new->throttle_state);
2302 if (bs_top->throttle_state) {
2303 assert(bs_top->io_limits_enabled);
2304 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2305 bdrv_io_limits_disable(bs_top);
2310 * Add new bs contents at the top of an image chain while the chain is
2311 * live, while keeping required fields on the top layer.
2313 * This will modify the BlockDriverState fields, and swap contents
2314 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2316 * bs_new must not be attached to a BlockBackend.
2318 * This function does not create any image files.
2320 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2321 * that's what the callers commonly need. bs_new will be referenced by the old
2322 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2323 * reference of its own, it must call bdrv_ref().
2325 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2327 assert(!bdrv_requests_pending(bs_top));
2328 assert(!bdrv_requests_pending(bs_new));
2330 bdrv_ref(bs_top);
2331 change_parent_backing_link(bs_top, bs_new);
2333 /* Some fields always stay on top of the backing file chain */
2334 swap_feature_fields(bs_top, bs_new);
2336 bdrv_set_backing_hd(bs_new, bs_top);
2337 bdrv_unref(bs_top);
2339 /* bs_new is now referenced by its new parents, we don't need the
2340 * additional reference any more. */
2341 bdrv_unref(bs_new);
2344 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2346 assert(!bdrv_requests_pending(old));
2347 assert(!bdrv_requests_pending(new));
2349 bdrv_ref(old);
2351 if (old->blk) {
2352 /* As long as these fields aren't in BlockBackend, but in the top-level
2353 * BlockDriverState, it's not possible for a BDS to have two BBs.
2355 * We really want to copy the fields from old to new, but we go for a
2356 * swap instead so that pointers aren't duplicated and cause trouble.
2357 * (Also, bdrv_swap() used to do the same.) */
2358 assert(!new->blk);
2359 swap_feature_fields(old, new);
2361 change_parent_backing_link(old, new);
2363 /* Change backing files if a previously independent node is added to the
2364 * chain. For active commit, we replace top by its own (indirect) backing
2365 * file and don't do anything here so we don't build a loop. */
2366 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2367 bdrv_set_backing_hd(new, backing_bs(old));
2368 bdrv_set_backing_hd(old, NULL);
2371 bdrv_unref(old);
2374 static void bdrv_delete(BlockDriverState *bs)
2376 assert(!bs->job);
2377 assert(bdrv_op_blocker_is_empty(bs));
2378 assert(!bs->refcnt);
2380 bdrv_close(bs);
2382 /* remove from list, if necessary */
2383 bdrv_make_anon(bs);
2385 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list);
2387 g_free(bs);
2391 * Run consistency checks on an image
2393 * Returns 0 if the check could be completed (it doesn't mean that the image is
2394 * free of errors) or -errno when an internal error occurred. The results of the
2395 * check are stored in res.
2397 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2399 if (bs->drv == NULL) {
2400 return -ENOMEDIUM;
2402 if (bs->drv->bdrv_check == NULL) {
2403 return -ENOTSUP;
2406 memset(res, 0, sizeof(*res));
2407 return bs->drv->bdrv_check(bs, res, fix);
2410 #define COMMIT_BUF_SECTORS 2048
2412 /* commit COW file into the raw image */
2413 int bdrv_commit(BlockDriverState *bs)
2415 BlockDriver *drv = bs->drv;
2416 int64_t sector, total_sectors, length, backing_length;
2417 int n, ro, open_flags;
2418 int ret = 0;
2419 uint8_t *buf = NULL;
2421 if (!drv)
2422 return -ENOMEDIUM;
2424 if (!bs->backing) {
2425 return -ENOTSUP;
2428 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2429 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2430 return -EBUSY;
2433 ro = bs->backing->bs->read_only;
2434 open_flags = bs->backing->bs->open_flags;
2436 if (ro) {
2437 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2438 return -EACCES;
2442 length = bdrv_getlength(bs);
2443 if (length < 0) {
2444 ret = length;
2445 goto ro_cleanup;
2448 backing_length = bdrv_getlength(bs->backing->bs);
2449 if (backing_length < 0) {
2450 ret = backing_length;
2451 goto ro_cleanup;
2454 /* If our top snapshot is larger than the backing file image,
2455 * grow the backing file image if possible. If not possible,
2456 * we must return an error */
2457 if (length > backing_length) {
2458 ret = bdrv_truncate(bs->backing->bs, length);
2459 if (ret < 0) {
2460 goto ro_cleanup;
2464 total_sectors = length >> BDRV_SECTOR_BITS;
2466 /* qemu_try_blockalign() for bs will choose an alignment that works for
2467 * bs->backing->bs as well, so no need to compare the alignment manually. */
2468 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2469 if (buf == NULL) {
2470 ret = -ENOMEM;
2471 goto ro_cleanup;
2474 for (sector = 0; sector < total_sectors; sector += n) {
2475 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2476 if (ret < 0) {
2477 goto ro_cleanup;
2479 if (ret) {
2480 ret = bdrv_read(bs, sector, buf, n);
2481 if (ret < 0) {
2482 goto ro_cleanup;
2485 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2486 if (ret < 0) {
2487 goto ro_cleanup;
2492 if (drv->bdrv_make_empty) {
2493 ret = drv->bdrv_make_empty(bs);
2494 if (ret < 0) {
2495 goto ro_cleanup;
2497 bdrv_flush(bs);
2501 * Make sure all data we wrote to the backing device is actually
2502 * stable on disk.
2504 if (bs->backing) {
2505 bdrv_flush(bs->backing->bs);
2508 ret = 0;
2509 ro_cleanup:
2510 qemu_vfree(buf);
2512 if (ro) {
2513 /* ignoring error return here */
2514 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2517 return ret;
2521 * Return values:
2522 * 0 - success
2523 * -EINVAL - backing format specified, but no file
2524 * -ENOSPC - can't update the backing file because no space is left in the
2525 * image file header
2526 * -ENOTSUP - format driver doesn't support changing the backing file
2528 int bdrv_change_backing_file(BlockDriverState *bs,
2529 const char *backing_file, const char *backing_fmt)
2531 BlockDriver *drv = bs->drv;
2532 int ret;
2534 /* Backing file format doesn't make sense without a backing file */
2535 if (backing_fmt && !backing_file) {
2536 return -EINVAL;
2539 if (drv->bdrv_change_backing_file != NULL) {
2540 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2541 } else {
2542 ret = -ENOTSUP;
2545 if (ret == 0) {
2546 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2547 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2549 return ret;
2553 * Finds the image layer in the chain that has 'bs' as its backing file.
2555 * active is the current topmost image.
2557 * Returns NULL if bs is not found in active's image chain,
2558 * or if active == bs.
2560 * Returns the bottommost base image if bs == NULL.
2562 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2563 BlockDriverState *bs)
2565 while (active && bs != backing_bs(active)) {
2566 active = backing_bs(active);
2569 return active;
2572 /* Given a BDS, searches for the base layer. */
2573 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2575 return bdrv_find_overlay(bs, NULL);
2579 * Drops images above 'base' up to and including 'top', and sets the image
2580 * above 'top' to have base as its backing file.
2582 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2583 * information in 'bs' can be properly updated.
2585 * E.g., this will convert the following chain:
2586 * bottom <- base <- intermediate <- top <- active
2588 * to
2590 * bottom <- base <- active
2592 * It is allowed for bottom==base, in which case it converts:
2594 * base <- intermediate <- top <- active
2596 * to
2598 * base <- active
2600 * If backing_file_str is non-NULL, it will be used when modifying top's
2601 * overlay image metadata.
2603 * Error conditions:
2604 * if active == top, that is considered an error
2607 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2608 BlockDriverState *base, const char *backing_file_str)
2610 BlockDriverState *new_top_bs = NULL;
2611 int ret = -EIO;
2613 if (!top->drv || !base->drv) {
2614 goto exit;
2617 new_top_bs = bdrv_find_overlay(active, top);
2619 if (new_top_bs == NULL) {
2620 /* we could not find the image above 'top', this is an error */
2621 goto exit;
2624 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2625 * to do, no intermediate images */
2626 if (backing_bs(new_top_bs) == base) {
2627 ret = 0;
2628 goto exit;
2631 /* Make sure that base is in the backing chain of top */
2632 if (!bdrv_chain_contains(top, base)) {
2633 goto exit;
2636 /* success - we can delete the intermediate states, and link top->base */
2637 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2638 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2639 base->drv ? base->drv->format_name : "");
2640 if (ret) {
2641 goto exit;
2643 bdrv_set_backing_hd(new_top_bs, base);
2645 ret = 0;
2646 exit:
2647 return ret;
2651 * Truncate file to 'offset' bytes (needed only for file protocols)
2653 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2655 BlockDriver *drv = bs->drv;
2656 int ret;
2657 if (!drv)
2658 return -ENOMEDIUM;
2659 if (!drv->bdrv_truncate)
2660 return -ENOTSUP;
2661 if (bs->read_only)
2662 return -EACCES;
2664 ret = drv->bdrv_truncate(bs, offset);
2665 if (ret == 0) {
2666 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2667 bdrv_dirty_bitmap_truncate(bs);
2668 if (bs->blk) {
2669 blk_dev_resize_cb(bs->blk);
2672 return ret;
2676 * Length of a allocated file in bytes. Sparse files are counted by actual
2677 * allocated space. Return < 0 if error or unknown.
2679 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2681 BlockDriver *drv = bs->drv;
2682 if (!drv) {
2683 return -ENOMEDIUM;
2685 if (drv->bdrv_get_allocated_file_size) {
2686 return drv->bdrv_get_allocated_file_size(bs);
2688 if (bs->file) {
2689 return bdrv_get_allocated_file_size(bs->file->bs);
2691 return -ENOTSUP;
2695 * Return number of sectors on success, -errno on error.
2697 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2699 BlockDriver *drv = bs->drv;
2701 if (!drv)
2702 return -ENOMEDIUM;
2704 if (drv->has_variable_length) {
2705 int ret = refresh_total_sectors(bs, bs->total_sectors);
2706 if (ret < 0) {
2707 return ret;
2710 return bs->total_sectors;
2714 * Return length in bytes on success, -errno on error.
2715 * The length is always a multiple of BDRV_SECTOR_SIZE.
2717 int64_t bdrv_getlength(BlockDriverState *bs)
2719 int64_t ret = bdrv_nb_sectors(bs);
2721 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2722 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2725 /* return 0 as number of sectors if no device present or error */
2726 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2728 int64_t nb_sectors = bdrv_nb_sectors(bs);
2730 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2733 int bdrv_is_read_only(BlockDriverState *bs)
2735 return bs->read_only;
2738 int bdrv_is_sg(BlockDriverState *bs)
2740 return bs->sg;
2743 int bdrv_enable_write_cache(BlockDriverState *bs)
2745 return bs->enable_write_cache;
2748 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2750 bs->enable_write_cache = wce;
2752 /* so a reopen() will preserve wce */
2753 if (wce) {
2754 bs->open_flags |= BDRV_O_CACHE_WB;
2755 } else {
2756 bs->open_flags &= ~BDRV_O_CACHE_WB;
2760 int bdrv_is_encrypted(BlockDriverState *bs)
2762 if (bs->backing && bs->backing->bs->encrypted) {
2763 return 1;
2765 return bs->encrypted;
2768 int bdrv_key_required(BlockDriverState *bs)
2770 BdrvChild *backing = bs->backing;
2772 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2773 return 1;
2775 return (bs->encrypted && !bs->valid_key);
2778 int bdrv_set_key(BlockDriverState *bs, const char *key)
2780 int ret;
2781 if (bs->backing && bs->backing->bs->encrypted) {
2782 ret = bdrv_set_key(bs->backing->bs, key);
2783 if (ret < 0)
2784 return ret;
2785 if (!bs->encrypted)
2786 return 0;
2788 if (!bs->encrypted) {
2789 return -EINVAL;
2790 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2791 return -ENOMEDIUM;
2793 ret = bs->drv->bdrv_set_key(bs, key);
2794 if (ret < 0) {
2795 bs->valid_key = 0;
2796 } else if (!bs->valid_key) {
2797 bs->valid_key = 1;
2798 if (bs->blk) {
2799 /* call the change callback now, we skipped it on open */
2800 blk_dev_change_media_cb(bs->blk, true);
2803 return ret;
2807 * Provide an encryption key for @bs.
2808 * If @key is non-null:
2809 * If @bs is not encrypted, fail.
2810 * Else if the key is invalid, fail.
2811 * Else set @bs's key to @key, replacing the existing key, if any.
2812 * If @key is null:
2813 * If @bs is encrypted and still lacks a key, fail.
2814 * Else do nothing.
2815 * On failure, store an error object through @errp if non-null.
2817 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2819 if (key) {
2820 if (!bdrv_is_encrypted(bs)) {
2821 error_setg(errp, "Node '%s' is not encrypted",
2822 bdrv_get_device_or_node_name(bs));
2823 } else if (bdrv_set_key(bs, key) < 0) {
2824 error_setg(errp, QERR_INVALID_PASSWORD);
2826 } else {
2827 if (bdrv_key_required(bs)) {
2828 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2829 "'%s' (%s) is encrypted",
2830 bdrv_get_device_or_node_name(bs),
2831 bdrv_get_encrypted_filename(bs));
2836 const char *bdrv_get_format_name(BlockDriverState *bs)
2838 return bs->drv ? bs->drv->format_name : NULL;
2841 static int qsort_strcmp(const void *a, const void *b)
2843 return strcmp(a, b);
2846 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2847 void *opaque)
2849 BlockDriver *drv;
2850 int count = 0;
2851 int i;
2852 const char **formats = NULL;
2854 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2855 if (drv->format_name) {
2856 bool found = false;
2857 int i = count;
2858 while (formats && i && !found) {
2859 found = !strcmp(formats[--i], drv->format_name);
2862 if (!found) {
2863 formats = g_renew(const char *, formats, count + 1);
2864 formats[count++] = drv->format_name;
2869 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2871 for (i = 0; i < count; i++) {
2872 it(opaque, formats[i]);
2875 g_free(formats);
2878 /* This function is to find a node in the bs graph */
2879 BlockDriverState *bdrv_find_node(const char *node_name)
2881 BlockDriverState *bs;
2883 assert(node_name);
2885 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2886 if (!strcmp(node_name, bs->node_name)) {
2887 return bs;
2890 return NULL;
2893 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2894 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2896 BlockDeviceInfoList *list, *entry;
2897 BlockDriverState *bs;
2899 list = NULL;
2900 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2901 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2902 if (!info) {
2903 qapi_free_BlockDeviceInfoList(list);
2904 return NULL;
2906 entry = g_malloc0(sizeof(*entry));
2907 entry->value = info;
2908 entry->next = list;
2909 list = entry;
2912 return list;
2915 BlockDriverState *bdrv_lookup_bs(const char *device,
2916 const char *node_name,
2917 Error **errp)
2919 BlockBackend *blk;
2920 BlockDriverState *bs;
2922 if (device) {
2923 blk = blk_by_name(device);
2925 if (blk) {
2926 bs = blk_bs(blk);
2927 if (!bs) {
2928 error_setg(errp, "Device '%s' has no medium", device);
2931 return bs;
2935 if (node_name) {
2936 bs = bdrv_find_node(node_name);
2938 if (bs) {
2939 return bs;
2943 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2944 device ? device : "",
2945 node_name ? node_name : "");
2946 return NULL;
2949 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2950 * return false. If either argument is NULL, return false. */
2951 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2953 while (top && top != base) {
2954 top = backing_bs(top);
2957 return top != NULL;
2960 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2962 if (!bs) {
2963 return QTAILQ_FIRST(&graph_bdrv_states);
2965 return QTAILQ_NEXT(bs, node_list);
2968 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by
2969 * the monitor or attached to a BlockBackend */
2970 BlockDriverState *bdrv_next(BlockDriverState *bs)
2972 if (!bs || bs->blk) {
2973 bs = blk_next_root_bs(bs);
2974 if (bs) {
2975 return bs;
2979 /* Ignore all BDSs that are attached to a BlockBackend here; they have been
2980 * handled by the above block already */
2981 do {
2982 bs = bdrv_next_monitor_owned(bs);
2983 } while (bs && bs->blk);
2984 return bs;
2987 const char *bdrv_get_node_name(const BlockDriverState *bs)
2989 return bs->node_name;
2992 /* TODO check what callers really want: bs->node_name or blk_name() */
2993 const char *bdrv_get_device_name(const BlockDriverState *bs)
2995 return bs->blk ? blk_name(bs->blk) : "";
2998 /* This can be used to identify nodes that might not have a device
2999 * name associated. Since node and device names live in the same
3000 * namespace, the result is unambiguous. The exception is if both are
3001 * absent, then this returns an empty (non-null) string. */
3002 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
3004 return bs->blk ? blk_name(bs->blk) : bs->node_name;
3007 int bdrv_get_flags(BlockDriverState *bs)
3009 return bs->open_flags;
3012 int bdrv_has_zero_init_1(BlockDriverState *bs)
3014 return 1;
3017 int bdrv_has_zero_init(BlockDriverState *bs)
3019 assert(bs->drv);
3021 /* If BS is a copy on write image, it is initialized to
3022 the contents of the base image, which may not be zeroes. */
3023 if (bs->backing) {
3024 return 0;
3026 if (bs->drv->bdrv_has_zero_init) {
3027 return bs->drv->bdrv_has_zero_init(bs);
3030 /* safe default */
3031 return 0;
3034 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3036 BlockDriverInfo bdi;
3038 if (bs->backing) {
3039 return false;
3042 if (bdrv_get_info(bs, &bdi) == 0) {
3043 return bdi.unallocated_blocks_are_zero;
3046 return false;
3049 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3051 BlockDriverInfo bdi;
3053 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
3054 return false;
3057 if (bdrv_get_info(bs, &bdi) == 0) {
3058 return bdi.can_write_zeroes_with_unmap;
3061 return false;
3064 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3066 if (bs->backing && bs->backing->bs->encrypted)
3067 return bs->backing_file;
3068 else if (bs->encrypted)
3069 return bs->filename;
3070 else
3071 return NULL;
3074 void bdrv_get_backing_filename(BlockDriverState *bs,
3075 char *filename, int filename_size)
3077 pstrcpy(filename, filename_size, bs->backing_file);
3080 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3082 BlockDriver *drv = bs->drv;
3083 if (!drv)
3084 return -ENOMEDIUM;
3085 if (!drv->bdrv_get_info)
3086 return -ENOTSUP;
3087 memset(bdi, 0, sizeof(*bdi));
3088 return drv->bdrv_get_info(bs, bdi);
3091 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3093 BlockDriver *drv = bs->drv;
3094 if (drv && drv->bdrv_get_specific_info) {
3095 return drv->bdrv_get_specific_info(bs);
3097 return NULL;
3100 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
3102 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3103 return;
3106 bs->drv->bdrv_debug_event(bs, event);
3109 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3110 const char *tag)
3112 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3113 bs = bs->file ? bs->file->bs : NULL;
3116 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3117 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3120 return -ENOTSUP;
3123 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3125 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3126 bs = bs->file ? bs->file->bs : NULL;
3129 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3130 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3133 return -ENOTSUP;
3136 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3138 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3139 bs = bs->file ? bs->file->bs : NULL;
3142 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3143 return bs->drv->bdrv_debug_resume(bs, tag);
3146 return -ENOTSUP;
3149 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3151 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3152 bs = bs->file ? bs->file->bs : NULL;
3155 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3156 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3159 return false;
3162 int bdrv_is_snapshot(BlockDriverState *bs)
3164 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3167 /* backing_file can either be relative, or absolute, or a protocol. If it is
3168 * relative, it must be relative to the chain. So, passing in bs->filename
3169 * from a BDS as backing_file should not be done, as that may be relative to
3170 * the CWD rather than the chain. */
3171 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3172 const char *backing_file)
3174 char *filename_full = NULL;
3175 char *backing_file_full = NULL;
3176 char *filename_tmp = NULL;
3177 int is_protocol = 0;
3178 BlockDriverState *curr_bs = NULL;
3179 BlockDriverState *retval = NULL;
3181 if (!bs || !bs->drv || !backing_file) {
3182 return NULL;
3185 filename_full = g_malloc(PATH_MAX);
3186 backing_file_full = g_malloc(PATH_MAX);
3187 filename_tmp = g_malloc(PATH_MAX);
3189 is_protocol = path_has_protocol(backing_file);
3191 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3193 /* If either of the filename paths is actually a protocol, then
3194 * compare unmodified paths; otherwise make paths relative */
3195 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3196 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3197 retval = curr_bs->backing->bs;
3198 break;
3200 } else {
3201 /* If not an absolute filename path, make it relative to the current
3202 * image's filename path */
3203 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3204 backing_file);
3206 /* We are going to compare absolute pathnames */
3207 if (!realpath(filename_tmp, filename_full)) {
3208 continue;
3211 /* We need to make sure the backing filename we are comparing against
3212 * is relative to the current image filename (or absolute) */
3213 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3214 curr_bs->backing_file);
3216 if (!realpath(filename_tmp, backing_file_full)) {
3217 continue;
3220 if (strcmp(backing_file_full, filename_full) == 0) {
3221 retval = curr_bs->backing->bs;
3222 break;
3227 g_free(filename_full);
3228 g_free(backing_file_full);
3229 g_free(filename_tmp);
3230 return retval;
3233 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3235 if (!bs->drv) {
3236 return 0;
3239 if (!bs->backing) {
3240 return 0;
3243 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3246 void bdrv_init(void)
3248 module_call_init(MODULE_INIT_BLOCK);
3251 void bdrv_init_with_whitelist(void)
3253 use_bdrv_whitelist = 1;
3254 bdrv_init();
3257 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3259 Error *local_err = NULL;
3260 int ret;
3262 if (!bs->drv) {
3263 return;
3266 if (!(bs->open_flags & BDRV_O_INACTIVE)) {
3267 return;
3269 bs->open_flags &= ~BDRV_O_INACTIVE;
3271 if (bs->drv->bdrv_invalidate_cache) {
3272 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3273 } else if (bs->file) {
3274 bdrv_invalidate_cache(bs->file->bs, &local_err);
3276 if (local_err) {
3277 bs->open_flags |= BDRV_O_INACTIVE;
3278 error_propagate(errp, local_err);
3279 return;
3282 ret = refresh_total_sectors(bs, bs->total_sectors);
3283 if (ret < 0) {
3284 bs->open_flags |= BDRV_O_INACTIVE;
3285 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3286 return;
3290 void bdrv_invalidate_cache_all(Error **errp)
3292 BlockDriverState *bs = NULL;
3293 Error *local_err = NULL;
3295 while ((bs = bdrv_next(bs)) != NULL) {
3296 AioContext *aio_context = bdrv_get_aio_context(bs);
3298 aio_context_acquire(aio_context);
3299 bdrv_invalidate_cache(bs, &local_err);
3300 aio_context_release(aio_context);
3301 if (local_err) {
3302 error_propagate(errp, local_err);
3303 return;
3308 static int bdrv_inactivate(BlockDriverState *bs)
3310 int ret;
3312 if (bs->drv->bdrv_inactivate) {
3313 ret = bs->drv->bdrv_inactivate(bs);
3314 if (ret < 0) {
3315 return ret;
3319 bs->open_flags |= BDRV_O_INACTIVE;
3320 return 0;
3323 int bdrv_inactivate_all(void)
3325 BlockDriverState *bs = NULL;
3326 int ret;
3328 while ((bs = bdrv_next(bs)) != NULL) {
3329 AioContext *aio_context = bdrv_get_aio_context(bs);
3331 aio_context_acquire(aio_context);
3332 ret = bdrv_inactivate(bs);
3333 aio_context_release(aio_context);
3334 if (ret < 0) {
3335 return ret;
3339 return 0;
3342 /**************************************************************/
3343 /* removable device support */
3346 * Return TRUE if the media is present
3348 bool bdrv_is_inserted(BlockDriverState *bs)
3350 BlockDriver *drv = bs->drv;
3351 BdrvChild *child;
3353 if (!drv) {
3354 return false;
3356 if (drv->bdrv_is_inserted) {
3357 return drv->bdrv_is_inserted(bs);
3359 QLIST_FOREACH(child, &bs->children, next) {
3360 if (!bdrv_is_inserted(child->bs)) {
3361 return false;
3364 return true;
3368 * Return whether the media changed since the last call to this
3369 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3371 int bdrv_media_changed(BlockDriverState *bs)
3373 BlockDriver *drv = bs->drv;
3375 if (drv && drv->bdrv_media_changed) {
3376 return drv->bdrv_media_changed(bs);
3378 return -ENOTSUP;
3382 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3384 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3386 BlockDriver *drv = bs->drv;
3387 const char *device_name;
3389 if (drv && drv->bdrv_eject) {
3390 drv->bdrv_eject(bs, eject_flag);
3393 device_name = bdrv_get_device_name(bs);
3394 if (device_name[0] != '\0') {
3395 qapi_event_send_device_tray_moved(device_name,
3396 eject_flag, &error_abort);
3401 * Lock or unlock the media (if it is locked, the user won't be able
3402 * to eject it manually).
3404 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3406 BlockDriver *drv = bs->drv;
3408 trace_bdrv_lock_medium(bs, locked);
3410 if (drv && drv->bdrv_lock_medium) {
3411 drv->bdrv_lock_medium(bs, locked);
3415 /* Get a reference to bs */
3416 void bdrv_ref(BlockDriverState *bs)
3418 bs->refcnt++;
3421 /* Release a previously grabbed reference to bs.
3422 * If after releasing, reference count is zero, the BlockDriverState is
3423 * deleted. */
3424 void bdrv_unref(BlockDriverState *bs)
3426 if (!bs) {
3427 return;
3429 assert(bs->refcnt > 0);
3430 if (--bs->refcnt == 0) {
3431 bdrv_delete(bs);
3435 struct BdrvOpBlocker {
3436 Error *reason;
3437 QLIST_ENTRY(BdrvOpBlocker) list;
3440 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3442 BdrvOpBlocker *blocker;
3443 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3444 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3445 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3446 if (errp) {
3447 *errp = error_copy(blocker->reason);
3448 error_prepend(errp, "Node '%s' is busy: ",
3449 bdrv_get_device_or_node_name(bs));
3451 return true;
3453 return false;
3456 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3458 BdrvOpBlocker *blocker;
3459 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3461 blocker = g_new0(BdrvOpBlocker, 1);
3462 blocker->reason = reason;
3463 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3466 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3468 BdrvOpBlocker *blocker, *next;
3469 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3470 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3471 if (blocker->reason == reason) {
3472 QLIST_REMOVE(blocker, list);
3473 g_free(blocker);
3478 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3480 int i;
3481 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3482 bdrv_op_block(bs, i, reason);
3486 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3488 int i;
3489 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3490 bdrv_op_unblock(bs, i, reason);
3494 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3496 int i;
3498 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3499 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3500 return false;
3503 return true;
3506 void bdrv_img_create(const char *filename, const char *fmt,
3507 const char *base_filename, const char *base_fmt,
3508 char *options, uint64_t img_size, int flags,
3509 Error **errp, bool quiet)
3511 QemuOptsList *create_opts = NULL;
3512 QemuOpts *opts = NULL;
3513 const char *backing_fmt, *backing_file;
3514 int64_t size;
3515 BlockDriver *drv, *proto_drv;
3516 Error *local_err = NULL;
3517 int ret = 0;
3519 /* Find driver and parse its options */
3520 drv = bdrv_find_format(fmt);
3521 if (!drv) {
3522 error_setg(errp, "Unknown file format '%s'", fmt);
3523 return;
3526 proto_drv = bdrv_find_protocol(filename, true, errp);
3527 if (!proto_drv) {
3528 return;
3531 if (!drv->create_opts) {
3532 error_setg(errp, "Format driver '%s' does not support image creation",
3533 drv->format_name);
3534 return;
3537 if (!proto_drv->create_opts) {
3538 error_setg(errp, "Protocol driver '%s' does not support image creation",
3539 proto_drv->format_name);
3540 return;
3543 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3544 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3546 /* Create parameter list with default values */
3547 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3548 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3550 /* Parse -o options */
3551 if (options) {
3552 qemu_opts_do_parse(opts, options, NULL, &local_err);
3553 if (local_err) {
3554 error_report_err(local_err);
3555 local_err = NULL;
3556 error_setg(errp, "Invalid options for file format '%s'", fmt);
3557 goto out;
3561 if (base_filename) {
3562 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3563 if (local_err) {
3564 error_setg(errp, "Backing file not supported for file format '%s'",
3565 fmt);
3566 goto out;
3570 if (base_fmt) {
3571 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3572 if (local_err) {
3573 error_setg(errp, "Backing file format not supported for file "
3574 "format '%s'", fmt);
3575 goto out;
3579 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3580 if (backing_file) {
3581 if (!strcmp(filename, backing_file)) {
3582 error_setg(errp, "Error: Trying to create an image with the "
3583 "same filename as the backing file");
3584 goto out;
3588 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3590 // The size for the image must always be specified, with one exception:
3591 // If we are using a backing file, we can obtain the size from there
3592 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3593 if (size == -1) {
3594 if (backing_file) {
3595 BlockDriverState *bs;
3596 char *full_backing = g_new0(char, PATH_MAX);
3597 int64_t size;
3598 int back_flags;
3599 QDict *backing_options = NULL;
3601 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3602 full_backing, PATH_MAX,
3603 &local_err);
3604 if (local_err) {
3605 g_free(full_backing);
3606 goto out;
3609 /* backing files always opened read-only */
3610 back_flags =
3611 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3613 if (backing_fmt) {
3614 backing_options = qdict_new();
3615 qdict_put(backing_options, "driver",
3616 qstring_from_str(backing_fmt));
3619 bs = NULL;
3620 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3621 back_flags, &local_err);
3622 g_free(full_backing);
3623 if (ret < 0) {
3624 goto out;
3626 size = bdrv_getlength(bs);
3627 if (size < 0) {
3628 error_setg_errno(errp, -size, "Could not get size of '%s'",
3629 backing_file);
3630 bdrv_unref(bs);
3631 goto out;
3634 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3636 bdrv_unref(bs);
3637 } else {
3638 error_setg(errp, "Image creation needs a size parameter");
3639 goto out;
3643 if (!quiet) {
3644 printf("Formatting '%s', fmt=%s ", filename, fmt);
3645 qemu_opts_print(opts, " ");
3646 puts("");
3649 ret = bdrv_create(drv, filename, opts, &local_err);
3651 if (ret == -EFBIG) {
3652 /* This is generally a better message than whatever the driver would
3653 * deliver (especially because of the cluster_size_hint), since that
3654 * is most probably not much different from "image too large". */
3655 const char *cluster_size_hint = "";
3656 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3657 cluster_size_hint = " (try using a larger cluster size)";
3659 error_setg(errp, "The image size is too large for file format '%s'"
3660 "%s", fmt, cluster_size_hint);
3661 error_free(local_err);
3662 local_err = NULL;
3665 out:
3666 qemu_opts_del(opts);
3667 qemu_opts_free(create_opts);
3668 if (local_err) {
3669 error_propagate(errp, local_err);
3673 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3675 return bs->aio_context;
3678 void bdrv_detach_aio_context(BlockDriverState *bs)
3680 BdrvAioNotifier *baf;
3682 if (!bs->drv) {
3683 return;
3686 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3687 baf->detach_aio_context(baf->opaque);
3690 if (bs->throttle_state) {
3691 throttle_timers_detach_aio_context(&bs->throttle_timers);
3693 if (bs->drv->bdrv_detach_aio_context) {
3694 bs->drv->bdrv_detach_aio_context(bs);
3696 if (bs->file) {
3697 bdrv_detach_aio_context(bs->file->bs);
3699 if (bs->backing) {
3700 bdrv_detach_aio_context(bs->backing->bs);
3703 bs->aio_context = NULL;
3706 void bdrv_attach_aio_context(BlockDriverState *bs,
3707 AioContext *new_context)
3709 BdrvAioNotifier *ban;
3711 if (!bs->drv) {
3712 return;
3715 bs->aio_context = new_context;
3717 if (bs->backing) {
3718 bdrv_attach_aio_context(bs->backing->bs, new_context);
3720 if (bs->file) {
3721 bdrv_attach_aio_context(bs->file->bs, new_context);
3723 if (bs->drv->bdrv_attach_aio_context) {
3724 bs->drv->bdrv_attach_aio_context(bs, new_context);
3726 if (bs->throttle_state) {
3727 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
3730 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
3731 ban->attached_aio_context(new_context, ban->opaque);
3735 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
3737 bdrv_drain(bs); /* ensure there are no in-flight requests */
3739 bdrv_detach_aio_context(bs);
3741 /* This function executes in the old AioContext so acquire the new one in
3742 * case it runs in a different thread.
3744 aio_context_acquire(new_context);
3745 bdrv_attach_aio_context(bs, new_context);
3746 aio_context_release(new_context);
3749 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
3750 void (*attached_aio_context)(AioContext *new_context, void *opaque),
3751 void (*detach_aio_context)(void *opaque), void *opaque)
3753 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
3754 *ban = (BdrvAioNotifier){
3755 .attached_aio_context = attached_aio_context,
3756 .detach_aio_context = detach_aio_context,
3757 .opaque = opaque
3760 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
3763 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
3764 void (*attached_aio_context)(AioContext *,
3765 void *),
3766 void (*detach_aio_context)(void *),
3767 void *opaque)
3769 BdrvAioNotifier *ban, *ban_next;
3771 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
3772 if (ban->attached_aio_context == attached_aio_context &&
3773 ban->detach_aio_context == detach_aio_context &&
3774 ban->opaque == opaque)
3776 QLIST_REMOVE(ban, list);
3777 g_free(ban);
3779 return;
3783 abort();
3786 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
3787 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
3789 if (!bs->drv->bdrv_amend_options) {
3790 return -ENOTSUP;
3792 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
3795 /* This function will be called by the bdrv_recurse_is_first_non_filter method
3796 * of block filter and by bdrv_is_first_non_filter.
3797 * It is used to test if the given bs is the candidate or recurse more in the
3798 * node graph.
3800 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
3801 BlockDriverState *candidate)
3803 /* return false if basic checks fails */
3804 if (!bs || !bs->drv) {
3805 return false;
3808 /* the code reached a non block filter driver -> check if the bs is
3809 * the same as the candidate. It's the recursion termination condition.
3811 if (!bs->drv->is_filter) {
3812 return bs == candidate;
3814 /* Down this path the driver is a block filter driver */
3816 /* If the block filter recursion method is defined use it to recurse down
3817 * the node graph.
3819 if (bs->drv->bdrv_recurse_is_first_non_filter) {
3820 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
3823 /* the driver is a block filter but don't allow to recurse -> return false
3825 return false;
3828 /* This function checks if the candidate is the first non filter bs down it's
3829 * bs chain. Since we don't have pointers to parents it explore all bs chains
3830 * from the top. Some filters can choose not to pass down the recursion.
3832 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
3834 BlockDriverState *bs = NULL;
3836 /* walk down the bs forest recursively */
3837 while ((bs = bdrv_next(bs)) != NULL) {
3838 bool perm;
3840 /* try to recurse in this top level bs */
3841 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
3843 /* candidate is the first non filter */
3844 if (perm) {
3845 return true;
3849 return false;
3852 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
3853 const char *node_name, Error **errp)
3855 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
3856 AioContext *aio_context;
3858 if (!to_replace_bs) {
3859 error_setg(errp, "Node name '%s' not found", node_name);
3860 return NULL;
3863 aio_context = bdrv_get_aio_context(to_replace_bs);
3864 aio_context_acquire(aio_context);
3866 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
3867 to_replace_bs = NULL;
3868 goto out;
3871 /* We don't want arbitrary node of the BDS chain to be replaced only the top
3872 * most non filter in order to prevent data corruption.
3873 * Another benefit is that this tests exclude backing files which are
3874 * blocked by the backing blockers.
3876 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
3877 error_setg(errp, "Only top most non filter can be replaced");
3878 to_replace_bs = NULL;
3879 goto out;
3882 out:
3883 aio_context_release(aio_context);
3884 return to_replace_bs;
3887 static bool append_open_options(QDict *d, BlockDriverState *bs)
3889 const QDictEntry *entry;
3890 QemuOptDesc *desc;
3891 BdrvChild *child;
3892 bool found_any = false;
3893 const char *p;
3895 for (entry = qdict_first(bs->options); entry;
3896 entry = qdict_next(bs->options, entry))
3898 /* Exclude options for children */
3899 QLIST_FOREACH(child, &bs->children, next) {
3900 if (strstart(qdict_entry_key(entry), child->name, &p)
3901 && (!*p || *p == '.'))
3903 break;
3906 if (child) {
3907 continue;
3910 /* And exclude all non-driver-specific options */
3911 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
3912 if (!strcmp(qdict_entry_key(entry), desc->name)) {
3913 break;
3916 if (desc->name) {
3917 continue;
3920 qobject_incref(qdict_entry_value(entry));
3921 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
3922 found_any = true;
3925 return found_any;
3928 /* Updates the following BDS fields:
3929 * - exact_filename: A filename which may be used for opening a block device
3930 * which (mostly) equals the given BDS (even without any
3931 * other options; so reading and writing must return the same
3932 * results, but caching etc. may be different)
3933 * - full_open_options: Options which, when given when opening a block device
3934 * (without a filename), result in a BDS (mostly)
3935 * equalling the given one
3936 * - filename: If exact_filename is set, it is copied here. Otherwise,
3937 * full_open_options is converted to a JSON object, prefixed with
3938 * "json:" (for use through the JSON pseudo protocol) and put here.
3940 void bdrv_refresh_filename(BlockDriverState *bs)
3942 BlockDriver *drv = bs->drv;
3943 QDict *opts;
3945 if (!drv) {
3946 return;
3949 /* This BDS's file name will most probably depend on its file's name, so
3950 * refresh that first */
3951 if (bs->file) {
3952 bdrv_refresh_filename(bs->file->bs);
3955 if (drv->bdrv_refresh_filename) {
3956 /* Obsolete information is of no use here, so drop the old file name
3957 * information before refreshing it */
3958 bs->exact_filename[0] = '\0';
3959 if (bs->full_open_options) {
3960 QDECREF(bs->full_open_options);
3961 bs->full_open_options = NULL;
3964 opts = qdict_new();
3965 append_open_options(opts, bs);
3966 drv->bdrv_refresh_filename(bs, opts);
3967 QDECREF(opts);
3968 } else if (bs->file) {
3969 /* Try to reconstruct valid information from the underlying file */
3970 bool has_open_options;
3972 bs->exact_filename[0] = '\0';
3973 if (bs->full_open_options) {
3974 QDECREF(bs->full_open_options);
3975 bs->full_open_options = NULL;
3978 opts = qdict_new();
3979 has_open_options = append_open_options(opts, bs);
3981 /* If no specific options have been given for this BDS, the filename of
3982 * the underlying file should suffice for this one as well */
3983 if (bs->file->bs->exact_filename[0] && !has_open_options) {
3984 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
3986 /* Reconstructing the full options QDict is simple for most format block
3987 * drivers, as long as the full options are known for the underlying
3988 * file BDS. The full options QDict of that file BDS should somehow
3989 * contain a representation of the filename, therefore the following
3990 * suffices without querying the (exact_)filename of this BDS. */
3991 if (bs->file->bs->full_open_options) {
3992 qdict_put_obj(opts, "driver",
3993 QOBJECT(qstring_from_str(drv->format_name)));
3994 QINCREF(bs->file->bs->full_open_options);
3995 qdict_put_obj(opts, "file",
3996 QOBJECT(bs->file->bs->full_open_options));
3998 bs->full_open_options = opts;
3999 } else {
4000 QDECREF(opts);
4002 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4003 /* There is no underlying file BDS (at least referenced by BDS.file),
4004 * so the full options QDict should be equal to the options given
4005 * specifically for this block device when it was opened (plus the
4006 * driver specification).
4007 * Because those options don't change, there is no need to update
4008 * full_open_options when it's already set. */
4010 opts = qdict_new();
4011 append_open_options(opts, bs);
4012 qdict_put_obj(opts, "driver",
4013 QOBJECT(qstring_from_str(drv->format_name)));
4015 if (bs->exact_filename[0]) {
4016 /* This may not work for all block protocol drivers (some may
4017 * require this filename to be parsed), but we have to find some
4018 * default solution here, so just include it. If some block driver
4019 * does not support pure options without any filename at all or
4020 * needs some special format of the options QDict, it needs to
4021 * implement the driver-specific bdrv_refresh_filename() function.
4023 qdict_put_obj(opts, "filename",
4024 QOBJECT(qstring_from_str(bs->exact_filename)));
4027 bs->full_open_options = opts;
4030 if (bs->exact_filename[0]) {
4031 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4032 } else if (bs->full_open_options) {
4033 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4034 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4035 qstring_get_str(json));
4036 QDECREF(json);