scripts/dump-guest-memory.py: Move constants to the top
[qemu/ar7.git] / block.c
blob54c37f9629167d026cba618fff63007731e7eec2
1 /*
2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/error-report.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/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/types.h>
46 #include <sys/stat.h>
47 #include <sys/ioctl.h>
48 #include <sys/queue.h>
49 #ifndef __DragonFly__
50 #include <sys/disk.h>
51 #endif
52 #endif
54 #ifdef _WIN32
55 #include <windows.h>
56 #endif
58 /**
59 * A BdrvDirtyBitmap can be in three possible states:
60 * (1) successor is NULL and disabled is false: full r/w mode
61 * (2) successor is NULL and disabled is true: read only mode ("disabled")
62 * (3) successor is set: frozen mode.
63 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
64 * or enabled. A frozen bitmap can only abdicate() or reclaim().
66 struct BdrvDirtyBitmap {
67 HBitmap *bitmap; /* Dirty sector bitmap implementation */
68 BdrvDirtyBitmap *successor; /* Anonymous child; implies frozen status */
69 char *name; /* Optional non-empty unique ID */
70 int64_t size; /* Size of the bitmap (Number of sectors) */
71 bool disabled; /* Bitmap is read-only */
72 QLIST_ENTRY(BdrvDirtyBitmap) list;
75 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
77 struct BdrvStates bdrv_states = QTAILQ_HEAD_INITIALIZER(bdrv_states);
79 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
80 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
82 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
83 QLIST_HEAD_INITIALIZER(bdrv_drivers);
85 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
86 const char *reference, QDict *options, int flags,
87 BlockDriverState *parent,
88 const BdrvChildRole *child_role, Error **errp);
90 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs);
91 /* If non-zero, use only whitelisted block drivers */
92 static int use_bdrv_whitelist;
94 #ifdef _WIN32
95 static int is_windows_drive_prefix(const char *filename)
97 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
98 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
99 filename[1] == ':');
102 int is_windows_drive(const char *filename)
104 if (is_windows_drive_prefix(filename) &&
105 filename[2] == '\0')
106 return 1;
107 if (strstart(filename, "\\\\.\\", NULL) ||
108 strstart(filename, "//./", NULL))
109 return 1;
110 return 0;
112 #endif
114 size_t bdrv_opt_mem_align(BlockDriverState *bs)
116 if (!bs || !bs->drv) {
117 /* page size or 4k (hdd sector size) should be on the safe side */
118 return MAX(4096, getpagesize());
121 return bs->bl.opt_mem_alignment;
124 size_t bdrv_min_mem_align(BlockDriverState *bs)
126 if (!bs || !bs->drv) {
127 /* page size or 4k (hdd sector size) should be on the safe side */
128 return MAX(4096, getpagesize());
131 return bs->bl.min_mem_alignment;
134 /* check if the path starts with "<protocol>:" */
135 int path_has_protocol(const char *path)
137 const char *p;
139 #ifdef _WIN32
140 if (is_windows_drive(path) ||
141 is_windows_drive_prefix(path)) {
142 return 0;
144 p = path + strcspn(path, ":/\\");
145 #else
146 p = path + strcspn(path, ":/");
147 #endif
149 return *p == ':';
152 int path_is_absolute(const char *path)
154 #ifdef _WIN32
155 /* specific case for names like: "\\.\d:" */
156 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
157 return 1;
159 return (*path == '/' || *path == '\\');
160 #else
161 return (*path == '/');
162 #endif
165 /* if filename is absolute, just copy it to dest. Otherwise, build a
166 path to it by considering it is relative to base_path. URL are
167 supported. */
168 void path_combine(char *dest, int dest_size,
169 const char *base_path,
170 const char *filename)
172 const char *p, *p1;
173 int len;
175 if (dest_size <= 0)
176 return;
177 if (path_is_absolute(filename)) {
178 pstrcpy(dest, dest_size, filename);
179 } else {
180 p = strchr(base_path, ':');
181 if (p)
182 p++;
183 else
184 p = base_path;
185 p1 = strrchr(base_path, '/');
186 #ifdef _WIN32
188 const char *p2;
189 p2 = strrchr(base_path, '\\');
190 if (!p1 || p2 > p1)
191 p1 = p2;
193 #endif
194 if (p1)
195 p1++;
196 else
197 p1 = base_path;
198 if (p1 > p)
199 p = p1;
200 len = p - base_path;
201 if (len > dest_size - 1)
202 len = dest_size - 1;
203 memcpy(dest, base_path, len);
204 dest[len] = '\0';
205 pstrcat(dest, dest_size, filename);
209 void bdrv_get_full_backing_filename_from_filename(const char *backed,
210 const char *backing,
211 char *dest, size_t sz,
212 Error **errp)
214 if (backing[0] == '\0' || path_has_protocol(backing) ||
215 path_is_absolute(backing))
217 pstrcpy(dest, sz, backing);
218 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) {
219 error_setg(errp, "Cannot use relative backing file names for '%s'",
220 backed);
221 } else {
222 path_combine(dest, sz, backed, backing);
226 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz,
227 Error **errp)
229 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename;
231 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file,
232 dest, sz, errp);
235 void bdrv_register(BlockDriver *bdrv)
237 bdrv_setup_io_funcs(bdrv);
239 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
242 BlockDriverState *bdrv_new_root(void)
244 BlockDriverState *bs = bdrv_new();
246 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
247 return bs;
250 BlockDriverState *bdrv_new(void)
252 BlockDriverState *bs;
253 int i;
255 bs = g_new0(BlockDriverState, 1);
256 QLIST_INIT(&bs->dirty_bitmaps);
257 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
258 QLIST_INIT(&bs->op_blockers[i]);
260 notifier_list_init(&bs->close_notifiers);
261 notifier_with_return_list_init(&bs->before_write_notifiers);
262 qemu_co_queue_init(&bs->throttled_reqs[0]);
263 qemu_co_queue_init(&bs->throttled_reqs[1]);
264 bs->refcnt = 1;
265 bs->aio_context = qemu_get_aio_context();
267 return bs;
270 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
272 notifier_list_add(&bs->close_notifiers, notify);
275 BlockDriver *bdrv_find_format(const char *format_name)
277 BlockDriver *drv1;
278 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
279 if (!strcmp(drv1->format_name, format_name)) {
280 return drv1;
283 return NULL;
286 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
288 static const char *whitelist_rw[] = {
289 CONFIG_BDRV_RW_WHITELIST
291 static const char *whitelist_ro[] = {
292 CONFIG_BDRV_RO_WHITELIST
294 const char **p;
296 if (!whitelist_rw[0] && !whitelist_ro[0]) {
297 return 1; /* no whitelist, anything goes */
300 for (p = whitelist_rw; *p; p++) {
301 if (!strcmp(drv->format_name, *p)) {
302 return 1;
305 if (read_only) {
306 for (p = whitelist_ro; *p; p++) {
307 if (!strcmp(drv->format_name, *p)) {
308 return 1;
312 return 0;
315 typedef struct CreateCo {
316 BlockDriver *drv;
317 char *filename;
318 QemuOpts *opts;
319 int ret;
320 Error *err;
321 } CreateCo;
323 static void coroutine_fn bdrv_create_co_entry(void *opaque)
325 Error *local_err = NULL;
326 int ret;
328 CreateCo *cco = opaque;
329 assert(cco->drv);
331 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
332 if (local_err) {
333 error_propagate(&cco->err, local_err);
335 cco->ret = ret;
338 int bdrv_create(BlockDriver *drv, const char* filename,
339 QemuOpts *opts, Error **errp)
341 int ret;
343 Coroutine *co;
344 CreateCo cco = {
345 .drv = drv,
346 .filename = g_strdup(filename),
347 .opts = opts,
348 .ret = NOT_DONE,
349 .err = NULL,
352 if (!drv->bdrv_create) {
353 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
354 ret = -ENOTSUP;
355 goto out;
358 if (qemu_in_coroutine()) {
359 /* Fast-path if already in coroutine context */
360 bdrv_create_co_entry(&cco);
361 } else {
362 co = qemu_coroutine_create(bdrv_create_co_entry);
363 qemu_coroutine_enter(co, &cco);
364 while (cco.ret == NOT_DONE) {
365 aio_poll(qemu_get_aio_context(), true);
369 ret = cco.ret;
370 if (ret < 0) {
371 if (cco.err) {
372 error_propagate(errp, cco.err);
373 } else {
374 error_setg_errno(errp, -ret, "Could not create image");
378 out:
379 g_free(cco.filename);
380 return ret;
383 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
385 BlockDriver *drv;
386 Error *local_err = NULL;
387 int ret;
389 drv = bdrv_find_protocol(filename, true, errp);
390 if (drv == NULL) {
391 return -ENOENT;
394 ret = bdrv_create(drv, filename, opts, &local_err);
395 if (local_err) {
396 error_propagate(errp, local_err);
398 return ret;
402 * Try to get @bs's logical and physical block size.
403 * On success, store them in @bsz struct and return 0.
404 * On failure return -errno.
405 * @bs must not be empty.
407 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
409 BlockDriver *drv = bs->drv;
411 if (drv && drv->bdrv_probe_blocksizes) {
412 return drv->bdrv_probe_blocksizes(bs, bsz);
415 return -ENOTSUP;
419 * Try to get @bs's geometry (cyls, heads, sectors).
420 * On success, store them in @geo struct and return 0.
421 * On failure return -errno.
422 * @bs must not be empty.
424 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
426 BlockDriver *drv = bs->drv;
428 if (drv && drv->bdrv_probe_geometry) {
429 return drv->bdrv_probe_geometry(bs, geo);
432 return -ENOTSUP;
436 * Create a uniquely-named empty temporary file.
437 * Return 0 upon success, otherwise a negative errno value.
439 int get_tmp_filename(char *filename, int size)
441 #ifdef _WIN32
442 char temp_dir[MAX_PATH];
443 /* GetTempFileName requires that its output buffer (4th param)
444 have length MAX_PATH or greater. */
445 assert(size >= MAX_PATH);
446 return (GetTempPath(MAX_PATH, temp_dir)
447 && GetTempFileName(temp_dir, "qem", 0, filename)
448 ? 0 : -GetLastError());
449 #else
450 int fd;
451 const char *tmpdir;
452 tmpdir = getenv("TMPDIR");
453 if (!tmpdir) {
454 tmpdir = "/var/tmp";
456 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
457 return -EOVERFLOW;
459 fd = mkstemp(filename);
460 if (fd < 0) {
461 return -errno;
463 if (close(fd) != 0) {
464 unlink(filename);
465 return -errno;
467 return 0;
468 #endif
472 * Detect host devices. By convention, /dev/cdrom[N] is always
473 * recognized as a host CDROM.
475 static BlockDriver *find_hdev_driver(const char *filename)
477 int score_max = 0, score;
478 BlockDriver *drv = NULL, *d;
480 QLIST_FOREACH(d, &bdrv_drivers, list) {
481 if (d->bdrv_probe_device) {
482 score = d->bdrv_probe_device(filename);
483 if (score > score_max) {
484 score_max = score;
485 drv = d;
490 return drv;
493 BlockDriver *bdrv_find_protocol(const char *filename,
494 bool allow_protocol_prefix,
495 Error **errp)
497 BlockDriver *drv1;
498 char protocol[128];
499 int len;
500 const char *p;
502 /* TODO Drivers without bdrv_file_open must be specified explicitly */
505 * XXX(hch): we really should not let host device detection
506 * override an explicit protocol specification, but moving this
507 * later breaks access to device names with colons in them.
508 * Thanks to the brain-dead persistent naming schemes on udev-
509 * based Linux systems those actually are quite common.
511 drv1 = find_hdev_driver(filename);
512 if (drv1) {
513 return drv1;
516 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
517 return &bdrv_file;
520 p = strchr(filename, ':');
521 assert(p != NULL);
522 len = p - filename;
523 if (len > sizeof(protocol) - 1)
524 len = sizeof(protocol) - 1;
525 memcpy(protocol, filename, len);
526 protocol[len] = '\0';
527 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
528 if (drv1->protocol_name &&
529 !strcmp(drv1->protocol_name, protocol)) {
530 return drv1;
534 error_setg(errp, "Unknown protocol '%s'", protocol);
535 return NULL;
539 * Guess image format by probing its contents.
540 * This is not a good idea when your image is raw (CVE-2008-2004), but
541 * we do it anyway for backward compatibility.
543 * @buf contains the image's first @buf_size bytes.
544 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
545 * but can be smaller if the image file is smaller)
546 * @filename is its filename.
548 * For all block drivers, call the bdrv_probe() method to get its
549 * probing score.
550 * Return the first block driver with the highest probing score.
552 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
553 const char *filename)
555 int score_max = 0, score;
556 BlockDriver *drv = NULL, *d;
558 QLIST_FOREACH(d, &bdrv_drivers, list) {
559 if (d->bdrv_probe) {
560 score = d->bdrv_probe(buf, buf_size, filename);
561 if (score > score_max) {
562 score_max = score;
563 drv = d;
568 return drv;
571 static int find_image_format(BlockDriverState *bs, const char *filename,
572 BlockDriver **pdrv, Error **errp)
574 BlockDriver *drv;
575 uint8_t buf[BLOCK_PROBE_BUF_SIZE];
576 int ret = 0;
578 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
579 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
580 *pdrv = &bdrv_raw;
581 return ret;
584 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
585 if (ret < 0) {
586 error_setg_errno(errp, -ret, "Could not read image for determining its "
587 "format");
588 *pdrv = NULL;
589 return ret;
592 drv = bdrv_probe_all(buf, ret, filename);
593 if (!drv) {
594 error_setg(errp, "Could not determine image format: No compatible "
595 "driver found");
596 ret = -ENOENT;
598 *pdrv = drv;
599 return ret;
603 * Set the current 'total_sectors' value
604 * Return 0 on success, -errno on error.
606 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
608 BlockDriver *drv = bs->drv;
610 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
611 if (bdrv_is_sg(bs))
612 return 0;
614 /* query actual device if possible, otherwise just trust the hint */
615 if (drv->bdrv_getlength) {
616 int64_t length = drv->bdrv_getlength(bs);
617 if (length < 0) {
618 return length;
620 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
623 bs->total_sectors = hint;
624 return 0;
628 * Combines a QDict of new block driver @options with any missing options taken
629 * from @old_options, so that leaving out an option defaults to its old value.
631 static void bdrv_join_options(BlockDriverState *bs, QDict *options,
632 QDict *old_options)
634 if (bs->drv && bs->drv->bdrv_join_options) {
635 bs->drv->bdrv_join_options(options, old_options);
636 } else {
637 qdict_join(options, old_options, false);
642 * Set open flags for a given discard mode
644 * Return 0 on success, -1 if the discard mode was invalid.
646 int bdrv_parse_discard_flags(const char *mode, int *flags)
648 *flags &= ~BDRV_O_UNMAP;
650 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
651 /* do nothing */
652 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
653 *flags |= BDRV_O_UNMAP;
654 } else {
655 return -1;
658 return 0;
662 * Set open flags for a given cache mode
664 * Return 0 on success, -1 if the cache mode was invalid.
666 int bdrv_parse_cache_flags(const char *mode, int *flags)
668 *flags &= ~BDRV_O_CACHE_MASK;
670 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
671 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
672 } else if (!strcmp(mode, "directsync")) {
673 *flags |= BDRV_O_NOCACHE;
674 } else if (!strcmp(mode, "writeback")) {
675 *flags |= BDRV_O_CACHE_WB;
676 } else if (!strcmp(mode, "unsafe")) {
677 *flags |= BDRV_O_CACHE_WB;
678 *flags |= BDRV_O_NO_FLUSH;
679 } else if (!strcmp(mode, "writethrough")) {
680 /* this is the default */
681 } else {
682 return -1;
685 return 0;
689 * Returns the flags that a temporary snapshot should get, based on the
690 * originally requested flags (the originally requested image will have flags
691 * like a backing file)
693 static int bdrv_temp_snapshot_flags(int flags)
695 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
699 * Returns the options and flags that bs->file should get if a protocol driver
700 * is expected, based on the given options and flags for the parent BDS
702 static void bdrv_inherited_options(int *child_flags, QDict *child_options,
703 int parent_flags, QDict *parent_options)
705 int flags = parent_flags;
707 /* Enable protocol handling, disable format probing for bs->file */
708 flags |= BDRV_O_PROTOCOL;
710 /* If the cache mode isn't explicitly set, inherit direct and no-flush from
711 * the parent. */
712 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
713 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
715 /* Our block drivers take care to send flushes and respect unmap policy,
716 * so we can default to enable both on lower layers regardless of the
717 * corresponding parent options. */
718 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on");
719 flags |= BDRV_O_UNMAP;
721 /* Clear flags that only apply to the top layer */
722 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
724 *child_flags = flags;
727 const BdrvChildRole child_file = {
728 .inherit_options = bdrv_inherited_options,
732 * Returns the options and flags that bs->file should get if the use of formats
733 * (and not only protocols) is permitted for it, based on the given options and
734 * flags for the parent BDS
736 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options,
737 int parent_flags, QDict *parent_options)
739 child_file.inherit_options(child_flags, child_options,
740 parent_flags, parent_options);
742 *child_flags &= ~BDRV_O_PROTOCOL;
745 const BdrvChildRole child_format = {
746 .inherit_options = bdrv_inherited_fmt_options,
750 * Returns the options and flags that bs->backing should get, based on the
751 * given options and flags for the parent BDS
753 static void bdrv_backing_options(int *child_flags, QDict *child_options,
754 int parent_flags, QDict *parent_options)
756 int flags = parent_flags;
758 /* The cache mode is inherited unmodified for backing files */
759 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_WB);
760 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);
761 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);
763 /* backing files always opened read-only */
764 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
766 /* snapshot=on is handled on the top layer */
767 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
769 *child_flags = flags;
772 static const BdrvChildRole child_backing = {
773 .inherit_options = bdrv_backing_options,
776 static int bdrv_open_flags(BlockDriverState *bs, int flags)
778 int open_flags = flags | BDRV_O_CACHE_WB;
781 * Clear flags that are internal to the block layer before opening the
782 * image.
784 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
787 * Snapshots should be writable.
789 if (flags & BDRV_O_TEMPORARY) {
790 open_flags |= BDRV_O_RDWR;
793 return open_flags;
796 static void update_flags_from_options(int *flags, QemuOpts *opts)
798 *flags &= ~BDRV_O_CACHE_MASK;
800 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_WB));
801 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, false)) {
802 *flags |= BDRV_O_CACHE_WB;
805 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH));
806 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) {
807 *flags |= BDRV_O_NO_FLUSH;
810 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT));
811 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) {
812 *flags |= BDRV_O_NOCACHE;
816 static void update_options_from_flags(QDict *options, int flags)
818 if (!qdict_haskey(options, BDRV_OPT_CACHE_WB)) {
819 qdict_put(options, BDRV_OPT_CACHE_WB,
820 qbool_from_bool(flags & BDRV_O_CACHE_WB));
822 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) {
823 qdict_put(options, BDRV_OPT_CACHE_DIRECT,
824 qbool_from_bool(flags & BDRV_O_NOCACHE));
826 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) {
827 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH,
828 qbool_from_bool(flags & BDRV_O_NO_FLUSH));
832 static void bdrv_assign_node_name(BlockDriverState *bs,
833 const char *node_name,
834 Error **errp)
836 char *gen_node_name = NULL;
838 if (!node_name) {
839 node_name = gen_node_name = id_generate(ID_BLOCK);
840 } else if (!id_wellformed(node_name)) {
842 * Check for empty string or invalid characters, but not if it is
843 * generated (generated names use characters not available to the user)
845 error_setg(errp, "Invalid node name");
846 return;
849 /* takes care of avoiding namespaces collisions */
850 if (blk_by_name(node_name)) {
851 error_setg(errp, "node-name=%s is conflicting with a device id",
852 node_name);
853 goto out;
856 /* takes care of avoiding duplicates node names */
857 if (bdrv_find_node(node_name)) {
858 error_setg(errp, "Duplicate node name");
859 goto out;
862 /* copy node name into the bs and insert it into the graph list */
863 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
864 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
865 out:
866 g_free(gen_node_name);
869 static QemuOptsList bdrv_runtime_opts = {
870 .name = "bdrv_common",
871 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
872 .desc = {
874 .name = "node-name",
875 .type = QEMU_OPT_STRING,
876 .help = "Node name of the block device node",
879 .name = "driver",
880 .type = QEMU_OPT_STRING,
881 .help = "Block driver to use for the node",
884 .name = BDRV_OPT_CACHE_WB,
885 .type = QEMU_OPT_BOOL,
886 .help = "Enable writeback mode",
889 .name = BDRV_OPT_CACHE_DIRECT,
890 .type = QEMU_OPT_BOOL,
891 .help = "Bypass software writeback cache on the host",
894 .name = BDRV_OPT_CACHE_NO_FLUSH,
895 .type = QEMU_OPT_BOOL,
896 .help = "Ignore flush requests",
898 { /* end of list */ }
903 * Common part for opening disk images and files
905 * Removes all processed options from *options.
907 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
908 QDict *options, int flags, Error **errp)
910 int ret, open_flags;
911 const char *filename;
912 const char *driver_name = NULL;
913 const char *node_name = NULL;
914 QemuOpts *opts;
915 BlockDriver *drv;
916 Error *local_err = NULL;
918 assert(bs->file == NULL);
919 assert(options != NULL && bs->options != options);
921 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
922 qemu_opts_absorb_qdict(opts, options, &local_err);
923 if (local_err) {
924 error_propagate(errp, local_err);
925 ret = -EINVAL;
926 goto fail_opts;
929 driver_name = qemu_opt_get(opts, "driver");
930 drv = bdrv_find_format(driver_name);
931 assert(drv != NULL);
933 if (file != NULL) {
934 filename = file->bs->filename;
935 } else {
936 filename = qdict_get_try_str(options, "filename");
939 if (drv->bdrv_needs_filename && !filename) {
940 error_setg(errp, "The '%s' block driver requires a file name",
941 drv->format_name);
942 ret = -EINVAL;
943 goto fail_opts;
946 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
948 node_name = qemu_opt_get(opts, "node-name");
949 bdrv_assign_node_name(bs, node_name, &local_err);
950 if (local_err) {
951 error_propagate(errp, local_err);
952 ret = -EINVAL;
953 goto fail_opts;
956 bs->request_alignment = 512;
957 bs->zero_beyond_eof = true;
958 open_flags = bdrv_open_flags(bs, flags);
959 bs->read_only = !(open_flags & BDRV_O_RDWR);
961 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
962 error_setg(errp,
963 !bs->read_only && bdrv_is_whitelisted(drv, true)
964 ? "Driver '%s' can only be used for read-only devices"
965 : "Driver '%s' is not whitelisted",
966 drv->format_name);
967 ret = -ENOTSUP;
968 goto fail_opts;
971 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
972 if (flags & BDRV_O_COPY_ON_READ) {
973 if (!bs->read_only) {
974 bdrv_enable_copy_on_read(bs);
975 } else {
976 error_setg(errp, "Can't use copy-on-read on read-only device");
977 ret = -EINVAL;
978 goto fail_opts;
982 if (filename != NULL) {
983 pstrcpy(bs->filename, sizeof(bs->filename), filename);
984 } else {
985 bs->filename[0] = '\0';
987 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
989 bs->drv = drv;
990 bs->opaque = g_malloc0(drv->instance_size);
992 /* Apply cache mode options */
993 update_flags_from_options(&bs->open_flags, opts);
994 bdrv_set_enable_write_cache(bs, bs->open_flags & BDRV_O_CACHE_WB);
996 /* Open the image, either directly or using a protocol */
997 if (drv->bdrv_file_open) {
998 assert(file == NULL);
999 assert(!drv->bdrv_needs_filename || filename != NULL);
1000 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
1001 } else {
1002 if (file == NULL) {
1003 error_setg(errp, "Can't use '%s' as a block driver for the "
1004 "protocol level", drv->format_name);
1005 ret = -EINVAL;
1006 goto free_and_fail;
1008 bs->file = file;
1009 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
1012 if (ret < 0) {
1013 if (local_err) {
1014 error_propagate(errp, local_err);
1015 } else if (bs->filename[0]) {
1016 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
1017 } else {
1018 error_setg_errno(errp, -ret, "Could not open image");
1020 goto free_and_fail;
1023 if (bs->encrypted) {
1024 error_report("Encrypted images are deprecated");
1025 error_printf("Support for them will be removed in a future release.\n"
1026 "You can use 'qemu-img convert' to convert your image"
1027 " to an unencrypted one.\n");
1030 ret = refresh_total_sectors(bs, bs->total_sectors);
1031 if (ret < 0) {
1032 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1033 goto free_and_fail;
1036 bdrv_refresh_limits(bs, &local_err);
1037 if (local_err) {
1038 error_propagate(errp, local_err);
1039 ret = -EINVAL;
1040 goto free_and_fail;
1043 assert(bdrv_opt_mem_align(bs) != 0);
1044 assert(bdrv_min_mem_align(bs) != 0);
1045 assert((bs->request_alignment != 0) || bdrv_is_sg(bs));
1047 qemu_opts_del(opts);
1048 return 0;
1050 free_and_fail:
1051 bs->file = NULL;
1052 g_free(bs->opaque);
1053 bs->opaque = NULL;
1054 bs->drv = NULL;
1055 fail_opts:
1056 qemu_opts_del(opts);
1057 return ret;
1060 static QDict *parse_json_filename(const char *filename, Error **errp)
1062 QObject *options_obj;
1063 QDict *options;
1064 int ret;
1066 ret = strstart(filename, "json:", &filename);
1067 assert(ret);
1069 options_obj = qobject_from_json(filename);
1070 if (!options_obj) {
1071 error_setg(errp, "Could not parse the JSON options");
1072 return NULL;
1075 if (qobject_type(options_obj) != QTYPE_QDICT) {
1076 qobject_decref(options_obj);
1077 error_setg(errp, "Invalid JSON object given");
1078 return NULL;
1081 options = qobject_to_qdict(options_obj);
1082 qdict_flatten(options);
1084 return options;
1087 static void parse_json_protocol(QDict *options, const char **pfilename,
1088 Error **errp)
1090 QDict *json_options;
1091 Error *local_err = NULL;
1093 /* Parse json: pseudo-protocol */
1094 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) {
1095 return;
1098 json_options = parse_json_filename(*pfilename, &local_err);
1099 if (local_err) {
1100 error_propagate(errp, local_err);
1101 return;
1104 /* Options given in the filename have lower priority than options
1105 * specified directly */
1106 qdict_join(options, json_options, false);
1107 QDECREF(json_options);
1108 *pfilename = NULL;
1112 * Fills in default options for opening images and converts the legacy
1113 * filename/flags pair to option QDict entries.
1114 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a
1115 * block driver has been specified explicitly.
1117 static int bdrv_fill_options(QDict **options, const char *filename,
1118 int *flags, Error **errp)
1120 const char *drvname;
1121 bool protocol = *flags & BDRV_O_PROTOCOL;
1122 bool parse_filename = false;
1123 BlockDriver *drv = NULL;
1124 Error *local_err = NULL;
1126 drvname = qdict_get_try_str(*options, "driver");
1127 if (drvname) {
1128 drv = bdrv_find_format(drvname);
1129 if (!drv) {
1130 error_setg(errp, "Unknown driver '%s'", drvname);
1131 return -ENOENT;
1133 /* If the user has explicitly specified the driver, this choice should
1134 * override the BDRV_O_PROTOCOL flag */
1135 protocol = drv->bdrv_file_open;
1138 if (protocol) {
1139 *flags |= BDRV_O_PROTOCOL;
1140 } else {
1141 *flags &= ~BDRV_O_PROTOCOL;
1144 /* Translate cache options from flags into options */
1145 update_options_from_flags(*options, *flags);
1147 /* Fetch the file name from the options QDict if necessary */
1148 if (protocol && filename) {
1149 if (!qdict_haskey(*options, "filename")) {
1150 qdict_put(*options, "filename", qstring_from_str(filename));
1151 parse_filename = true;
1152 } else {
1153 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1154 "the same time");
1155 return -EINVAL;
1159 /* Find the right block driver */
1160 filename = qdict_get_try_str(*options, "filename");
1162 if (!drvname && protocol) {
1163 if (filename) {
1164 drv = bdrv_find_protocol(filename, parse_filename, errp);
1165 if (!drv) {
1166 return -EINVAL;
1169 drvname = drv->format_name;
1170 qdict_put(*options, "driver", qstring_from_str(drvname));
1171 } else {
1172 error_setg(errp, "Must specify either driver or file");
1173 return -EINVAL;
1177 assert(drv || !protocol);
1179 /* Driver-specific filename parsing */
1180 if (drv && drv->bdrv_parse_filename && parse_filename) {
1181 drv->bdrv_parse_filename(filename, *options, &local_err);
1182 if (local_err) {
1183 error_propagate(errp, local_err);
1184 return -EINVAL;
1187 if (!drv->bdrv_needs_filename) {
1188 qdict_del(*options, "filename");
1192 if (runstate_check(RUN_STATE_INMIGRATE)) {
1193 *flags |= BDRV_O_INCOMING;
1196 return 0;
1199 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,
1200 BlockDriverState *child_bs,
1201 const char *child_name,
1202 const BdrvChildRole *child_role)
1204 BdrvChild *child = g_new(BdrvChild, 1);
1205 *child = (BdrvChild) {
1206 .bs = child_bs,
1207 .name = g_strdup(child_name),
1208 .role = child_role,
1211 QLIST_INSERT_HEAD(&parent_bs->children, child, next);
1212 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent);
1214 return child;
1217 static void bdrv_detach_child(BdrvChild *child)
1219 QLIST_REMOVE(child, next);
1220 QLIST_REMOVE(child, next_parent);
1221 g_free(child->name);
1222 g_free(child);
1225 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
1227 BlockDriverState *child_bs;
1229 if (child == NULL) {
1230 return;
1233 if (child->bs->inherits_from == parent) {
1234 child->bs->inherits_from = NULL;
1237 child_bs = child->bs;
1238 bdrv_detach_child(child);
1239 bdrv_unref(child_bs);
1243 * Sets the backing file link of a BDS. A new reference is created; callers
1244 * which don't need their own reference any more must call bdrv_unref().
1246 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1248 if (backing_hd) {
1249 bdrv_ref(backing_hd);
1252 if (bs->backing) {
1253 assert(bs->backing_blocker);
1254 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker);
1255 bdrv_unref_child(bs, bs->backing);
1256 } else if (backing_hd) {
1257 error_setg(&bs->backing_blocker,
1258 "node is used as backing hd of '%s'",
1259 bdrv_get_device_or_node_name(bs));
1262 if (!backing_hd) {
1263 error_free(bs->backing_blocker);
1264 bs->backing_blocker = NULL;
1265 bs->backing = NULL;
1266 goto out;
1268 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing);
1269 bs->open_flags &= ~BDRV_O_NO_BACKING;
1270 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1271 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1272 backing_hd->drv ? backing_hd->drv->format_name : "");
1274 bdrv_op_block_all(backing_hd, bs->backing_blocker);
1275 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1276 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET,
1277 bs->backing_blocker);
1278 out:
1279 bdrv_refresh_limits(bs, NULL);
1283 * Opens the backing file for a BlockDriverState if not yet open
1285 * bdref_key specifies the key for the image's BlockdevRef in the options QDict.
1286 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1287 * itself, all options starting with "${bdref_key}." are considered part of the
1288 * BlockdevRef.
1290 * TODO Can this be unified with bdrv_open_image()?
1292 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
1293 const char *bdref_key, Error **errp)
1295 char *backing_filename = g_malloc0(PATH_MAX);
1296 char *bdref_key_dot;
1297 const char *reference = NULL;
1298 int ret = 0;
1299 BlockDriverState *backing_hd;
1300 QDict *options;
1301 QDict *tmp_parent_options = NULL;
1302 Error *local_err = NULL;
1304 if (bs->backing != NULL) {
1305 goto free_exit;
1308 /* NULL means an empty set of options */
1309 if (parent_options == NULL) {
1310 tmp_parent_options = qdict_new();
1311 parent_options = tmp_parent_options;
1314 bs->open_flags &= ~BDRV_O_NO_BACKING;
1316 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1317 qdict_extract_subqdict(parent_options, &options, bdref_key_dot);
1318 g_free(bdref_key_dot);
1320 reference = qdict_get_try_str(parent_options, bdref_key);
1321 if (reference || qdict_haskey(options, "file.filename")) {
1322 backing_filename[0] = '\0';
1323 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1324 QDECREF(options);
1325 goto free_exit;
1326 } else {
1327 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
1328 &local_err);
1329 if (local_err) {
1330 ret = -EINVAL;
1331 error_propagate(errp, local_err);
1332 QDECREF(options);
1333 goto free_exit;
1337 if (!bs->drv || !bs->drv->supports_backing) {
1338 ret = -EINVAL;
1339 error_setg(errp, "Driver doesn't support backing files");
1340 QDECREF(options);
1341 goto free_exit;
1344 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) {
1345 qdict_put(options, "driver", qstring_from_str(bs->backing_format));
1348 backing_hd = NULL;
1349 ret = bdrv_open_inherit(&backing_hd,
1350 *backing_filename ? backing_filename : NULL,
1351 reference, options, 0, bs, &child_backing,
1352 errp);
1353 if (ret < 0) {
1354 bs->open_flags |= BDRV_O_NO_BACKING;
1355 error_prepend(errp, "Could not open backing file: ");
1356 goto free_exit;
1359 /* Hook up the backing file link; drop our reference, bs owns the
1360 * backing_hd reference now */
1361 bdrv_set_backing_hd(bs, backing_hd);
1362 bdrv_unref(backing_hd);
1364 qdict_del(parent_options, bdref_key);
1366 free_exit:
1367 g_free(backing_filename);
1368 QDECREF(tmp_parent_options);
1369 return ret;
1373 * Opens a disk image whose options are given as BlockdevRef in another block
1374 * device's options.
1376 * If allow_none is true, no image will be opened if filename is false and no
1377 * BlockdevRef is given. NULL will be returned, but errp remains unset.
1379 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1380 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1381 * itself, all options starting with "${bdref_key}." are considered part of the
1382 * BlockdevRef.
1384 * The BlockdevRef will be removed from the options QDict.
1386 BdrvChild *bdrv_open_child(const char *filename,
1387 QDict *options, const char *bdref_key,
1388 BlockDriverState* parent,
1389 const BdrvChildRole *child_role,
1390 bool allow_none, Error **errp)
1392 BdrvChild *c = NULL;
1393 BlockDriverState *bs;
1394 QDict *image_options;
1395 int ret;
1396 char *bdref_key_dot;
1397 const char *reference;
1399 assert(child_role != NULL);
1401 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1402 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1403 g_free(bdref_key_dot);
1405 reference = qdict_get_try_str(options, bdref_key);
1406 if (!filename && !reference && !qdict_size(image_options)) {
1407 if (!allow_none) {
1408 error_setg(errp, "A block device must be specified for \"%s\"",
1409 bdref_key);
1411 QDECREF(image_options);
1412 goto done;
1415 bs = NULL;
1416 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0,
1417 parent, child_role, errp);
1418 if (ret < 0) {
1419 goto done;
1422 c = bdrv_attach_child(parent, bs, bdref_key, child_role);
1424 done:
1425 qdict_del(options, bdref_key);
1426 return c;
1429 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1431 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1432 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1433 int64_t total_size;
1434 QemuOpts *opts = NULL;
1435 QDict *snapshot_options;
1436 BlockDriverState *bs_snapshot;
1437 Error *local_err = NULL;
1438 int ret;
1440 /* if snapshot, we create a temporary backing file and open it
1441 instead of opening 'filename' directly */
1443 /* Get the required size from the image */
1444 total_size = bdrv_getlength(bs);
1445 if (total_size < 0) {
1446 ret = total_size;
1447 error_setg_errno(errp, -total_size, "Could not get image size");
1448 goto out;
1451 /* Create the temporary image */
1452 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1453 if (ret < 0) {
1454 error_setg_errno(errp, -ret, "Could not get temporary filename");
1455 goto out;
1458 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0,
1459 &error_abort);
1460 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort);
1461 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp);
1462 qemu_opts_del(opts);
1463 if (ret < 0) {
1464 error_prepend(errp, "Could not create temporary overlay '%s': ",
1465 tmp_filename);
1466 goto out;
1469 /* Prepare a new options QDict for the temporary file */
1470 snapshot_options = qdict_new();
1471 qdict_put(snapshot_options, "file.driver",
1472 qstring_from_str("file"));
1473 qdict_put(snapshot_options, "file.filename",
1474 qstring_from_str(tmp_filename));
1475 qdict_put(snapshot_options, "driver",
1476 qstring_from_str("qcow2"));
1478 bs_snapshot = bdrv_new();
1480 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1481 flags, &local_err);
1482 if (ret < 0) {
1483 error_propagate(errp, local_err);
1484 goto out;
1487 bdrv_append(bs_snapshot, bs);
1489 out:
1490 g_free(tmp_filename);
1491 return ret;
1495 * Opens a disk image (raw, qcow2, vmdk, ...)
1497 * options is a QDict of options to pass to the block drivers, or NULL for an
1498 * empty set of options. The reference to the QDict belongs to the block layer
1499 * after the call (even on failure), so if the caller intends to reuse the
1500 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1502 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1503 * If it is not NULL, the referenced BDS will be reused.
1505 * The reference parameter may be used to specify an existing block device which
1506 * should be opened. If specified, neither options nor a filename may be given,
1507 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1509 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename,
1510 const char *reference, QDict *options, int flags,
1511 BlockDriverState *parent,
1512 const BdrvChildRole *child_role, Error **errp)
1514 int ret;
1515 BdrvChild *file = NULL;
1516 BlockDriverState *bs;
1517 BlockDriver *drv = NULL;
1518 const char *drvname;
1519 const char *backing;
1520 Error *local_err = NULL;
1521 int snapshot_flags = 0;
1523 assert(pbs);
1524 assert(!child_role || !flags);
1525 assert(!child_role == !parent);
1527 if (reference) {
1528 bool options_non_empty = options ? qdict_size(options) : false;
1529 QDECREF(options);
1531 if (*pbs) {
1532 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1533 "another block device");
1534 return -EINVAL;
1537 if (filename || options_non_empty) {
1538 error_setg(errp, "Cannot reference an existing block device with "
1539 "additional options or a new filename");
1540 return -EINVAL;
1543 bs = bdrv_lookup_bs(reference, reference, errp);
1544 if (!bs) {
1545 return -ENODEV;
1547 bdrv_ref(bs);
1548 *pbs = bs;
1549 return 0;
1552 if (*pbs) {
1553 bs = *pbs;
1554 } else {
1555 bs = bdrv_new();
1558 /* NULL means an empty set of options */
1559 if (options == NULL) {
1560 options = qdict_new();
1563 /* json: syntax counts as explicit options, as if in the QDict */
1564 parse_json_protocol(options, &filename, &local_err);
1565 if (local_err) {
1566 ret = -EINVAL;
1567 goto fail;
1570 bs->explicit_options = qdict_clone_shallow(options);
1572 if (child_role) {
1573 bs->inherits_from = parent;
1574 child_role->inherit_options(&flags, options,
1575 parent->open_flags, parent->options);
1578 ret = bdrv_fill_options(&options, filename, &flags, &local_err);
1579 if (local_err) {
1580 goto fail;
1583 bs->open_flags = flags;
1584 bs->options = options;
1585 options = qdict_clone_shallow(options);
1587 /* Find the right image format driver */
1588 drvname = qdict_get_try_str(options, "driver");
1589 if (drvname) {
1590 drv = bdrv_find_format(drvname);
1591 if (!drv) {
1592 error_setg(errp, "Unknown driver: '%s'", drvname);
1593 ret = -EINVAL;
1594 goto fail;
1598 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1600 backing = qdict_get_try_str(options, "backing");
1601 if (backing && *backing == '\0') {
1602 flags |= BDRV_O_NO_BACKING;
1603 qdict_del(options, "backing");
1606 /* Open image file without format layer */
1607 if ((flags & BDRV_O_PROTOCOL) == 0) {
1608 if (flags & BDRV_O_RDWR) {
1609 flags |= BDRV_O_ALLOW_RDWR;
1611 if (flags & BDRV_O_SNAPSHOT) {
1612 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1613 bdrv_backing_options(&flags, options, flags, options);
1616 bs->open_flags = flags;
1618 file = bdrv_open_child(filename, options, "file", bs,
1619 &child_file, true, &local_err);
1620 if (local_err) {
1621 ret = -EINVAL;
1622 goto fail;
1626 /* Image format probing */
1627 bs->probed = !drv;
1628 if (!drv && file) {
1629 ret = find_image_format(file->bs, filename, &drv, &local_err);
1630 if (ret < 0) {
1631 goto fail;
1634 * This option update would logically belong in bdrv_fill_options(),
1635 * but we first need to open bs->file for the probing to work, while
1636 * opening bs->file already requires the (mostly) final set of options
1637 * so that cache mode etc. can be inherited.
1639 * Adding the driver later is somewhat ugly, but it's not an option
1640 * that would ever be inherited, so it's correct. We just need to make
1641 * sure to update both bs->options (which has the full effective
1642 * options for bs) and options (which has file.* already removed).
1644 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name));
1645 qdict_put(options, "driver", qstring_from_str(drv->format_name));
1646 } else if (!drv) {
1647 error_setg(errp, "Must specify either driver or file");
1648 ret = -EINVAL;
1649 goto fail;
1652 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */
1653 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open);
1654 /* file must be NULL if a protocol BDS is about to be created
1655 * (the inverse results in an error message from bdrv_open_common()) */
1656 assert(!(flags & BDRV_O_PROTOCOL) || !file);
1658 /* Open the image */
1659 ret = bdrv_open_common(bs, file, options, flags, &local_err);
1660 if (ret < 0) {
1661 goto fail;
1664 if (file && (bs->file != file)) {
1665 bdrv_unref_child(bs, file);
1666 file = NULL;
1669 /* If there is a backing file, use it */
1670 if ((flags & BDRV_O_NO_BACKING) == 0) {
1671 ret = bdrv_open_backing_file(bs, options, "backing", &local_err);
1672 if (ret < 0) {
1673 goto close_and_fail;
1677 bdrv_refresh_filename(bs);
1679 /* Check if any unknown options were used */
1680 if (options && (qdict_size(options) != 0)) {
1681 const QDictEntry *entry = qdict_first(options);
1682 if (flags & BDRV_O_PROTOCOL) {
1683 error_setg(errp, "Block protocol '%s' doesn't support the option "
1684 "'%s'", drv->format_name, entry->key);
1685 } else {
1686 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1687 "support the option '%s'", drv->format_name,
1688 bdrv_get_device_name(bs), entry->key);
1691 ret = -EINVAL;
1692 goto close_and_fail;
1695 if (!bdrv_key_required(bs)) {
1696 if (bs->blk) {
1697 blk_dev_change_media_cb(bs->blk, true);
1699 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1700 && !runstate_check(RUN_STATE_INMIGRATE)
1701 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1702 error_setg(errp,
1703 "Guest must be stopped for opening of encrypted image");
1704 ret = -EBUSY;
1705 goto close_and_fail;
1708 QDECREF(options);
1709 *pbs = bs;
1711 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1712 * temporary snapshot afterwards. */
1713 if (snapshot_flags) {
1714 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1715 if (local_err) {
1716 goto close_and_fail;
1720 return 0;
1722 fail:
1723 if (file != NULL) {
1724 bdrv_unref_child(bs, file);
1726 QDECREF(bs->explicit_options);
1727 QDECREF(bs->options);
1728 QDECREF(options);
1729 bs->options = NULL;
1730 if (!*pbs) {
1731 /* If *pbs is NULL, a new BDS has been created in this function and
1732 needs to be freed now. Otherwise, it does not need to be closed,
1733 since it has not really been opened yet. */
1734 bdrv_unref(bs);
1736 if (local_err) {
1737 error_propagate(errp, local_err);
1739 return ret;
1741 close_and_fail:
1742 /* See fail path, but now the BDS has to be always closed */
1743 if (*pbs) {
1744 bdrv_close(bs);
1745 } else {
1746 bdrv_unref(bs);
1748 QDECREF(options);
1749 if (local_err) {
1750 error_propagate(errp, local_err);
1752 return ret;
1755 int bdrv_open(BlockDriverState **pbs, const char *filename,
1756 const char *reference, QDict *options, int flags, Error **errp)
1758 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL,
1759 NULL, errp);
1762 typedef struct BlockReopenQueueEntry {
1763 bool prepared;
1764 BDRVReopenState state;
1765 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1766 } BlockReopenQueueEntry;
1769 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1770 * reopen of multiple devices.
1772 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1773 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1774 * be created and initialized. This newly created BlockReopenQueue should be
1775 * passed back in for subsequent calls that are intended to be of the same
1776 * atomic 'set'.
1778 * bs is the BlockDriverState to add to the reopen queue.
1780 * options contains the changed options for the associated bs
1781 * (the BlockReopenQueue takes ownership)
1783 * flags contains the open flags for the associated bs
1785 * returns a pointer to bs_queue, which is either the newly allocated
1786 * bs_queue, or the existing bs_queue being used.
1789 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
1790 BlockDriverState *bs,
1791 QDict *options,
1792 int flags,
1793 const BdrvChildRole *role,
1794 QDict *parent_options,
1795 int parent_flags)
1797 assert(bs != NULL);
1799 BlockReopenQueueEntry *bs_entry;
1800 BdrvChild *child;
1801 QDict *old_options, *explicit_options;
1803 if (bs_queue == NULL) {
1804 bs_queue = g_new0(BlockReopenQueue, 1);
1805 QSIMPLEQ_INIT(bs_queue);
1808 if (!options) {
1809 options = qdict_new();
1813 * Precedence of options:
1814 * 1. Explicitly passed in options (highest)
1815 * 2. Set in flags (only for top level)
1816 * 3. Retained from explicitly set options of bs
1817 * 4. Inherited from parent node
1818 * 5. Retained from effective options of bs
1821 if (!parent_options) {
1823 * Any setting represented by flags is always updated. If the
1824 * corresponding QDict option is set, it takes precedence. Otherwise
1825 * the flag is translated into a QDict option. The old setting of bs is
1826 * not considered.
1828 update_options_from_flags(options, flags);
1831 /* Old explicitly set values (don't overwrite by inherited value) */
1832 old_options = qdict_clone_shallow(bs->explicit_options);
1833 bdrv_join_options(bs, options, old_options);
1834 QDECREF(old_options);
1836 explicit_options = qdict_clone_shallow(options);
1838 /* Inherit from parent node */
1839 if (parent_options) {
1840 assert(!flags);
1841 role->inherit_options(&flags, options, parent_flags, parent_options);
1844 /* Old values are used for options that aren't set yet */
1845 old_options = qdict_clone_shallow(bs->options);
1846 bdrv_join_options(bs, options, old_options);
1847 QDECREF(old_options);
1849 /* bdrv_open() masks this flag out */
1850 flags &= ~BDRV_O_PROTOCOL;
1852 QLIST_FOREACH(child, &bs->children, next) {
1853 QDict *new_child_options;
1854 char *child_key_dot;
1856 /* reopen can only change the options of block devices that were
1857 * implicitly created and inherited options. For other (referenced)
1858 * block devices, a syntax like "backing.foo" results in an error. */
1859 if (child->bs->inherits_from != bs) {
1860 continue;
1863 child_key_dot = g_strdup_printf("%s.", child->name);
1864 qdict_extract_subqdict(options, &new_child_options, child_key_dot);
1865 g_free(child_key_dot);
1867 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0,
1868 child->role, options, flags);
1871 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1872 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1874 bs_entry->state.bs = bs;
1875 bs_entry->state.options = options;
1876 bs_entry->state.explicit_options = explicit_options;
1877 bs_entry->state.flags = flags;
1879 return bs_queue;
1882 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1883 BlockDriverState *bs,
1884 QDict *options, int flags)
1886 return bdrv_reopen_queue_child(bs_queue, bs, options, flags,
1887 NULL, NULL, 0);
1891 * Reopen multiple BlockDriverStates atomically & transactionally.
1893 * The queue passed in (bs_queue) must have been built up previous
1894 * via bdrv_reopen_queue().
1896 * Reopens all BDS specified in the queue, with the appropriate
1897 * flags. All devices are prepared for reopen, and failure of any
1898 * device will cause all device changes to be abandonded, and intermediate
1899 * data cleaned up.
1901 * If all devices prepare successfully, then the changes are committed
1902 * to all devices.
1905 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1907 int ret = -1;
1908 BlockReopenQueueEntry *bs_entry, *next;
1909 Error *local_err = NULL;
1911 assert(bs_queue != NULL);
1913 bdrv_drain_all();
1915 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1916 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1917 error_propagate(errp, local_err);
1918 goto cleanup;
1920 bs_entry->prepared = true;
1923 /* If we reach this point, we have success and just need to apply the
1924 * changes
1926 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1927 bdrv_reopen_commit(&bs_entry->state);
1930 ret = 0;
1932 cleanup:
1933 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1934 if (ret && bs_entry->prepared) {
1935 bdrv_reopen_abort(&bs_entry->state);
1936 } else if (ret) {
1937 QDECREF(bs_entry->state.explicit_options);
1939 QDECREF(bs_entry->state.options);
1940 g_free(bs_entry);
1942 g_free(bs_queue);
1943 return ret;
1947 /* Reopen a single BlockDriverState with the specified flags. */
1948 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1950 int ret = -1;
1951 Error *local_err = NULL;
1952 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
1954 ret = bdrv_reopen_multiple(queue, &local_err);
1955 if (local_err != NULL) {
1956 error_propagate(errp, local_err);
1958 return ret;
1963 * Prepares a BlockDriverState for reopen. All changes are staged in the
1964 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1965 * the block driver layer .bdrv_reopen_prepare()
1967 * bs is the BlockDriverState to reopen
1968 * flags are the new open flags
1969 * queue is the reopen queue
1971 * Returns 0 on success, non-zero on error. On error errp will be set
1972 * as well.
1974 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1975 * It is the responsibility of the caller to then call the abort() or
1976 * commit() for any other BDS that have been left in a prepare() state
1979 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1980 Error **errp)
1982 int ret = -1;
1983 Error *local_err = NULL;
1984 BlockDriver *drv;
1985 QemuOpts *opts;
1986 const char *value;
1988 assert(reopen_state != NULL);
1989 assert(reopen_state->bs->drv != NULL);
1990 drv = reopen_state->bs->drv;
1992 /* Process generic block layer options */
1993 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort);
1994 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err);
1995 if (local_err) {
1996 error_propagate(errp, local_err);
1997 ret = -EINVAL;
1998 goto error;
2001 update_flags_from_options(&reopen_state->flags, opts);
2003 /* If a guest device is attached, it owns WCE */
2004 if (reopen_state->bs->blk && blk_get_attached_dev(reopen_state->bs->blk)) {
2005 bool old_wce = bdrv_enable_write_cache(reopen_state->bs);
2006 bool new_wce = (reopen_state->flags & BDRV_O_CACHE_WB);
2007 if (old_wce != new_wce) {
2008 error_setg(errp, "Cannot change cache.writeback: Device attached");
2009 ret = -EINVAL;
2010 goto error;
2014 /* node-name and driver must be unchanged. Put them back into the QDict, so
2015 * that they are checked at the end of this function. */
2016 value = qemu_opt_get(opts, "node-name");
2017 if (value) {
2018 qdict_put(reopen_state->options, "node-name", qstring_from_str(value));
2021 value = qemu_opt_get(opts, "driver");
2022 if (value) {
2023 qdict_put(reopen_state->options, "driver", qstring_from_str(value));
2026 /* if we are to stay read-only, do not allow permission change
2027 * to r/w */
2028 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
2029 reopen_state->flags & BDRV_O_RDWR) {
2030 error_setg(errp, "Node '%s' is read only",
2031 bdrv_get_device_or_node_name(reopen_state->bs));
2032 goto error;
2036 ret = bdrv_flush(reopen_state->bs);
2037 if (ret) {
2038 error_setg_errno(errp, -ret, "Error flushing drive");
2039 goto error;
2042 if (drv->bdrv_reopen_prepare) {
2043 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
2044 if (ret) {
2045 if (local_err != NULL) {
2046 error_propagate(errp, local_err);
2047 } else {
2048 error_setg(errp, "failed while preparing to reopen image '%s'",
2049 reopen_state->bs->filename);
2051 goto error;
2053 } else {
2054 /* It is currently mandatory to have a bdrv_reopen_prepare()
2055 * handler for each supported drv. */
2056 error_setg(errp, "Block format '%s' used by node '%s' "
2057 "does not support reopening files", drv->format_name,
2058 bdrv_get_device_or_node_name(reopen_state->bs));
2059 ret = -1;
2060 goto error;
2063 /* Options that are not handled are only okay if they are unchanged
2064 * compared to the old state. It is expected that some options are only
2065 * used for the initial open, but not reopen (e.g. filename) */
2066 if (qdict_size(reopen_state->options)) {
2067 const QDictEntry *entry = qdict_first(reopen_state->options);
2069 do {
2070 QString *new_obj = qobject_to_qstring(entry->value);
2071 const char *new = qstring_get_str(new_obj);
2072 const char *old = qdict_get_try_str(reopen_state->bs->options,
2073 entry->key);
2075 if (!old || strcmp(new, old)) {
2076 error_setg(errp, "Cannot change the option '%s'", entry->key);
2077 ret = -EINVAL;
2078 goto error;
2080 } while ((entry = qdict_next(reopen_state->options, entry)));
2083 ret = 0;
2085 error:
2086 qemu_opts_del(opts);
2087 return ret;
2091 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
2092 * makes them final by swapping the staging BlockDriverState contents into
2093 * the active BlockDriverState contents.
2095 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
2097 BlockDriver *drv;
2099 assert(reopen_state != NULL);
2100 drv = reopen_state->bs->drv;
2101 assert(drv != NULL);
2103 /* If there are any driver level actions to take */
2104 if (drv->bdrv_reopen_commit) {
2105 drv->bdrv_reopen_commit(reopen_state);
2108 /* set BDS specific flags now */
2109 QDECREF(reopen_state->bs->explicit_options);
2111 reopen_state->bs->explicit_options = reopen_state->explicit_options;
2112 reopen_state->bs->open_flags = reopen_state->flags;
2113 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
2114 BDRV_O_CACHE_WB);
2115 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
2117 bdrv_refresh_limits(reopen_state->bs, NULL);
2121 * Abort the reopen, and delete and free the staged changes in
2122 * reopen_state
2124 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
2126 BlockDriver *drv;
2128 assert(reopen_state != NULL);
2129 drv = reopen_state->bs->drv;
2130 assert(drv != NULL);
2132 if (drv->bdrv_reopen_abort) {
2133 drv->bdrv_reopen_abort(reopen_state);
2136 QDECREF(reopen_state->explicit_options);
2140 void bdrv_close(BlockDriverState *bs)
2142 BdrvAioNotifier *ban, *ban_next;
2144 if (bs->job) {
2145 block_job_cancel_sync(bs->job);
2148 /* Disable I/O limits and drain all pending throttled requests */
2149 if (bs->throttle_state) {
2150 bdrv_io_limits_disable(bs);
2153 bdrv_drained_begin(bs); /* complete I/O */
2154 bdrv_flush(bs);
2155 bdrv_drain(bs); /* in case flush left pending I/O */
2157 notifier_list_notify(&bs->close_notifiers, bs);
2159 if (bs->blk) {
2160 blk_dev_change_media_cb(bs->blk, false);
2163 if (bs->drv) {
2164 BdrvChild *child, *next;
2166 bs->drv->bdrv_close(bs);
2167 bs->drv = NULL;
2169 bdrv_set_backing_hd(bs, NULL);
2171 if (bs->file != NULL) {
2172 bdrv_unref_child(bs, bs->file);
2173 bs->file = NULL;
2176 QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
2177 /* TODO Remove bdrv_unref() from drivers' close function and use
2178 * bdrv_unref_child() here */
2179 if (child->bs->inherits_from == bs) {
2180 child->bs->inherits_from = NULL;
2182 bdrv_detach_child(child);
2185 g_free(bs->opaque);
2186 bs->opaque = NULL;
2187 bs->copy_on_read = 0;
2188 bs->backing_file[0] = '\0';
2189 bs->backing_format[0] = '\0';
2190 bs->total_sectors = 0;
2191 bs->encrypted = 0;
2192 bs->valid_key = 0;
2193 bs->sg = 0;
2194 bs->zero_beyond_eof = false;
2195 QDECREF(bs->options);
2196 QDECREF(bs->explicit_options);
2197 bs->options = NULL;
2198 QDECREF(bs->full_open_options);
2199 bs->full_open_options = NULL;
2202 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
2203 g_free(ban);
2205 QLIST_INIT(&bs->aio_notifiers);
2206 bdrv_drained_end(bs);
2209 void bdrv_close_all(void)
2211 BlockDriverState *bs;
2213 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2214 AioContext *aio_context = bdrv_get_aio_context(bs);
2216 aio_context_acquire(aio_context);
2217 bdrv_close(bs);
2218 aio_context_release(aio_context);
2222 /* make a BlockDriverState anonymous by removing from bdrv_state and
2223 * graph_bdrv_state list.
2224 Also, NULL terminate the device_name to prevent double remove */
2225 void bdrv_make_anon(BlockDriverState *bs)
2228 * Take care to remove bs from bdrv_states only when it's actually
2229 * in it. Note that bs->device_list.tqe_prev is initially null,
2230 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2231 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2232 * resetting it to null on remove.
2234 if (bs->device_list.tqe_prev) {
2235 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
2236 bs->device_list.tqe_prev = NULL;
2238 if (bs->node_name[0] != '\0') {
2239 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
2241 bs->node_name[0] = '\0';
2244 /* Fields that need to stay with the top-level BDS */
2245 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
2246 BlockDriverState *bs_src)
2248 /* move some fields that need to stay attached to the device */
2250 /* dev info */
2251 bs_dest->copy_on_read = bs_src->copy_on_read;
2253 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2255 /* dirty bitmap */
2256 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2259 static void change_parent_backing_link(BlockDriverState *from,
2260 BlockDriverState *to)
2262 BdrvChild *c, *next;
2264 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {
2265 assert(c->role != &child_backing);
2266 c->bs = to;
2267 QLIST_REMOVE(c, next_parent);
2268 QLIST_INSERT_HEAD(&to->parents, c, next_parent);
2269 bdrv_ref(to);
2270 bdrv_unref(from);
2272 if (from->blk) {
2273 blk_set_bs(from->blk, to);
2274 if (!to->device_list.tqe_prev) {
2275 QTAILQ_INSERT_BEFORE(from, to, device_list);
2277 QTAILQ_REMOVE(&bdrv_states, from, device_list);
2281 static void swap_feature_fields(BlockDriverState *bs_top,
2282 BlockDriverState *bs_new)
2284 BlockDriverState tmp;
2286 bdrv_move_feature_fields(&tmp, bs_top);
2287 bdrv_move_feature_fields(bs_top, bs_new);
2288 bdrv_move_feature_fields(bs_new, &tmp);
2290 assert(!bs_new->throttle_state);
2291 if (bs_top->throttle_state) {
2292 assert(bs_top->io_limits_enabled);
2293 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top));
2294 bdrv_io_limits_disable(bs_top);
2299 * Add new bs contents at the top of an image chain while the chain is
2300 * live, while keeping required fields on the top layer.
2302 * This will modify the BlockDriverState fields, and swap contents
2303 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2305 * bs_new must not be attached to a BlockBackend.
2307 * This function does not create any image files.
2309 * bdrv_append() takes ownership of a bs_new reference and unrefs it because
2310 * that's what the callers commonly need. bs_new will be referenced by the old
2311 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a
2312 * reference of its own, it must call bdrv_ref().
2314 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2316 assert(!bdrv_requests_pending(bs_top));
2317 assert(!bdrv_requests_pending(bs_new));
2319 bdrv_ref(bs_top);
2320 change_parent_backing_link(bs_top, bs_new);
2322 /* Some fields always stay on top of the backing file chain */
2323 swap_feature_fields(bs_top, bs_new);
2325 bdrv_set_backing_hd(bs_new, bs_top);
2326 bdrv_unref(bs_top);
2328 /* bs_new is now referenced by its new parents, we don't need the
2329 * additional reference any more. */
2330 bdrv_unref(bs_new);
2333 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
2335 assert(!bdrv_requests_pending(old));
2336 assert(!bdrv_requests_pending(new));
2338 bdrv_ref(old);
2340 if (old->blk) {
2341 /* As long as these fields aren't in BlockBackend, but in the top-level
2342 * BlockDriverState, it's not possible for a BDS to have two BBs.
2344 * We really want to copy the fields from old to new, but we go for a
2345 * swap instead so that pointers aren't duplicated and cause trouble.
2346 * (Also, bdrv_swap() used to do the same.) */
2347 assert(!new->blk);
2348 swap_feature_fields(old, new);
2350 change_parent_backing_link(old, new);
2352 /* Change backing files if a previously independent node is added to the
2353 * chain. For active commit, we replace top by its own (indirect) backing
2354 * file and don't do anything here so we don't build a loop. */
2355 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {
2356 bdrv_set_backing_hd(new, backing_bs(old));
2357 bdrv_set_backing_hd(old, NULL);
2360 bdrv_unref(old);
2363 static void bdrv_delete(BlockDriverState *bs)
2365 assert(!bs->job);
2366 assert(bdrv_op_blocker_is_empty(bs));
2367 assert(!bs->refcnt);
2368 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2370 bdrv_close(bs);
2372 /* remove from list, if necessary */
2373 bdrv_make_anon(bs);
2375 g_free(bs);
2379 * Run consistency checks on an image
2381 * Returns 0 if the check could be completed (it doesn't mean that the image is
2382 * free of errors) or -errno when an internal error occurred. The results of the
2383 * check are stored in res.
2385 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2387 if (bs->drv == NULL) {
2388 return -ENOMEDIUM;
2390 if (bs->drv->bdrv_check == NULL) {
2391 return -ENOTSUP;
2394 memset(res, 0, sizeof(*res));
2395 return bs->drv->bdrv_check(bs, res, fix);
2398 #define COMMIT_BUF_SECTORS 2048
2400 /* commit COW file into the raw image */
2401 int bdrv_commit(BlockDriverState *bs)
2403 BlockDriver *drv = bs->drv;
2404 int64_t sector, total_sectors, length, backing_length;
2405 int n, ro, open_flags;
2406 int ret = 0;
2407 uint8_t *buf = NULL;
2409 if (!drv)
2410 return -ENOMEDIUM;
2412 if (!bs->backing) {
2413 return -ENOTSUP;
2416 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
2417 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
2418 return -EBUSY;
2421 ro = bs->backing->bs->read_only;
2422 open_flags = bs->backing->bs->open_flags;
2424 if (ro) {
2425 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
2426 return -EACCES;
2430 length = bdrv_getlength(bs);
2431 if (length < 0) {
2432 ret = length;
2433 goto ro_cleanup;
2436 backing_length = bdrv_getlength(bs->backing->bs);
2437 if (backing_length < 0) {
2438 ret = backing_length;
2439 goto ro_cleanup;
2442 /* If our top snapshot is larger than the backing file image,
2443 * grow the backing file image if possible. If not possible,
2444 * we must return an error */
2445 if (length > backing_length) {
2446 ret = bdrv_truncate(bs->backing->bs, length);
2447 if (ret < 0) {
2448 goto ro_cleanup;
2452 total_sectors = length >> BDRV_SECTOR_BITS;
2454 /* qemu_try_blockalign() for bs will choose an alignment that works for
2455 * bs->backing->bs as well, so no need to compare the alignment manually. */
2456 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2457 if (buf == NULL) {
2458 ret = -ENOMEM;
2459 goto ro_cleanup;
2462 for (sector = 0; sector < total_sectors; sector += n) {
2463 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2464 if (ret < 0) {
2465 goto ro_cleanup;
2467 if (ret) {
2468 ret = bdrv_read(bs, sector, buf, n);
2469 if (ret < 0) {
2470 goto ro_cleanup;
2473 ret = bdrv_write(bs->backing->bs, sector, buf, n);
2474 if (ret < 0) {
2475 goto ro_cleanup;
2480 if (drv->bdrv_make_empty) {
2481 ret = drv->bdrv_make_empty(bs);
2482 if (ret < 0) {
2483 goto ro_cleanup;
2485 bdrv_flush(bs);
2489 * Make sure all data we wrote to the backing device is actually
2490 * stable on disk.
2492 if (bs->backing) {
2493 bdrv_flush(bs->backing->bs);
2496 ret = 0;
2497 ro_cleanup:
2498 qemu_vfree(buf);
2500 if (ro) {
2501 /* ignoring error return here */
2502 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
2505 return ret;
2508 int bdrv_commit_all(void)
2510 BlockDriverState *bs;
2512 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2513 AioContext *aio_context = bdrv_get_aio_context(bs);
2515 aio_context_acquire(aio_context);
2516 if (bs->drv && bs->backing) {
2517 int ret = bdrv_commit(bs);
2518 if (ret < 0) {
2519 aio_context_release(aio_context);
2520 return ret;
2523 aio_context_release(aio_context);
2525 return 0;
2529 * Return values:
2530 * 0 - success
2531 * -EINVAL - backing format specified, but no file
2532 * -ENOSPC - can't update the backing file because no space is left in the
2533 * image file header
2534 * -ENOTSUP - format driver doesn't support changing the backing file
2536 int bdrv_change_backing_file(BlockDriverState *bs,
2537 const char *backing_file, const char *backing_fmt)
2539 BlockDriver *drv = bs->drv;
2540 int ret;
2542 /* Backing file format doesn't make sense without a backing file */
2543 if (backing_fmt && !backing_file) {
2544 return -EINVAL;
2547 if (drv->bdrv_change_backing_file != NULL) {
2548 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2549 } else {
2550 ret = -ENOTSUP;
2553 if (ret == 0) {
2554 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2555 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2557 return ret;
2561 * Finds the image layer in the chain that has 'bs' as its backing file.
2563 * active is the current topmost image.
2565 * Returns NULL if bs is not found in active's image chain,
2566 * or if active == bs.
2568 * Returns the bottommost base image if bs == NULL.
2570 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2571 BlockDriverState *bs)
2573 while (active && bs != backing_bs(active)) {
2574 active = backing_bs(active);
2577 return active;
2580 /* Given a BDS, searches for the base layer. */
2581 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2583 return bdrv_find_overlay(bs, NULL);
2587 * Drops images above 'base' up to and including 'top', and sets the image
2588 * above 'top' to have base as its backing file.
2590 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2591 * information in 'bs' can be properly updated.
2593 * E.g., this will convert the following chain:
2594 * bottom <- base <- intermediate <- top <- active
2596 * to
2598 * bottom <- base <- active
2600 * It is allowed for bottom==base, in which case it converts:
2602 * base <- intermediate <- top <- active
2604 * to
2606 * base <- active
2608 * If backing_file_str is non-NULL, it will be used when modifying top's
2609 * overlay image metadata.
2611 * Error conditions:
2612 * if active == top, that is considered an error
2615 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2616 BlockDriverState *base, const char *backing_file_str)
2618 BlockDriverState *new_top_bs = NULL;
2619 int ret = -EIO;
2621 if (!top->drv || !base->drv) {
2622 goto exit;
2625 new_top_bs = bdrv_find_overlay(active, top);
2627 if (new_top_bs == NULL) {
2628 /* we could not find the image above 'top', this is an error */
2629 goto exit;
2632 /* special case of new_top_bs->backing->bs already pointing to base - nothing
2633 * to do, no intermediate images */
2634 if (backing_bs(new_top_bs) == base) {
2635 ret = 0;
2636 goto exit;
2639 /* Make sure that base is in the backing chain of top */
2640 if (!bdrv_chain_contains(top, base)) {
2641 goto exit;
2644 /* success - we can delete the intermediate states, and link top->base */
2645 backing_file_str = backing_file_str ? backing_file_str : base->filename;
2646 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2647 base->drv ? base->drv->format_name : "");
2648 if (ret) {
2649 goto exit;
2651 bdrv_set_backing_hd(new_top_bs, base);
2653 ret = 0;
2654 exit:
2655 return ret;
2659 * Truncate file to 'offset' bytes (needed only for file protocols)
2661 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2663 BlockDriver *drv = bs->drv;
2664 int ret;
2665 if (!drv)
2666 return -ENOMEDIUM;
2667 if (!drv->bdrv_truncate)
2668 return -ENOTSUP;
2669 if (bs->read_only)
2670 return -EACCES;
2672 ret = drv->bdrv_truncate(bs, offset);
2673 if (ret == 0) {
2674 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2675 bdrv_dirty_bitmap_truncate(bs);
2676 if (bs->blk) {
2677 blk_dev_resize_cb(bs->blk);
2680 return ret;
2684 * Length of a allocated file in bytes. Sparse files are counted by actual
2685 * allocated space. Return < 0 if error or unknown.
2687 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2689 BlockDriver *drv = bs->drv;
2690 if (!drv) {
2691 return -ENOMEDIUM;
2693 if (drv->bdrv_get_allocated_file_size) {
2694 return drv->bdrv_get_allocated_file_size(bs);
2696 if (bs->file) {
2697 return bdrv_get_allocated_file_size(bs->file->bs);
2699 return -ENOTSUP;
2703 * Return number of sectors on success, -errno on error.
2705 int64_t bdrv_nb_sectors(BlockDriverState *bs)
2707 BlockDriver *drv = bs->drv;
2709 if (!drv)
2710 return -ENOMEDIUM;
2712 if (drv->has_variable_length) {
2713 int ret = refresh_total_sectors(bs, bs->total_sectors);
2714 if (ret < 0) {
2715 return ret;
2718 return bs->total_sectors;
2722 * Return length in bytes on success, -errno on error.
2723 * The length is always a multiple of BDRV_SECTOR_SIZE.
2725 int64_t bdrv_getlength(BlockDriverState *bs)
2727 int64_t ret = bdrv_nb_sectors(bs);
2729 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret;
2730 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
2733 /* return 0 as number of sectors if no device present or error */
2734 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2736 int64_t nb_sectors = bdrv_nb_sectors(bs);
2738 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
2741 int bdrv_is_read_only(BlockDriverState *bs)
2743 return bs->read_only;
2746 int bdrv_is_sg(BlockDriverState *bs)
2748 return bs->sg;
2751 int bdrv_enable_write_cache(BlockDriverState *bs)
2753 return bs->enable_write_cache;
2756 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2758 bs->enable_write_cache = wce;
2760 /* so a reopen() will preserve wce */
2761 if (wce) {
2762 bs->open_flags |= BDRV_O_CACHE_WB;
2763 } else {
2764 bs->open_flags &= ~BDRV_O_CACHE_WB;
2768 int bdrv_is_encrypted(BlockDriverState *bs)
2770 if (bs->backing && bs->backing->bs->encrypted) {
2771 return 1;
2773 return bs->encrypted;
2776 int bdrv_key_required(BlockDriverState *bs)
2778 BdrvChild *backing = bs->backing;
2780 if (backing && backing->bs->encrypted && !backing->bs->valid_key) {
2781 return 1;
2783 return (bs->encrypted && !bs->valid_key);
2786 int bdrv_set_key(BlockDriverState *bs, const char *key)
2788 int ret;
2789 if (bs->backing && bs->backing->bs->encrypted) {
2790 ret = bdrv_set_key(bs->backing->bs, key);
2791 if (ret < 0)
2792 return ret;
2793 if (!bs->encrypted)
2794 return 0;
2796 if (!bs->encrypted) {
2797 return -EINVAL;
2798 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2799 return -ENOMEDIUM;
2801 ret = bs->drv->bdrv_set_key(bs, key);
2802 if (ret < 0) {
2803 bs->valid_key = 0;
2804 } else if (!bs->valid_key) {
2805 bs->valid_key = 1;
2806 if (bs->blk) {
2807 /* call the change callback now, we skipped it on open */
2808 blk_dev_change_media_cb(bs->blk, true);
2811 return ret;
2815 * Provide an encryption key for @bs.
2816 * If @key is non-null:
2817 * If @bs is not encrypted, fail.
2818 * Else if the key is invalid, fail.
2819 * Else set @bs's key to @key, replacing the existing key, if any.
2820 * If @key is null:
2821 * If @bs is encrypted and still lacks a key, fail.
2822 * Else do nothing.
2823 * On failure, store an error object through @errp if non-null.
2825 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)
2827 if (key) {
2828 if (!bdrv_is_encrypted(bs)) {
2829 error_setg(errp, "Node '%s' is not encrypted",
2830 bdrv_get_device_or_node_name(bs));
2831 } else if (bdrv_set_key(bs, key) < 0) {
2832 error_setg(errp, QERR_INVALID_PASSWORD);
2834 } else {
2835 if (bdrv_key_required(bs)) {
2836 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,
2837 "'%s' (%s) is encrypted",
2838 bdrv_get_device_or_node_name(bs),
2839 bdrv_get_encrypted_filename(bs));
2844 const char *bdrv_get_format_name(BlockDriverState *bs)
2846 return bs->drv ? bs->drv->format_name : NULL;
2849 static int qsort_strcmp(const void *a, const void *b)
2851 return strcmp(a, b);
2854 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2855 void *opaque)
2857 BlockDriver *drv;
2858 int count = 0;
2859 int i;
2860 const char **formats = NULL;
2862 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2863 if (drv->format_name) {
2864 bool found = false;
2865 int i = count;
2866 while (formats && i && !found) {
2867 found = !strcmp(formats[--i], drv->format_name);
2870 if (!found) {
2871 formats = g_renew(const char *, formats, count + 1);
2872 formats[count++] = drv->format_name;
2877 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
2879 for (i = 0; i < count; i++) {
2880 it(opaque, formats[i]);
2883 g_free(formats);
2886 /* This function is to find a node in the bs graph */
2887 BlockDriverState *bdrv_find_node(const char *node_name)
2889 BlockDriverState *bs;
2891 assert(node_name);
2893 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2894 if (!strcmp(node_name, bs->node_name)) {
2895 return bs;
2898 return NULL;
2901 /* Put this QMP function here so it can access the static graph_bdrv_states. */
2902 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
2904 BlockDeviceInfoList *list, *entry;
2905 BlockDriverState *bs;
2907 list = NULL;
2908 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
2909 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp);
2910 if (!info) {
2911 qapi_free_BlockDeviceInfoList(list);
2912 return NULL;
2914 entry = g_malloc0(sizeof(*entry));
2915 entry->value = info;
2916 entry->next = list;
2917 list = entry;
2920 return list;
2923 BlockDriverState *bdrv_lookup_bs(const char *device,
2924 const char *node_name,
2925 Error **errp)
2927 BlockBackend *blk;
2928 BlockDriverState *bs;
2930 if (device) {
2931 blk = blk_by_name(device);
2933 if (blk) {
2934 bs = blk_bs(blk);
2935 if (!bs) {
2936 error_setg(errp, "Device '%s' has no medium", device);
2939 return bs;
2943 if (node_name) {
2944 bs = bdrv_find_node(node_name);
2946 if (bs) {
2947 return bs;
2951 error_setg(errp, "Cannot find device=%s nor node_name=%s",
2952 device ? device : "",
2953 node_name ? node_name : "");
2954 return NULL;
2957 /* If 'base' is in the same chain as 'top', return true. Otherwise,
2958 * return false. If either argument is NULL, return false. */
2959 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
2961 while (top && top != base) {
2962 top = backing_bs(top);
2965 return top != NULL;
2968 BlockDriverState *bdrv_next_node(BlockDriverState *bs)
2970 if (!bs) {
2971 return QTAILQ_FIRST(&graph_bdrv_states);
2973 return QTAILQ_NEXT(bs, node_list);
2976 BlockDriverState *bdrv_next(BlockDriverState *bs)
2978 if (!bs) {
2979 return QTAILQ_FIRST(&bdrv_states);
2981 return QTAILQ_NEXT(bs, device_list);
2984 const char *bdrv_get_node_name(const BlockDriverState *bs)
2986 return bs->node_name;
2989 /* TODO check what callers really want: bs->node_name or blk_name() */
2990 const char *bdrv_get_device_name(const BlockDriverState *bs)
2992 return bs->blk ? blk_name(bs->blk) : "";
2995 /* This can be used to identify nodes that might not have a device
2996 * name associated. Since node and device names live in the same
2997 * namespace, the result is unambiguous. The exception is if both are
2998 * absent, then this returns an empty (non-null) string. */
2999 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
3001 return bs->blk ? blk_name(bs->blk) : bs->node_name;
3004 int bdrv_get_flags(BlockDriverState *bs)
3006 return bs->open_flags;
3009 int bdrv_has_zero_init_1(BlockDriverState *bs)
3011 return 1;
3014 int bdrv_has_zero_init(BlockDriverState *bs)
3016 assert(bs->drv);
3018 /* If BS is a copy on write image, it is initialized to
3019 the contents of the base image, which may not be zeroes. */
3020 if (bs->backing) {
3021 return 0;
3023 if (bs->drv->bdrv_has_zero_init) {
3024 return bs->drv->bdrv_has_zero_init(bs);
3027 /* safe default */
3028 return 0;
3031 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3033 BlockDriverInfo bdi;
3035 if (bs->backing) {
3036 return false;
3039 if (bdrv_get_info(bs, &bdi) == 0) {
3040 return bdi.unallocated_blocks_are_zero;
3043 return false;
3046 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3048 BlockDriverInfo bdi;
3050 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) {
3051 return false;
3054 if (bdrv_get_info(bs, &bdi) == 0) {
3055 return bdi.can_write_zeroes_with_unmap;
3058 return false;
3061 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
3063 if (bs->backing && bs->backing->bs->encrypted)
3064 return bs->backing_file;
3065 else if (bs->encrypted)
3066 return bs->filename;
3067 else
3068 return NULL;
3071 void bdrv_get_backing_filename(BlockDriverState *bs,
3072 char *filename, int filename_size)
3074 pstrcpy(filename, filename_size, bs->backing_file);
3077 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3079 BlockDriver *drv = bs->drv;
3080 if (!drv)
3081 return -ENOMEDIUM;
3082 if (!drv->bdrv_get_info)
3083 return -ENOTSUP;
3084 memset(bdi, 0, sizeof(*bdi));
3085 return drv->bdrv_get_info(bs, bdi);
3088 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
3090 BlockDriver *drv = bs->drv;
3091 if (drv && drv->bdrv_get_specific_info) {
3092 return drv->bdrv_get_specific_info(bs);
3094 return NULL;
3097 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)
3099 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
3100 return;
3103 bs->drv->bdrv_debug_event(bs, event);
3106 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3107 const char *tag)
3109 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3110 bs = bs->file ? bs->file->bs : NULL;
3113 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3114 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3117 return -ENOTSUP;
3120 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
3122 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
3123 bs = bs->file ? bs->file->bs : NULL;
3126 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
3127 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
3130 return -ENOTSUP;
3133 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3135 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
3136 bs = bs->file ? bs->file->bs : NULL;
3139 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3140 return bs->drv->bdrv_debug_resume(bs, tag);
3143 return -ENOTSUP;
3146 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3148 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3149 bs = bs->file ? bs->file->bs : NULL;
3152 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3153 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3156 return false;
3159 int bdrv_is_snapshot(BlockDriverState *bs)
3161 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3164 /* backing_file can either be relative, or absolute, or a protocol. If it is
3165 * relative, it must be relative to the chain. So, passing in bs->filename
3166 * from a BDS as backing_file should not be done, as that may be relative to
3167 * the CWD rather than the chain. */
3168 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3169 const char *backing_file)
3171 char *filename_full = NULL;
3172 char *backing_file_full = NULL;
3173 char *filename_tmp = NULL;
3174 int is_protocol = 0;
3175 BlockDriverState *curr_bs = NULL;
3176 BlockDriverState *retval = NULL;
3178 if (!bs || !bs->drv || !backing_file) {
3179 return NULL;
3182 filename_full = g_malloc(PATH_MAX);
3183 backing_file_full = g_malloc(PATH_MAX);
3184 filename_tmp = g_malloc(PATH_MAX);
3186 is_protocol = path_has_protocol(backing_file);
3188 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) {
3190 /* If either of the filename paths is actually a protocol, then
3191 * compare unmodified paths; otherwise make paths relative */
3192 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3193 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3194 retval = curr_bs->backing->bs;
3195 break;
3197 } else {
3198 /* If not an absolute filename path, make it relative to the current
3199 * image's filename path */
3200 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3201 backing_file);
3203 /* We are going to compare absolute pathnames */
3204 if (!realpath(filename_tmp, filename_full)) {
3205 continue;
3208 /* We need to make sure the backing filename we are comparing against
3209 * is relative to the current image filename (or absolute) */
3210 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3211 curr_bs->backing_file);
3213 if (!realpath(filename_tmp, backing_file_full)) {
3214 continue;
3217 if (strcmp(backing_file_full, filename_full) == 0) {
3218 retval = curr_bs->backing->bs;
3219 break;
3224 g_free(filename_full);
3225 g_free(backing_file_full);
3226 g_free(filename_tmp);
3227 return retval;
3230 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3232 if (!bs->drv) {
3233 return 0;
3236 if (!bs->backing) {
3237 return 0;
3240 return 1 + bdrv_get_backing_file_depth(bs->backing->bs);
3243 void bdrv_init(void)
3245 module_call_init(MODULE_INIT_BLOCK);
3248 void bdrv_init_with_whitelist(void)
3250 use_bdrv_whitelist = 1;
3251 bdrv_init();
3254 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
3256 Error *local_err = NULL;
3257 int ret;
3259 if (!bs->drv) {
3260 return;
3263 if (!(bs->open_flags & BDRV_O_INCOMING)) {
3264 return;
3266 bs->open_flags &= ~BDRV_O_INCOMING;
3268 if (bs->drv->bdrv_invalidate_cache) {
3269 bs->drv->bdrv_invalidate_cache(bs, &local_err);
3270 } else if (bs->file) {
3271 bdrv_invalidate_cache(bs->file->bs, &local_err);
3273 if (local_err) {
3274 error_propagate(errp, local_err);
3275 return;
3278 ret = refresh_total_sectors(bs, bs->total_sectors);
3279 if (ret < 0) {
3280 error_setg_errno(errp, -ret, "Could not refresh total sector count");
3281 return;
3285 void bdrv_invalidate_cache_all(Error **errp)
3287 BlockDriverState *bs;
3288 Error *local_err = NULL;
3290 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3291 AioContext *aio_context = bdrv_get_aio_context(bs);
3293 aio_context_acquire(aio_context);
3294 bdrv_invalidate_cache(bs, &local_err);
3295 aio_context_release(aio_context);
3296 if (local_err) {
3297 error_propagate(errp, local_err);
3298 return;
3303 /**************************************************************/
3304 /* removable device support */
3307 * Return TRUE if the media is present
3309 bool bdrv_is_inserted(BlockDriverState *bs)
3311 BlockDriver *drv = bs->drv;
3312 BdrvChild *child;
3314 if (!drv) {
3315 return false;
3317 if (drv->bdrv_is_inserted) {
3318 return drv->bdrv_is_inserted(bs);
3320 QLIST_FOREACH(child, &bs->children, next) {
3321 if (!bdrv_is_inserted(child->bs)) {
3322 return false;
3325 return true;
3329 * Return whether the media changed since the last call to this
3330 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3332 int bdrv_media_changed(BlockDriverState *bs)
3334 BlockDriver *drv = bs->drv;
3336 if (drv && drv->bdrv_media_changed) {
3337 return drv->bdrv_media_changed(bs);
3339 return -ENOTSUP;
3343 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3345 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
3347 BlockDriver *drv = bs->drv;
3348 const char *device_name;
3350 if (drv && drv->bdrv_eject) {
3351 drv->bdrv_eject(bs, eject_flag);
3354 device_name = bdrv_get_device_name(bs);
3355 if (device_name[0] != '\0') {
3356 qapi_event_send_device_tray_moved(device_name,
3357 eject_flag, &error_abort);
3362 * Lock or unlock the media (if it is locked, the user won't be able
3363 * to eject it manually).
3365 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
3367 BlockDriver *drv = bs->drv;
3369 trace_bdrv_lock_medium(bs, locked);
3371 if (drv && drv->bdrv_lock_medium) {
3372 drv->bdrv_lock_medium(bs, locked);
3376 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name)
3378 BdrvDirtyBitmap *bm;
3380 assert(name);
3381 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3382 if (bm->name && !strcmp(name, bm->name)) {
3383 return bm;
3386 return NULL;
3389 void bdrv_dirty_bitmap_make_anon(BdrvDirtyBitmap *bitmap)
3391 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3392 g_free(bitmap->name);
3393 bitmap->name = NULL;
3396 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
3397 uint32_t granularity,
3398 const char *name,
3399 Error **errp)
3401 int64_t bitmap_size;
3402 BdrvDirtyBitmap *bitmap;
3403 uint32_t sector_granularity;
3405 assert((granularity & (granularity - 1)) == 0);
3407 if (name && bdrv_find_dirty_bitmap(bs, name)) {
3408 error_setg(errp, "Bitmap already exists: %s", name);
3409 return NULL;
3411 sector_granularity = granularity >> BDRV_SECTOR_BITS;
3412 assert(sector_granularity);
3413 bitmap_size = bdrv_nb_sectors(bs);
3414 if (bitmap_size < 0) {
3415 error_setg_errno(errp, -bitmap_size, "could not get length of device");
3416 errno = -bitmap_size;
3417 return NULL;
3419 bitmap = g_new0(BdrvDirtyBitmap, 1);
3420 bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(sector_granularity));
3421 bitmap->size = bitmap_size;
3422 bitmap->name = g_strdup(name);
3423 bitmap->disabled = false;
3424 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
3425 return bitmap;
3428 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap *bitmap)
3430 return bitmap->successor;
3433 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
3435 return !(bitmap->disabled || bitmap->successor);
3438 DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
3440 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3441 return DIRTY_BITMAP_STATUS_FROZEN;
3442 } else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3443 return DIRTY_BITMAP_STATUS_DISABLED;
3444 } else {
3445 return DIRTY_BITMAP_STATUS_ACTIVE;
3450 * Create a successor bitmap destined to replace this bitmap after an operation.
3451 * Requires that the bitmap is not frozen and has no successor.
3453 int bdrv_dirty_bitmap_create_successor(BlockDriverState *bs,
3454 BdrvDirtyBitmap *bitmap, Error **errp)
3456 uint64_t granularity;
3457 BdrvDirtyBitmap *child;
3459 if (bdrv_dirty_bitmap_frozen(bitmap)) {
3460 error_setg(errp, "Cannot create a successor for a bitmap that is "
3461 "currently frozen");
3462 return -1;
3464 assert(!bitmap->successor);
3466 /* Create an anonymous successor */
3467 granularity = bdrv_dirty_bitmap_granularity(bitmap);
3468 child = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp);
3469 if (!child) {
3470 return -1;
3473 /* Successor will be on or off based on our current state. */
3474 child->disabled = bitmap->disabled;
3476 /* Install the successor and freeze the parent */
3477 bitmap->successor = child;
3478 return 0;
3482 * For a bitmap with a successor, yield our name to the successor,
3483 * delete the old bitmap, and return a handle to the new bitmap.
3485 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BlockDriverState *bs,
3486 BdrvDirtyBitmap *bitmap,
3487 Error **errp)
3489 char *name;
3490 BdrvDirtyBitmap *successor = bitmap->successor;
3492 if (successor == NULL) {
3493 error_setg(errp, "Cannot relinquish control if "
3494 "there's no successor present");
3495 return NULL;
3498 name = bitmap->name;
3499 bitmap->name = NULL;
3500 successor->name = name;
3501 bitmap->successor = NULL;
3502 bdrv_release_dirty_bitmap(bs, bitmap);
3504 return successor;
3508 * In cases of failure where we can no longer safely delete the parent,
3509 * we may wish to re-join the parent and child/successor.
3510 * The merged parent will be un-frozen, but not explicitly re-enabled.
3512 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BlockDriverState *bs,
3513 BdrvDirtyBitmap *parent,
3514 Error **errp)
3516 BdrvDirtyBitmap *successor = parent->successor;
3518 if (!successor) {
3519 error_setg(errp, "Cannot reclaim a successor when none is present");
3520 return NULL;
3523 if (!hbitmap_merge(parent->bitmap, successor->bitmap)) {
3524 error_setg(errp, "Merging of parent and successor bitmap failed");
3525 return NULL;
3527 bdrv_release_dirty_bitmap(bs, successor);
3528 parent->successor = NULL;
3530 return parent;
3534 * Truncates _all_ bitmaps attached to a BDS.
3536 static void bdrv_dirty_bitmap_truncate(BlockDriverState *bs)
3538 BdrvDirtyBitmap *bitmap;
3539 uint64_t size = bdrv_nb_sectors(bs);
3541 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3542 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3543 hbitmap_truncate(bitmap->bitmap, size);
3544 bitmap->size = size;
3548 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
3550 BdrvDirtyBitmap *bm, *next;
3551 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
3552 if (bm == bitmap) {
3553 assert(!bdrv_dirty_bitmap_frozen(bm));
3554 QLIST_REMOVE(bitmap, list);
3555 hbitmap_free(bitmap->bitmap);
3556 g_free(bitmap->name);
3557 g_free(bitmap);
3558 return;
3563 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3565 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3566 bitmap->disabled = true;
3569 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap)
3571 assert(!bdrv_dirty_bitmap_frozen(bitmap));
3572 bitmap->disabled = false;
3575 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
3577 BdrvDirtyBitmap *bm;
3578 BlockDirtyInfoList *list = NULL;
3579 BlockDirtyInfoList **plist = &list;
3581 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
3582 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
3583 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
3584 info->count = bdrv_get_dirty_count(bm);
3585 info->granularity = bdrv_dirty_bitmap_granularity(bm);
3586 info->has_name = !!bm->name;
3587 info->name = g_strdup(bm->name);
3588 info->status = bdrv_dirty_bitmap_status(bm);
3589 entry->value = info;
3590 *plist = entry;
3591 plist = &entry->next;
3594 return list;
3597 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
3599 if (bitmap) {
3600 return hbitmap_get(bitmap->bitmap, sector);
3601 } else {
3602 return 0;
3607 * Chooses a default granularity based on the existing cluster size,
3608 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
3609 * is no cluster size information available.
3611 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)
3613 BlockDriverInfo bdi;
3614 uint32_t granularity;
3616 if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {
3617 granularity = MAX(4096, bdi.cluster_size);
3618 granularity = MIN(65536, granularity);
3619 } else {
3620 granularity = 65536;
3623 return granularity;
3626 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap *bitmap)
3628 return BDRV_SECTOR_SIZE << hbitmap_granularity(bitmap->bitmap);
3631 void bdrv_dirty_iter_init(BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
3633 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
3636 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3637 int64_t cur_sector, int nr_sectors)
3639 assert(bdrv_dirty_bitmap_enabled(bitmap));
3640 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3643 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
3644 int64_t cur_sector, int nr_sectors)
3646 assert(bdrv_dirty_bitmap_enabled(bitmap));
3647 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
3650 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out)
3652 assert(bdrv_dirty_bitmap_enabled(bitmap));
3653 if (!out) {
3654 hbitmap_reset_all(bitmap->bitmap);
3655 } else {
3656 HBitmap *backup = bitmap->bitmap;
3657 bitmap->bitmap = hbitmap_alloc(bitmap->size,
3658 hbitmap_granularity(backup));
3659 *out = backup;
3663 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in)
3665 HBitmap *tmp = bitmap->bitmap;
3666 assert(bdrv_dirty_bitmap_enabled(bitmap));
3667 bitmap->bitmap = in;
3668 hbitmap_free(tmp);
3671 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
3672 int nr_sectors)
3674 BdrvDirtyBitmap *bitmap;
3675 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
3676 if (!bdrv_dirty_bitmap_enabled(bitmap)) {
3677 continue;
3679 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
3684 * Advance an HBitmapIter to an arbitrary offset.
3686 void bdrv_set_dirty_iter(HBitmapIter *hbi, int64_t offset)
3688 assert(hbi->hb);
3689 hbitmap_iter_init(hbi, hbi->hb, offset);
3692 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap)
3694 return hbitmap_count(bitmap->bitmap);
3697 /* Get a reference to bs */
3698 void bdrv_ref(BlockDriverState *bs)
3700 bs->refcnt++;
3703 /* Release a previously grabbed reference to bs.
3704 * If after releasing, reference count is zero, the BlockDriverState is
3705 * deleted. */
3706 void bdrv_unref(BlockDriverState *bs)
3708 if (!bs) {
3709 return;
3711 assert(bs->refcnt > 0);
3712 if (--bs->refcnt == 0) {
3713 bdrv_delete(bs);
3717 struct BdrvOpBlocker {
3718 Error *reason;
3719 QLIST_ENTRY(BdrvOpBlocker) list;
3722 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
3724 BdrvOpBlocker *blocker;
3725 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3726 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
3727 blocker = QLIST_FIRST(&bs->op_blockers[op]);
3728 if (errp) {
3729 *errp = error_copy(blocker->reason);
3730 error_prepend(errp, "Node '%s' is busy: ",
3731 bdrv_get_device_or_node_name(bs));
3733 return true;
3735 return false;
3738 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
3740 BdrvOpBlocker *blocker;
3741 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3743 blocker = g_new0(BdrvOpBlocker, 1);
3744 blocker->reason = reason;
3745 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
3748 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
3750 BdrvOpBlocker *blocker, *next;
3751 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
3752 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
3753 if (blocker->reason == reason) {
3754 QLIST_REMOVE(blocker, list);
3755 g_free(blocker);
3760 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
3762 int i;
3763 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3764 bdrv_op_block(bs, i, reason);
3768 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
3770 int i;
3771 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3772 bdrv_op_unblock(bs, i, reason);
3776 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
3778 int i;
3780 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
3781 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
3782 return false;
3785 return true;
3788 void bdrv_img_create(const char *filename, const char *fmt,
3789 const char *base_filename, const char *base_fmt,
3790 char *options, uint64_t img_size, int flags,
3791 Error **errp, bool quiet)
3793 QemuOptsList *create_opts = NULL;
3794 QemuOpts *opts = NULL;
3795 const char *backing_fmt, *backing_file;
3796 int64_t size;
3797 BlockDriver *drv, *proto_drv;
3798 Error *local_err = NULL;
3799 int ret = 0;
3801 /* Find driver and parse its options */
3802 drv = bdrv_find_format(fmt);
3803 if (!drv) {
3804 error_setg(errp, "Unknown file format '%s'", fmt);
3805 return;
3808 proto_drv = bdrv_find_protocol(filename, true, errp);
3809 if (!proto_drv) {
3810 return;
3813 if (!drv->create_opts) {
3814 error_setg(errp, "Format driver '%s' does not support image creation",
3815 drv->format_name);
3816 return;
3819 if (!proto_drv->create_opts) {
3820 error_setg(errp, "Protocol driver '%s' does not support image creation",
3821 proto_drv->format_name);
3822 return;
3825 create_opts = qemu_opts_append(create_opts, drv->create_opts);
3826 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
3828 /* Create parameter list with default values */
3829 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
3830 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
3832 /* Parse -o options */
3833 if (options) {
3834 qemu_opts_do_parse(opts, options, NULL, &local_err);
3835 if (local_err) {
3836 error_report_err(local_err);
3837 local_err = NULL;
3838 error_setg(errp, "Invalid options for file format '%s'", fmt);
3839 goto out;
3843 if (base_filename) {
3844 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
3845 if (local_err) {
3846 error_setg(errp, "Backing file not supported for file format '%s'",
3847 fmt);
3848 goto out;
3852 if (base_fmt) {
3853 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err);
3854 if (local_err) {
3855 error_setg(errp, "Backing file format not supported for file "
3856 "format '%s'", fmt);
3857 goto out;
3861 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
3862 if (backing_file) {
3863 if (!strcmp(filename, backing_file)) {
3864 error_setg(errp, "Error: Trying to create an image with the "
3865 "same filename as the backing file");
3866 goto out;
3870 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
3872 // The size for the image must always be specified, with one exception:
3873 // If we are using a backing file, we can obtain the size from there
3874 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
3875 if (size == -1) {
3876 if (backing_file) {
3877 BlockDriverState *bs;
3878 char *full_backing = g_new0(char, PATH_MAX);
3879 int64_t size;
3880 int back_flags;
3881 QDict *backing_options = NULL;
3883 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
3884 full_backing, PATH_MAX,
3885 &local_err);
3886 if (local_err) {
3887 g_free(full_backing);
3888 goto out;
3891 /* backing files always opened read-only */
3892 back_flags =
3893 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
3895 if (backing_fmt) {
3896 backing_options = qdict_new();
3897 qdict_put(backing_options, "driver",
3898 qstring_from_str(backing_fmt));
3901 bs = NULL;
3902 ret = bdrv_open(&bs, full_backing, NULL, backing_options,
3903 back_flags, &local_err);
3904 g_free(full_backing);
3905 if (ret < 0) {
3906 goto out;
3908 size = bdrv_getlength(bs);
3909 if (size < 0) {
3910 error_setg_errno(errp, -size, "Could not get size of '%s'",
3911 backing_file);
3912 bdrv_unref(bs);
3913 goto out;
3916 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
3918 bdrv_unref(bs);
3919 } else {
3920 error_setg(errp, "Image creation needs a size parameter");
3921 goto out;
3925 if (!quiet) {
3926 printf("Formatting '%s', fmt=%s ", filename, fmt);
3927 qemu_opts_print(opts, " ");
3928 puts("");
3931 ret = bdrv_create(drv, filename, opts, &local_err);
3933 if (ret == -EFBIG) {
3934 /* This is generally a better message than whatever the driver would
3935 * deliver (especially because of the cluster_size_hint), since that
3936 * is most probably not much different from "image too large". */
3937 const char *cluster_size_hint = "";
3938 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
3939 cluster_size_hint = " (try using a larger cluster size)";
3941 error_setg(errp, "The image size is too large for file format '%s'"
3942 "%s", fmt, cluster_size_hint);
3943 error_free(local_err);
3944 local_err = NULL;
3947 out:
3948 qemu_opts_del(opts);
3949 qemu_opts_free(create_opts);
3950 if (local_err) {
3951 error_propagate(errp, local_err);
3955 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
3957 return bs->aio_context;
3960 void bdrv_detach_aio_context(BlockDriverState *bs)
3962 BdrvAioNotifier *baf;
3964 if (!bs->drv) {
3965 return;
3968 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
3969 baf->detach_aio_context(baf->opaque);
3972 if (bs->throttle_state) {
3973 throttle_timers_detach_aio_context(&bs->throttle_timers);
3975 if (bs->drv->bdrv_detach_aio_context) {
3976 bs->drv->bdrv_detach_aio_context(bs);
3978 if (bs->file) {
3979 bdrv_detach_aio_context(bs->file->bs);
3981 if (bs->backing) {
3982 bdrv_detach_aio_context(bs->backing->bs);
3985 bs->aio_context = NULL;
3988 void bdrv_attach_aio_context(BlockDriverState *bs,
3989 AioContext *new_context)
3991 BdrvAioNotifier *ban;
3993 if (!bs->drv) {
3994 return;
3997 bs->aio_context = new_context;
3999 if (bs->backing) {
4000 bdrv_attach_aio_context(bs->backing->bs, new_context);
4002 if (bs->file) {
4003 bdrv_attach_aio_context(bs->file->bs, new_context);
4005 if (bs->drv->bdrv_attach_aio_context) {
4006 bs->drv->bdrv_attach_aio_context(bs, new_context);
4008 if (bs->throttle_state) {
4009 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context);
4012 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
4013 ban->attached_aio_context(new_context, ban->opaque);
4017 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
4019 bdrv_drain(bs); /* ensure there are no in-flight requests */
4021 bdrv_detach_aio_context(bs);
4023 /* This function executes in the old AioContext so acquire the new one in
4024 * case it runs in a different thread.
4026 aio_context_acquire(new_context);
4027 bdrv_attach_aio_context(bs, new_context);
4028 aio_context_release(new_context);
4031 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
4032 void (*attached_aio_context)(AioContext *new_context, void *opaque),
4033 void (*detach_aio_context)(void *opaque), void *opaque)
4035 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
4036 *ban = (BdrvAioNotifier){
4037 .attached_aio_context = attached_aio_context,
4038 .detach_aio_context = detach_aio_context,
4039 .opaque = opaque
4042 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
4045 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
4046 void (*attached_aio_context)(AioContext *,
4047 void *),
4048 void (*detach_aio_context)(void *),
4049 void *opaque)
4051 BdrvAioNotifier *ban, *ban_next;
4053 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
4054 if (ban->attached_aio_context == attached_aio_context &&
4055 ban->detach_aio_context == detach_aio_context &&
4056 ban->opaque == opaque)
4058 QLIST_REMOVE(ban, list);
4059 g_free(ban);
4061 return;
4065 abort();
4068 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
4069 BlockDriverAmendStatusCB *status_cb, void *cb_opaque)
4071 if (!bs->drv->bdrv_amend_options) {
4072 return -ENOTSUP;
4074 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque);
4077 /* This function will be called by the bdrv_recurse_is_first_non_filter method
4078 * of block filter and by bdrv_is_first_non_filter.
4079 * It is used to test if the given bs is the candidate or recurse more in the
4080 * node graph.
4082 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
4083 BlockDriverState *candidate)
4085 /* return false if basic checks fails */
4086 if (!bs || !bs->drv) {
4087 return false;
4090 /* the code reached a non block filter driver -> check if the bs is
4091 * the same as the candidate. It's the recursion termination condition.
4093 if (!bs->drv->is_filter) {
4094 return bs == candidate;
4096 /* Down this path the driver is a block filter driver */
4098 /* If the block filter recursion method is defined use it to recurse down
4099 * the node graph.
4101 if (bs->drv->bdrv_recurse_is_first_non_filter) {
4102 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
4105 /* the driver is a block filter but don't allow to recurse -> return false
4107 return false;
4110 /* This function checks if the candidate is the first non filter bs down it's
4111 * bs chain. Since we don't have pointers to parents it explore all bs chains
4112 * from the top. Some filters can choose not to pass down the recursion.
4114 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
4116 BlockDriverState *bs;
4118 /* walk down the bs forest recursively */
4119 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4120 bool perm;
4122 /* try to recurse in this top level bs */
4123 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
4125 /* candidate is the first non filter */
4126 if (perm) {
4127 return true;
4131 return false;
4134 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs,
4135 const char *node_name, Error **errp)
4137 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
4138 AioContext *aio_context;
4140 if (!to_replace_bs) {
4141 error_setg(errp, "Node name '%s' not found", node_name);
4142 return NULL;
4145 aio_context = bdrv_get_aio_context(to_replace_bs);
4146 aio_context_acquire(aio_context);
4148 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
4149 to_replace_bs = NULL;
4150 goto out;
4153 /* We don't want arbitrary node of the BDS chain to be replaced only the top
4154 * most non filter in order to prevent data corruption.
4155 * Another benefit is that this tests exclude backing files which are
4156 * blocked by the backing blockers.
4158 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) {
4159 error_setg(errp, "Only top most non filter can be replaced");
4160 to_replace_bs = NULL;
4161 goto out;
4164 out:
4165 aio_context_release(aio_context);
4166 return to_replace_bs;
4169 static bool append_open_options(QDict *d, BlockDriverState *bs)
4171 const QDictEntry *entry;
4172 QemuOptDesc *desc;
4173 BdrvChild *child;
4174 bool found_any = false;
4175 const char *p;
4177 for (entry = qdict_first(bs->options); entry;
4178 entry = qdict_next(bs->options, entry))
4180 /* Exclude options for children */
4181 QLIST_FOREACH(child, &bs->children, next) {
4182 if (strstart(qdict_entry_key(entry), child->name, &p)
4183 && (!*p || *p == '.'))
4185 break;
4188 if (child) {
4189 continue;
4192 /* And exclude all non-driver-specific options */
4193 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) {
4194 if (!strcmp(qdict_entry_key(entry), desc->name)) {
4195 break;
4198 if (desc->name) {
4199 continue;
4202 qobject_incref(qdict_entry_value(entry));
4203 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
4204 found_any = true;
4207 return found_any;
4210 /* Updates the following BDS fields:
4211 * - exact_filename: A filename which may be used for opening a block device
4212 * which (mostly) equals the given BDS (even without any
4213 * other options; so reading and writing must return the same
4214 * results, but caching etc. may be different)
4215 * - full_open_options: Options which, when given when opening a block device
4216 * (without a filename), result in a BDS (mostly)
4217 * equalling the given one
4218 * - filename: If exact_filename is set, it is copied here. Otherwise,
4219 * full_open_options is converted to a JSON object, prefixed with
4220 * "json:" (for use through the JSON pseudo protocol) and put here.
4222 void bdrv_refresh_filename(BlockDriverState *bs)
4224 BlockDriver *drv = bs->drv;
4225 QDict *opts;
4227 if (!drv) {
4228 return;
4231 /* This BDS's file name will most probably depend on its file's name, so
4232 * refresh that first */
4233 if (bs->file) {
4234 bdrv_refresh_filename(bs->file->bs);
4237 if (drv->bdrv_refresh_filename) {
4238 /* Obsolete information is of no use here, so drop the old file name
4239 * information before refreshing it */
4240 bs->exact_filename[0] = '\0';
4241 if (bs->full_open_options) {
4242 QDECREF(bs->full_open_options);
4243 bs->full_open_options = NULL;
4246 opts = qdict_new();
4247 append_open_options(opts, bs);
4248 drv->bdrv_refresh_filename(bs, opts);
4249 QDECREF(opts);
4250 } else if (bs->file) {
4251 /* Try to reconstruct valid information from the underlying file */
4252 bool has_open_options;
4254 bs->exact_filename[0] = '\0';
4255 if (bs->full_open_options) {
4256 QDECREF(bs->full_open_options);
4257 bs->full_open_options = NULL;
4260 opts = qdict_new();
4261 has_open_options = append_open_options(opts, bs);
4263 /* If no specific options have been given for this BDS, the filename of
4264 * the underlying file should suffice for this one as well */
4265 if (bs->file->bs->exact_filename[0] && !has_open_options) {
4266 strcpy(bs->exact_filename, bs->file->bs->exact_filename);
4268 /* Reconstructing the full options QDict is simple for most format block
4269 * drivers, as long as the full options are known for the underlying
4270 * file BDS. The full options QDict of that file BDS should somehow
4271 * contain a representation of the filename, therefore the following
4272 * suffices without querying the (exact_)filename of this BDS. */
4273 if (bs->file->bs->full_open_options) {
4274 qdict_put_obj(opts, "driver",
4275 QOBJECT(qstring_from_str(drv->format_name)));
4276 QINCREF(bs->file->bs->full_open_options);
4277 qdict_put_obj(opts, "file",
4278 QOBJECT(bs->file->bs->full_open_options));
4280 bs->full_open_options = opts;
4281 } else {
4282 QDECREF(opts);
4284 } else if (!bs->full_open_options && qdict_size(bs->options)) {
4285 /* There is no underlying file BDS (at least referenced by BDS.file),
4286 * so the full options QDict should be equal to the options given
4287 * specifically for this block device when it was opened (plus the
4288 * driver specification).
4289 * Because those options don't change, there is no need to update
4290 * full_open_options when it's already set. */
4292 opts = qdict_new();
4293 append_open_options(opts, bs);
4294 qdict_put_obj(opts, "driver",
4295 QOBJECT(qstring_from_str(drv->format_name)));
4297 if (bs->exact_filename[0]) {
4298 /* This may not work for all block protocol drivers (some may
4299 * require this filename to be parsed), but we have to find some
4300 * default solution here, so just include it. If some block driver
4301 * does not support pure options without any filename at all or
4302 * needs some special format of the options QDict, it needs to
4303 * implement the driver-specific bdrv_refresh_filename() function.
4305 qdict_put_obj(opts, "filename",
4306 QOBJECT(qstring_from_str(bs->exact_filename)));
4309 bs->full_open_options = opts;
4312 if (bs->exact_filename[0]) {
4313 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
4314 } else if (bs->full_open_options) {
4315 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
4316 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
4317 qstring_get_str(json));
4318 QDECREF(json);