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
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
41 #include <sys/types.h>
43 #include <sys/ioctl.h>
44 #include <sys/queue.h>
54 struct BdrvDirtyBitmap {
56 QLIST_ENTRY(BdrvDirtyBitmap) list;
59 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
61 static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
63 BlockCompletionFunc *cb, void *opaque);
64 static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
66 BlockCompletionFunc *cb, void *opaque);
67 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
68 int64_t sector_num, int nb_sectors,
70 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
71 int64_t sector_num, int nb_sectors,
73 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
74 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
75 BdrvRequestFlags flags);
76 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
77 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
78 BdrvRequestFlags flags);
79 static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
83 BdrvRequestFlags flags,
84 BlockCompletionFunc *cb,
87 static void coroutine_fn bdrv_co_do_rw(void *opaque);
88 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
89 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
91 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
92 QTAILQ_HEAD_INITIALIZER(bdrv_states);
94 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
97 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
98 QLIST_HEAD_INITIALIZER(bdrv_drivers);
100 /* If non-zero, use only whitelisted block drivers */
101 static int use_bdrv_whitelist;
104 static int is_windows_drive_prefix(const char *filename)
106 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
107 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
111 int is_windows_drive(const char *filename)
113 if (is_windows_drive_prefix(filename) &&
116 if (strstart(filename, "\\\\.\\", NULL) ||
117 strstart(filename, "//./", NULL))
123 /* throttling disk I/O limits */
124 void bdrv_set_io_limits(BlockDriverState *bs,
129 throttle_config(&bs->throttle_state, cfg);
131 for (i = 0; i < 2; i++) {
132 qemu_co_enter_next(&bs->throttled_reqs[i]);
136 /* this function drain all the throttled IOs */
137 static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
139 bool drained = false;
140 bool enabled = bs->io_limits_enabled;
143 bs->io_limits_enabled = false;
145 for (i = 0; i < 2; i++) {
146 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
151 bs->io_limits_enabled = enabled;
156 void bdrv_io_limits_disable(BlockDriverState *bs)
158 bs->io_limits_enabled = false;
160 bdrv_start_throttled_reqs(bs);
162 throttle_destroy(&bs->throttle_state);
165 static void bdrv_throttle_read_timer_cb(void *opaque)
167 BlockDriverState *bs = opaque;
168 qemu_co_enter_next(&bs->throttled_reqs[0]);
171 static void bdrv_throttle_write_timer_cb(void *opaque)
173 BlockDriverState *bs = opaque;
174 qemu_co_enter_next(&bs->throttled_reqs[1]);
177 /* should be called before bdrv_set_io_limits if a limit is set */
178 void bdrv_io_limits_enable(BlockDriverState *bs)
180 assert(!bs->io_limits_enabled);
181 throttle_init(&bs->throttle_state,
182 bdrv_get_aio_context(bs),
184 bdrv_throttle_read_timer_cb,
185 bdrv_throttle_write_timer_cb,
187 bs->io_limits_enabled = true;
190 /* This function makes an IO wait if needed
192 * @nb_sectors: the number of sectors of the IO
193 * @is_write: is the IO a write
195 static void bdrv_io_limits_intercept(BlockDriverState *bs,
199 /* does this io must wait */
200 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
202 /* if must wait or any request of this type throttled queue the IO */
204 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
205 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
208 /* the IO will be executed, do the accounting */
209 throttle_account(&bs->throttle_state, is_write, bytes);
212 /* if the next request must wait -> do nothing */
213 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
217 /* else queue next request for execution */
218 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
221 size_t bdrv_opt_mem_align(BlockDriverState *bs)
223 if (!bs || !bs->drv) {
224 /* 4k should be on the safe side */
228 return bs->bl.opt_mem_alignment;
231 /* check if the path starts with "<protocol>:" */
232 static int path_has_protocol(const char *path)
237 if (is_windows_drive(path) ||
238 is_windows_drive_prefix(path)) {
241 p = path + strcspn(path, ":/\\");
243 p = path + strcspn(path, ":/");
249 int path_is_absolute(const char *path)
252 /* specific case for names like: "\\.\d:" */
253 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
256 return (*path == '/' || *path == '\\');
258 return (*path == '/');
262 /* if filename is absolute, just copy it to dest. Otherwise, build a
263 path to it by considering it is relative to base_path. URL are
265 void path_combine(char *dest, int dest_size,
266 const char *base_path,
267 const char *filename)
274 if (path_is_absolute(filename)) {
275 pstrcpy(dest, dest_size, filename);
277 p = strchr(base_path, ':');
282 p1 = strrchr(base_path, '/');
286 p2 = strrchr(base_path, '\\');
298 if (len > dest_size - 1)
300 memcpy(dest, base_path, len);
302 pstrcat(dest, dest_size, filename);
306 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
308 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
309 pstrcpy(dest, sz, bs->backing_file);
311 path_combine(dest, sz, bs->filename, bs->backing_file);
315 void bdrv_register(BlockDriver *bdrv)
317 /* Block drivers without coroutine functions need emulation */
318 if (!bdrv->bdrv_co_readv) {
319 bdrv->bdrv_co_readv = bdrv_co_readv_em;
320 bdrv->bdrv_co_writev = bdrv_co_writev_em;
322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
323 * the block driver lacks aio we need to emulate that too.
325 if (!bdrv->bdrv_aio_readv) {
326 /* add AIO emulation layer */
327 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
328 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
332 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
335 BlockDriverState *bdrv_new_root(void)
337 BlockDriverState *bs = bdrv_new();
339 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
343 BlockDriverState *bdrv_new(void)
345 BlockDriverState *bs;
348 bs = g_new0(BlockDriverState, 1);
349 QLIST_INIT(&bs->dirty_bitmaps);
350 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
351 QLIST_INIT(&bs->op_blockers[i]);
353 bdrv_iostatus_disable(bs);
354 notifier_list_init(&bs->close_notifiers);
355 notifier_with_return_list_init(&bs->before_write_notifiers);
356 qemu_co_queue_init(&bs->throttled_reqs[0]);
357 qemu_co_queue_init(&bs->throttled_reqs[1]);
359 bs->aio_context = qemu_get_aio_context();
364 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
366 notifier_list_add(&bs->close_notifiers, notify);
369 BlockDriver *bdrv_find_format(const char *format_name)
372 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
373 if (!strcmp(drv1->format_name, format_name)) {
380 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
382 static const char *whitelist_rw[] = {
383 CONFIG_BDRV_RW_WHITELIST
385 static const char *whitelist_ro[] = {
386 CONFIG_BDRV_RO_WHITELIST
390 if (!whitelist_rw[0] && !whitelist_ro[0]) {
391 return 1; /* no whitelist, anything goes */
394 for (p = whitelist_rw; *p; p++) {
395 if (!strcmp(drv->format_name, *p)) {
400 for (p = whitelist_ro; *p; p++) {
401 if (!strcmp(drv->format_name, *p)) {
409 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
412 BlockDriver *drv = bdrv_find_format(format_name);
413 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
416 typedef struct CreateCo {
424 static void coroutine_fn bdrv_create_co_entry(void *opaque)
426 Error *local_err = NULL;
429 CreateCo *cco = opaque;
432 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
434 error_propagate(&cco->err, local_err);
439 int bdrv_create(BlockDriver *drv, const char* filename,
440 QemuOpts *opts, Error **errp)
447 .filename = g_strdup(filename),
453 if (!drv->bdrv_create) {
454 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
459 if (qemu_in_coroutine()) {
460 /* Fast-path if already in coroutine context */
461 bdrv_create_co_entry(&cco);
463 co = qemu_coroutine_create(bdrv_create_co_entry);
464 qemu_coroutine_enter(co, &cco);
465 while (cco.ret == NOT_DONE) {
466 aio_poll(qemu_get_aio_context(), true);
473 error_propagate(errp, cco.err);
475 error_setg_errno(errp, -ret, "Could not create image");
480 g_free(cco.filename);
484 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
487 Error *local_err = NULL;
490 drv = bdrv_find_protocol(filename, true);
492 error_setg(errp, "Could not find protocol for file '%s'", filename);
496 ret = bdrv_create(drv, filename, opts, &local_err);
498 error_propagate(errp, local_err);
503 void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
505 BlockDriver *drv = bs->drv;
506 Error *local_err = NULL;
508 memset(&bs->bl, 0, sizeof(bs->bl));
514 /* Take some limits from the children as a default */
516 bdrv_refresh_limits(bs->file, &local_err);
518 error_propagate(errp, local_err);
521 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
522 bs->bl.max_transfer_length = bs->file->bl.max_transfer_length;
523 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
525 bs->bl.opt_mem_alignment = 512;
528 if (bs->backing_hd) {
529 bdrv_refresh_limits(bs->backing_hd, &local_err);
531 error_propagate(errp, local_err);
534 bs->bl.opt_transfer_length =
535 MAX(bs->bl.opt_transfer_length,
536 bs->backing_hd->bl.opt_transfer_length);
537 bs->bl.max_transfer_length =
538 MIN_NON_ZERO(bs->bl.max_transfer_length,
539 bs->backing_hd->bl.max_transfer_length);
540 bs->bl.opt_mem_alignment =
541 MAX(bs->bl.opt_mem_alignment,
542 bs->backing_hd->bl.opt_mem_alignment);
545 /* Then let the driver override it */
546 if (drv->bdrv_refresh_limits) {
547 drv->bdrv_refresh_limits(bs, errp);
552 * Create a uniquely-named empty temporary file.
553 * Return 0 upon success, otherwise a negative errno value.
555 int get_tmp_filename(char *filename, int size)
558 char temp_dir[MAX_PATH];
559 /* GetTempFileName requires that its output buffer (4th param)
560 have length MAX_PATH or greater. */
561 assert(size >= MAX_PATH);
562 return (GetTempPath(MAX_PATH, temp_dir)
563 && GetTempFileName(temp_dir, "qem", 0, filename)
564 ? 0 : -GetLastError());
568 tmpdir = getenv("TMPDIR");
572 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
575 fd = mkstemp(filename);
579 if (close(fd) != 0) {
588 * Detect host devices. By convention, /dev/cdrom[N] is always
589 * recognized as a host CDROM.
591 static BlockDriver *find_hdev_driver(const char *filename)
593 int score_max = 0, score;
594 BlockDriver *drv = NULL, *d;
596 QLIST_FOREACH(d, &bdrv_drivers, list) {
597 if (d->bdrv_probe_device) {
598 score = d->bdrv_probe_device(filename);
599 if (score > score_max) {
609 BlockDriver *bdrv_find_protocol(const char *filename,
610 bool allow_protocol_prefix)
617 /* TODO Drivers without bdrv_file_open must be specified explicitly */
620 * XXX(hch): we really should not let host device detection
621 * override an explicit protocol specification, but moving this
622 * later breaks access to device names with colons in them.
623 * Thanks to the brain-dead persistent naming schemes on udev-
624 * based Linux systems those actually are quite common.
626 drv1 = find_hdev_driver(filename);
631 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
632 return bdrv_find_format("file");
635 p = strchr(filename, ':');
638 if (len > sizeof(protocol) - 1)
639 len = sizeof(protocol) - 1;
640 memcpy(protocol, filename, len);
641 protocol[len] = '\0';
642 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
643 if (drv1->protocol_name &&
644 !strcmp(drv1->protocol_name, protocol)) {
651 static int find_image_format(BlockDriverState *bs, const char *filename,
652 BlockDriver **pdrv, Error **errp)
654 int score, score_max;
655 BlockDriver *drv1, *drv;
659 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
660 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
661 drv = bdrv_find_format("raw");
663 error_setg(errp, "Could not find raw image format");
670 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
672 error_setg_errno(errp, -ret, "Could not read image for determining its "
680 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
681 if (drv1->bdrv_probe) {
682 score = drv1->bdrv_probe(buf, ret, filename);
683 if (score > score_max) {
690 error_setg(errp, "Could not determine image format: No compatible "
699 * Set the current 'total_sectors' value
700 * Return 0 on success, -errno on error.
702 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
704 BlockDriver *drv = bs->drv;
706 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
710 /* query actual device if possible, otherwise just trust the hint */
711 if (drv->bdrv_getlength) {
712 int64_t length = drv->bdrv_getlength(bs);
716 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
719 bs->total_sectors = hint;
724 * Set open flags for a given discard mode
726 * Return 0 on success, -1 if the discard mode was invalid.
728 int bdrv_parse_discard_flags(const char *mode, int *flags)
730 *flags &= ~BDRV_O_UNMAP;
732 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
734 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
735 *flags |= BDRV_O_UNMAP;
744 * Set open flags for a given cache mode
746 * Return 0 on success, -1 if the cache mode was invalid.
748 int bdrv_parse_cache_flags(const char *mode, int *flags)
750 *flags &= ~BDRV_O_CACHE_MASK;
752 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
753 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
754 } else if (!strcmp(mode, "directsync")) {
755 *flags |= BDRV_O_NOCACHE;
756 } else if (!strcmp(mode, "writeback")) {
757 *flags |= BDRV_O_CACHE_WB;
758 } else if (!strcmp(mode, "unsafe")) {
759 *flags |= BDRV_O_CACHE_WB;
760 *flags |= BDRV_O_NO_FLUSH;
761 } else if (!strcmp(mode, "writethrough")) {
762 /* this is the default */
771 * The copy-on-read flag is actually a reference count so multiple users may
772 * use the feature without worrying about clobbering its previous state.
773 * Copy-on-read stays enabled until all users have called to disable it.
775 void bdrv_enable_copy_on_read(BlockDriverState *bs)
780 void bdrv_disable_copy_on_read(BlockDriverState *bs)
782 assert(bs->copy_on_read > 0);
787 * Returns the flags that a temporary snapshot should get, based on the
788 * originally requested flags (the originally requested image will have flags
789 * like a backing file)
791 static int bdrv_temp_snapshot_flags(int flags)
793 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
797 * Returns the flags that bs->file should get, based on the given flags for
800 static int bdrv_inherited_flags(int flags)
802 /* Enable protocol handling, disable format probing for bs->file */
803 flags |= BDRV_O_PROTOCOL;
805 /* Our block drivers take care to send flushes and respect unmap policy,
806 * so we can enable both unconditionally on lower layers. */
807 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
809 /* Clear flags that only apply to the top layer */
810 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
816 * Returns the flags that bs->backing_hd should get, based on the given flags
819 static int bdrv_backing_flags(int flags)
821 /* backing files always opened read-only */
822 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
824 /* snapshot=on is handled on the top layer */
825 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
830 static int bdrv_open_flags(BlockDriverState *bs, int flags)
832 int open_flags = flags | BDRV_O_CACHE_WB;
835 * Clear flags that are internal to the block layer before opening the
838 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
841 * Snapshots should be writable.
843 if (flags & BDRV_O_TEMPORARY) {
844 open_flags |= BDRV_O_RDWR;
850 static void bdrv_assign_node_name(BlockDriverState *bs,
851 const char *node_name,
858 /* Check for empty string or invalid characters */
859 if (!id_wellformed(node_name)) {
860 error_setg(errp, "Invalid node name");
864 /* takes care of avoiding namespaces collisions */
865 if (blk_by_name(node_name)) {
866 error_setg(errp, "node-name=%s is conflicting with a device id",
871 /* takes care of avoiding duplicates node names */
872 if (bdrv_find_node(node_name)) {
873 error_setg(errp, "Duplicate node name");
877 /* copy node name into the bs and insert it into the graph list */
878 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
879 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
883 * Common part for opening disk images and files
885 * Removes all processed options from *options.
887 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
888 QDict *options, int flags, BlockDriver *drv, Error **errp)
891 const char *filename;
892 const char *node_name = NULL;
893 Error *local_err = NULL;
896 assert(bs->file == NULL);
897 assert(options != NULL && bs->options != options);
900 filename = file->filename;
902 filename = qdict_get_try_str(options, "filename");
905 if (drv->bdrv_needs_filename && !filename) {
906 error_setg(errp, "The '%s' block driver requires a file name",
911 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
913 node_name = qdict_get_try_str(options, "node-name");
914 bdrv_assign_node_name(bs, node_name, &local_err);
916 error_propagate(errp, local_err);
919 qdict_del(options, "node-name");
921 /* bdrv_open() with directly using a protocol as drv. This layer is already
922 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
923 * and return immediately. */
924 if (file != NULL && drv->bdrv_file_open) {
929 bs->open_flags = flags;
930 bs->guest_block_size = 512;
931 bs->request_alignment = 512;
932 bs->zero_beyond_eof = true;
933 open_flags = bdrv_open_flags(bs, flags);
934 bs->read_only = !(open_flags & BDRV_O_RDWR);
935 bs->growable = !!(flags & BDRV_O_PROTOCOL);
937 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
939 !bs->read_only && bdrv_is_whitelisted(drv, true)
940 ? "Driver '%s' can only be used for read-only devices"
941 : "Driver '%s' is not whitelisted",
946 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
947 if (flags & BDRV_O_COPY_ON_READ) {
948 if (!bs->read_only) {
949 bdrv_enable_copy_on_read(bs);
951 error_setg(errp, "Can't use copy-on-read on read-only device");
956 if (filename != NULL) {
957 pstrcpy(bs->filename, sizeof(bs->filename), filename);
959 bs->filename[0] = '\0';
961 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
964 bs->opaque = g_malloc0(drv->instance_size);
966 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
968 /* Open the image, either directly or using a protocol */
969 if (drv->bdrv_file_open) {
970 assert(file == NULL);
971 assert(!drv->bdrv_needs_filename || filename != NULL);
972 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
975 error_setg(errp, "Can't use '%s' as a block driver for the "
976 "protocol level", drv->format_name);
981 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
986 error_propagate(errp, local_err);
987 } else if (bs->filename[0]) {
988 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
990 error_setg_errno(errp, -ret, "Could not open image");
995 ret = refresh_total_sectors(bs, bs->total_sectors);
997 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1001 bdrv_refresh_limits(bs, &local_err);
1003 error_propagate(errp, local_err);
1008 assert(bdrv_opt_mem_align(bs) != 0);
1009 assert((bs->request_alignment != 0) || bs->sg);
1020 static QDict *parse_json_filename(const char *filename, Error **errp)
1022 QObject *options_obj;
1026 ret = strstart(filename, "json:", &filename);
1029 options_obj = qobject_from_json(filename);
1031 error_setg(errp, "Could not parse the JSON options");
1035 if (qobject_type(options_obj) != QTYPE_QDICT) {
1036 qobject_decref(options_obj);
1037 error_setg(errp, "Invalid JSON object given");
1041 options = qobject_to_qdict(options_obj);
1042 qdict_flatten(options);
1048 * Fills in default options for opening images and converts the legacy
1049 * filename/flags pair to option QDict entries.
1051 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1052 BlockDriver *drv, Error **errp)
1054 const char *filename = *pfilename;
1055 const char *drvname;
1056 bool protocol = flags & BDRV_O_PROTOCOL;
1057 bool parse_filename = false;
1058 Error *local_err = NULL;
1060 /* Parse json: pseudo-protocol */
1061 if (filename && g_str_has_prefix(filename, "json:")) {
1062 QDict *json_options = parse_json_filename(filename, &local_err);
1064 error_propagate(errp, local_err);
1068 /* Options given in the filename have lower priority than options
1069 * specified directly */
1070 qdict_join(*options, json_options, false);
1071 QDECREF(json_options);
1072 *pfilename = filename = NULL;
1075 /* Fetch the file name from the options QDict if necessary */
1076 if (protocol && filename) {
1077 if (!qdict_haskey(*options, "filename")) {
1078 qdict_put(*options, "filename", qstring_from_str(filename));
1079 parse_filename = true;
1081 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1087 /* Find the right block driver */
1088 filename = qdict_get_try_str(*options, "filename");
1089 drvname = qdict_get_try_str(*options, "driver");
1093 error_setg(errp, "Driver specified twice");
1096 drvname = drv->format_name;
1097 qdict_put(*options, "driver", qstring_from_str(drvname));
1099 if (!drvname && protocol) {
1101 drv = bdrv_find_protocol(filename, parse_filename);
1103 error_setg(errp, "Unknown protocol");
1107 drvname = drv->format_name;
1108 qdict_put(*options, "driver", qstring_from_str(drvname));
1110 error_setg(errp, "Must specify either driver or file");
1113 } else if (drvname) {
1114 drv = bdrv_find_format(drvname);
1116 error_setg(errp, "Unknown driver '%s'", drvname);
1122 assert(drv || !protocol);
1124 /* Driver-specific filename parsing */
1125 if (drv && drv->bdrv_parse_filename && parse_filename) {
1126 drv->bdrv_parse_filename(filename, *options, &local_err);
1128 error_propagate(errp, local_err);
1132 if (!drv->bdrv_needs_filename) {
1133 qdict_del(*options, "filename");
1140 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1143 if (bs->backing_hd) {
1144 assert(bs->backing_blocker);
1145 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1146 } else if (backing_hd) {
1147 error_setg(&bs->backing_blocker,
1148 "device is used as backing hd of '%s'",
1149 bdrv_get_device_name(bs));
1152 bs->backing_hd = backing_hd;
1154 error_free(bs->backing_blocker);
1155 bs->backing_blocker = NULL;
1158 bs->open_flags &= ~BDRV_O_NO_BACKING;
1159 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1160 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1161 backing_hd->drv ? backing_hd->drv->format_name : "");
1163 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1164 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1165 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1166 bs->backing_blocker);
1168 bdrv_refresh_limits(bs, NULL);
1172 * Opens the backing file for a BlockDriverState if not yet open
1174 * options is a QDict of options to pass to the block drivers, or NULL for an
1175 * empty set of options. The reference to the QDict is transferred to this
1176 * function (even on failure), so if the caller intends to reuse the dictionary,
1177 * it needs to use QINCREF() before calling bdrv_file_open.
1179 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1181 char *backing_filename = g_malloc0(PATH_MAX);
1183 BlockDriver *back_drv = NULL;
1184 BlockDriverState *backing_hd;
1185 Error *local_err = NULL;
1187 if (bs->backing_hd != NULL) {
1192 /* NULL means an empty set of options */
1193 if (options == NULL) {
1194 options = qdict_new();
1197 bs->open_flags &= ~BDRV_O_NO_BACKING;
1198 if (qdict_haskey(options, "file.filename")) {
1199 backing_filename[0] = '\0';
1200 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1204 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
1207 if (!bs->drv || !bs->drv->supports_backing) {
1209 error_setg(errp, "Driver doesn't support backing files");
1214 backing_hd = bdrv_new();
1216 if (bs->backing_format[0] != '\0') {
1217 back_drv = bdrv_find_format(bs->backing_format);
1220 assert(bs->backing_hd == NULL);
1221 ret = bdrv_open(&backing_hd,
1222 *backing_filename ? backing_filename : NULL, NULL, options,
1223 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
1225 bdrv_unref(backing_hd);
1227 bs->open_flags |= BDRV_O_NO_BACKING;
1228 error_setg(errp, "Could not open backing file: %s",
1229 error_get_pretty(local_err));
1230 error_free(local_err);
1233 bdrv_set_backing_hd(bs, backing_hd);
1236 g_free(backing_filename);
1241 * Opens a disk image whose options are given as BlockdevRef in another block
1244 * If allow_none is true, no image will be opened if filename is false and no
1245 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1247 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1248 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1249 * itself, all options starting with "${bdref_key}." are considered part of the
1252 * The BlockdevRef will be removed from the options QDict.
1254 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1256 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1257 QDict *options, const char *bdref_key, int flags,
1258 bool allow_none, Error **errp)
1260 QDict *image_options;
1262 char *bdref_key_dot;
1263 const char *reference;
1266 assert(*pbs == NULL);
1268 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1269 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1270 g_free(bdref_key_dot);
1272 reference = qdict_get_try_str(options, bdref_key);
1273 if (!filename && !reference && !qdict_size(image_options)) {
1277 error_setg(errp, "A block device must be specified for \"%s\"",
1281 QDECREF(image_options);
1285 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
1288 qdict_del(options, bdref_key);
1292 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1294 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1295 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1297 BlockDriver *bdrv_qcow2;
1298 QemuOpts *opts = NULL;
1299 QDict *snapshot_options;
1300 BlockDriverState *bs_snapshot;
1304 /* if snapshot, we create a temporary backing file and open it
1305 instead of opening 'filename' directly */
1307 /* Get the required size from the image */
1308 total_size = bdrv_getlength(bs);
1309 if (total_size < 0) {
1311 error_setg_errno(errp, -total_size, "Could not get image size");
1315 /* Create the temporary image */
1316 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1318 error_setg_errno(errp, -ret, "Could not get temporary filename");
1322 bdrv_qcow2 = bdrv_find_format("qcow2");
1323 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1325 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
1326 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1327 qemu_opts_del(opts);
1329 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1330 "'%s': %s", tmp_filename,
1331 error_get_pretty(local_err));
1332 error_free(local_err);
1336 /* Prepare a new options QDict for the temporary file */
1337 snapshot_options = qdict_new();
1338 qdict_put(snapshot_options, "file.driver",
1339 qstring_from_str("file"));
1340 qdict_put(snapshot_options, "file.filename",
1341 qstring_from_str(tmp_filename));
1343 bs_snapshot = bdrv_new();
1345 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1346 flags, bdrv_qcow2, &local_err);
1348 error_propagate(errp, local_err);
1352 bdrv_append(bs_snapshot, bs);
1355 g_free(tmp_filename);
1360 * Opens a disk image (raw, qcow2, vmdk, ...)
1362 * options is a QDict of options to pass to the block drivers, or NULL for an
1363 * empty set of options. The reference to the QDict belongs to the block layer
1364 * after the call (even on failure), so if the caller intends to reuse the
1365 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1367 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1368 * If it is not NULL, the referenced BDS will be reused.
1370 * The reference parameter may be used to specify an existing block device which
1371 * should be opened. If specified, neither options nor a filename may be given,
1372 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1374 int bdrv_open(BlockDriverState **pbs, const char *filename,
1375 const char *reference, QDict *options, int flags,
1376 BlockDriver *drv, Error **errp)
1379 BlockDriverState *file = NULL, *bs;
1380 const char *drvname;
1381 Error *local_err = NULL;
1382 int snapshot_flags = 0;
1387 bool options_non_empty = options ? qdict_size(options) : false;
1391 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1392 "another block device");
1396 if (filename || options_non_empty) {
1397 error_setg(errp, "Cannot reference an existing block device with "
1398 "additional options or a new filename");
1402 bs = bdrv_lookup_bs(reference, reference, errp);
1417 /* NULL means an empty set of options */
1418 if (options == NULL) {
1419 options = qdict_new();
1422 ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1427 /* Find the right image format driver */
1429 drvname = qdict_get_try_str(options, "driver");
1431 drv = bdrv_find_format(drvname);
1432 qdict_del(options, "driver");
1434 error_setg(errp, "Unknown driver: '%s'", drvname);
1440 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1441 if (drv && !drv->bdrv_file_open) {
1442 /* If the user explicitly wants a format driver here, we'll need to add
1443 * another layer for the protocol in bs->file */
1444 flags &= ~BDRV_O_PROTOCOL;
1447 bs->options = options;
1448 options = qdict_clone_shallow(options);
1450 /* Open image file without format layer */
1451 if ((flags & BDRV_O_PROTOCOL) == 0) {
1452 if (flags & BDRV_O_RDWR) {
1453 flags |= BDRV_O_ALLOW_RDWR;
1455 if (flags & BDRV_O_SNAPSHOT) {
1456 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1457 flags = bdrv_backing_flags(flags);
1460 assert(file == NULL);
1461 ret = bdrv_open_image(&file, filename, options, "file",
1462 bdrv_inherited_flags(flags),
1469 /* Image format probing */
1471 ret = find_image_format(file, filename, &drv, &local_err);
1476 error_setg(errp, "Must specify either driver or file");
1481 /* Open the image */
1482 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1487 if (file && (bs->file != file)) {
1492 /* If there is a backing file, use it */
1493 if ((flags & BDRV_O_NO_BACKING) == 0) {
1494 QDict *backing_options;
1496 qdict_extract_subqdict(options, &backing_options, "backing.");
1497 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1499 goto close_and_fail;
1503 bdrv_refresh_filename(bs);
1505 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1506 * temporary snapshot afterwards. */
1507 if (snapshot_flags) {
1508 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1510 goto close_and_fail;
1514 /* Check if any unknown options were used */
1515 if (options && (qdict_size(options) != 0)) {
1516 const QDictEntry *entry = qdict_first(options);
1517 if (flags & BDRV_O_PROTOCOL) {
1518 error_setg(errp, "Block protocol '%s' doesn't support the option "
1519 "'%s'", drv->format_name, entry->key);
1521 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1522 "support the option '%s'", drv->format_name,
1523 bdrv_get_device_name(bs), entry->key);
1527 goto close_and_fail;
1530 if (!bdrv_key_required(bs)) {
1532 blk_dev_change_media_cb(bs->blk, true);
1534 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1535 && !runstate_check(RUN_STATE_INMIGRATE)
1536 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1538 "Guest must be stopped for opening of encrypted image");
1540 goto close_and_fail;
1551 QDECREF(bs->options);
1555 /* If *pbs is NULL, a new BDS has been created in this function and
1556 needs to be freed now. Otherwise, it does not need to be closed,
1557 since it has not really been opened yet. */
1561 error_propagate(errp, local_err);
1566 /* See fail path, but now the BDS has to be always closed */
1574 error_propagate(errp, local_err);
1579 typedef struct BlockReopenQueueEntry {
1581 BDRVReopenState state;
1582 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1583 } BlockReopenQueueEntry;
1586 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1587 * reopen of multiple devices.
1589 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1590 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1591 * be created and initialized. This newly created BlockReopenQueue should be
1592 * passed back in for subsequent calls that are intended to be of the same
1595 * bs is the BlockDriverState to add to the reopen queue.
1597 * flags contains the open flags for the associated bs
1599 * returns a pointer to bs_queue, which is either the newly allocated
1600 * bs_queue, or the existing bs_queue being used.
1603 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1604 BlockDriverState *bs, int flags)
1608 BlockReopenQueueEntry *bs_entry;
1609 if (bs_queue == NULL) {
1610 bs_queue = g_new0(BlockReopenQueue, 1);
1611 QSIMPLEQ_INIT(bs_queue);
1614 /* bdrv_open() masks this flag out */
1615 flags &= ~BDRV_O_PROTOCOL;
1618 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1621 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1622 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1624 bs_entry->state.bs = bs;
1625 bs_entry->state.flags = flags;
1631 * Reopen multiple BlockDriverStates atomically & transactionally.
1633 * The queue passed in (bs_queue) must have been built up previous
1634 * via bdrv_reopen_queue().
1636 * Reopens all BDS specified in the queue, with the appropriate
1637 * flags. All devices are prepared for reopen, and failure of any
1638 * device will cause all device changes to be abandonded, and intermediate
1641 * If all devices prepare successfully, then the changes are committed
1645 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1648 BlockReopenQueueEntry *bs_entry, *next;
1649 Error *local_err = NULL;
1651 assert(bs_queue != NULL);
1655 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1656 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1657 error_propagate(errp, local_err);
1660 bs_entry->prepared = true;
1663 /* If we reach this point, we have success and just need to apply the
1666 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1667 bdrv_reopen_commit(&bs_entry->state);
1673 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1674 if (ret && bs_entry->prepared) {
1675 bdrv_reopen_abort(&bs_entry->state);
1684 /* Reopen a single BlockDriverState with the specified flags. */
1685 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1688 Error *local_err = NULL;
1689 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1691 ret = bdrv_reopen_multiple(queue, &local_err);
1692 if (local_err != NULL) {
1693 error_propagate(errp, local_err);
1700 * Prepares a BlockDriverState for reopen. All changes are staged in the
1701 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1702 * the block driver layer .bdrv_reopen_prepare()
1704 * bs is the BlockDriverState to reopen
1705 * flags are the new open flags
1706 * queue is the reopen queue
1708 * Returns 0 on success, non-zero on error. On error errp will be set
1711 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1712 * It is the responsibility of the caller to then call the abort() or
1713 * commit() for any other BDS that have been left in a prepare() state
1716 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1720 Error *local_err = NULL;
1723 assert(reopen_state != NULL);
1724 assert(reopen_state->bs->drv != NULL);
1725 drv = reopen_state->bs->drv;
1727 /* if we are to stay read-only, do not allow permission change
1729 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1730 reopen_state->flags & BDRV_O_RDWR) {
1731 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1732 bdrv_get_device_name(reopen_state->bs));
1737 ret = bdrv_flush(reopen_state->bs);
1739 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1744 if (drv->bdrv_reopen_prepare) {
1745 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1747 if (local_err != NULL) {
1748 error_propagate(errp, local_err);
1750 error_setg(errp, "failed while preparing to reopen image '%s'",
1751 reopen_state->bs->filename);
1756 /* It is currently mandatory to have a bdrv_reopen_prepare()
1757 * handler for each supported drv. */
1758 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1759 drv->format_name, bdrv_get_device_name(reopen_state->bs),
1760 "reopening of file");
1772 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1773 * makes them final by swapping the staging BlockDriverState contents into
1774 * the active BlockDriverState contents.
1776 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1780 assert(reopen_state != NULL);
1781 drv = reopen_state->bs->drv;
1782 assert(drv != NULL);
1784 /* If there are any driver level actions to take */
1785 if (drv->bdrv_reopen_commit) {
1786 drv->bdrv_reopen_commit(reopen_state);
1789 /* set BDS specific flags now */
1790 reopen_state->bs->open_flags = reopen_state->flags;
1791 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1793 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1795 bdrv_refresh_limits(reopen_state->bs, NULL);
1799 * Abort the reopen, and delete and free the staged changes in
1802 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1806 assert(reopen_state != NULL);
1807 drv = reopen_state->bs->drv;
1808 assert(drv != NULL);
1810 if (drv->bdrv_reopen_abort) {
1811 drv->bdrv_reopen_abort(reopen_state);
1816 void bdrv_close(BlockDriverState *bs)
1818 BdrvAioNotifier *ban, *ban_next;
1821 block_job_cancel_sync(bs->job);
1823 bdrv_drain_all(); /* complete I/O */
1825 bdrv_drain_all(); /* in case flush left pending I/O */
1826 notifier_list_notify(&bs->close_notifiers, bs);
1829 if (bs->backing_hd) {
1830 BlockDriverState *backing_hd = bs->backing_hd;
1831 bdrv_set_backing_hd(bs, NULL);
1832 bdrv_unref(backing_hd);
1834 bs->drv->bdrv_close(bs);
1838 bs->copy_on_read = 0;
1839 bs->backing_file[0] = '\0';
1840 bs->backing_format[0] = '\0';
1841 bs->total_sectors = 0;
1846 bs->zero_beyond_eof = false;
1847 QDECREF(bs->options);
1849 QDECREF(bs->full_open_options);
1850 bs->full_open_options = NULL;
1852 if (bs->file != NULL) {
1853 bdrv_unref(bs->file);
1859 blk_dev_change_media_cb(bs->blk, false);
1862 /*throttling disk I/O limits*/
1863 if (bs->io_limits_enabled) {
1864 bdrv_io_limits_disable(bs);
1867 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
1870 QLIST_INIT(&bs->aio_notifiers);
1873 void bdrv_close_all(void)
1875 BlockDriverState *bs;
1877 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1878 AioContext *aio_context = bdrv_get_aio_context(bs);
1880 aio_context_acquire(aio_context);
1882 aio_context_release(aio_context);
1886 /* Check if any requests are in-flight (including throttled requests) */
1887 static bool bdrv_requests_pending(BlockDriverState *bs)
1889 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1892 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1895 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1898 if (bs->file && bdrv_requests_pending(bs->file)) {
1901 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1907 static bool bdrv_drain_one(BlockDriverState *bs)
1911 bdrv_flush_io_queue(bs);
1912 bdrv_start_throttled_reqs(bs);
1913 bs_busy = bdrv_requests_pending(bs);
1914 bs_busy |= aio_poll(bdrv_get_aio_context(bs), bs_busy);
1919 * Wait for pending requests to complete on a single BlockDriverState subtree
1921 * See the warning in bdrv_drain_all(). This function can only be called if
1922 * you are sure nothing can generate I/O because you have op blockers
1925 * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
1928 void bdrv_drain(BlockDriverState *bs)
1930 while (bdrv_drain_one(bs)) {
1931 /* Keep iterating */
1936 * Wait for pending requests to complete across all BlockDriverStates
1938 * This function does not flush data to disk, use bdrv_flush_all() for that
1939 * after calling this function.
1941 * Note that completion of an asynchronous I/O operation can trigger any
1942 * number of other I/O operations on other devices---for example a coroutine
1943 * can be arbitrarily complex and a constant flow of I/O can come until the
1944 * coroutine is complete. Because of this, it is not possible to have a
1945 * function to drain a single device's I/O queue.
1947 void bdrv_drain_all(void)
1949 /* Always run first iteration so any pending completion BHs run */
1951 BlockDriverState *bs;
1956 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1957 AioContext *aio_context = bdrv_get_aio_context(bs);
1959 aio_context_acquire(aio_context);
1960 busy |= bdrv_drain_one(bs);
1961 aio_context_release(aio_context);
1966 /* make a BlockDriverState anonymous by removing from bdrv_state and
1967 * graph_bdrv_state list.
1968 Also, NULL terminate the device_name to prevent double remove */
1969 void bdrv_make_anon(BlockDriverState *bs)
1972 * Take care to remove bs from bdrv_states only when it's actually
1973 * in it. Note that bs->device_list.tqe_prev is initially null,
1974 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
1975 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
1976 * resetting it to null on remove.
1978 if (bs->device_list.tqe_prev) {
1979 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1980 bs->device_list.tqe_prev = NULL;
1982 if (bs->node_name[0] != '\0') {
1983 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1985 bs->node_name[0] = '\0';
1988 static void bdrv_rebind(BlockDriverState *bs)
1990 if (bs->drv && bs->drv->bdrv_rebind) {
1991 bs->drv->bdrv_rebind(bs);
1995 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1996 BlockDriverState *bs_src)
1998 /* move some fields that need to stay attached to the device */
2001 bs_dest->guest_block_size = bs_src->guest_block_size;
2002 bs_dest->copy_on_read = bs_src->copy_on_read;
2004 bs_dest->enable_write_cache = bs_src->enable_write_cache;
2006 /* i/o throttled req */
2007 memcpy(&bs_dest->throttle_state,
2008 &bs_src->throttle_state,
2009 sizeof(ThrottleState));
2010 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
2011 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
2012 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
2015 bs_dest->on_read_error = bs_src->on_read_error;
2016 bs_dest->on_write_error = bs_src->on_write_error;
2019 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
2020 bs_dest->iostatus = bs_src->iostatus;
2023 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
2025 /* reference count */
2026 bs_dest->refcnt = bs_src->refcnt;
2029 bs_dest->job = bs_src->job;
2031 /* keep the same entry in bdrv_states */
2032 bs_dest->device_list = bs_src->device_list;
2033 bs_dest->blk = bs_src->blk;
2035 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2036 sizeof(bs_dest->op_blockers));
2040 * Swap bs contents for two image chains while they are live,
2041 * while keeping required fields on the BlockDriverState that is
2042 * actually attached to a device.
2044 * This will modify the BlockDriverState fields, and swap contents
2045 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2047 * bs_new must not be attached to a BlockBackend.
2049 * This function does not create any image files.
2051 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2053 BlockDriverState tmp;
2055 /* The code needs to swap the node_name but simply swapping node_list won't
2056 * work so first remove the nodes from the graph list, do the swap then
2057 * insert them back if needed.
2059 if (bs_new->node_name[0] != '\0') {
2060 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2062 if (bs_old->node_name[0] != '\0') {
2063 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2066 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2067 assert(!bs_new->blk);
2068 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2069 assert(bs_new->job == NULL);
2070 assert(bs_new->io_limits_enabled == false);
2071 assert(!throttle_have_timer(&bs_new->throttle_state));
2077 /* there are some fields that should not be swapped, move them back */
2078 bdrv_move_feature_fields(&tmp, bs_old);
2079 bdrv_move_feature_fields(bs_old, bs_new);
2080 bdrv_move_feature_fields(bs_new, &tmp);
2082 /* bs_new must remain unattached */
2083 assert(!bs_new->blk);
2085 /* Check a few fields that should remain attached to the device */
2086 assert(bs_new->job == NULL);
2087 assert(bs_new->io_limits_enabled == false);
2088 assert(!throttle_have_timer(&bs_new->throttle_state));
2090 /* insert the nodes back into the graph node list if needed */
2091 if (bs_new->node_name[0] != '\0') {
2092 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2094 if (bs_old->node_name[0] != '\0') {
2095 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2098 bdrv_rebind(bs_new);
2099 bdrv_rebind(bs_old);
2103 * Add new bs contents at the top of an image chain while the chain is
2104 * live, while keeping required fields on the top layer.
2106 * This will modify the BlockDriverState fields, and swap contents
2107 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2109 * bs_new must not be attached to a BlockBackend.
2111 * This function does not create any image files.
2113 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2115 bdrv_swap(bs_new, bs_top);
2117 /* The contents of 'tmp' will become bs_top, as we are
2118 * swapping bs_new and bs_top contents. */
2119 bdrv_set_backing_hd(bs_top, bs_new);
2122 static void bdrv_delete(BlockDriverState *bs)
2125 assert(bdrv_op_blocker_is_empty(bs));
2126 assert(!bs->refcnt);
2127 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2133 /* remove from list, if necessary */
2140 * Run consistency checks on an image
2142 * Returns 0 if the check could be completed (it doesn't mean that the image is
2143 * free of errors) or -errno when an internal error occurred. The results of the
2144 * check are stored in res.
2146 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2148 if (bs->drv == NULL) {
2151 if (bs->drv->bdrv_check == NULL) {
2155 memset(res, 0, sizeof(*res));
2156 return bs->drv->bdrv_check(bs, res, fix);
2159 #define COMMIT_BUF_SECTORS 2048
2161 /* commit COW file into the raw image */
2162 int bdrv_commit(BlockDriverState *bs)
2164 BlockDriver *drv = bs->drv;
2165 int64_t sector, total_sectors, length, backing_length;
2166 int n, ro, open_flags;
2168 uint8_t *buf = NULL;
2169 char filename[PATH_MAX];
2174 if (!bs->backing_hd) {
2178 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2179 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2183 ro = bs->backing_hd->read_only;
2184 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2185 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2186 open_flags = bs->backing_hd->open_flags;
2189 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2194 length = bdrv_getlength(bs);
2200 backing_length = bdrv_getlength(bs->backing_hd);
2201 if (backing_length < 0) {
2202 ret = backing_length;
2206 /* If our top snapshot is larger than the backing file image,
2207 * grow the backing file image if possible. If not possible,
2208 * we must return an error */
2209 if (length > backing_length) {
2210 ret = bdrv_truncate(bs->backing_hd, length);
2216 total_sectors = length >> BDRV_SECTOR_BITS;
2218 /* qemu_try_blockalign() for bs will choose an alignment that works for
2219 * bs->backing_hd as well, so no need to compare the alignment manually. */
2220 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2226 for (sector = 0; sector < total_sectors; sector += n) {
2227 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2232 ret = bdrv_read(bs, sector, buf, n);
2237 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2244 if (drv->bdrv_make_empty) {
2245 ret = drv->bdrv_make_empty(bs);
2253 * Make sure all data we wrote to the backing device is actually
2256 if (bs->backing_hd) {
2257 bdrv_flush(bs->backing_hd);
2265 /* ignoring error return here */
2266 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2272 int bdrv_commit_all(void)
2274 BlockDriverState *bs;
2276 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2277 AioContext *aio_context = bdrv_get_aio_context(bs);
2279 aio_context_acquire(aio_context);
2280 if (bs->drv && bs->backing_hd) {
2281 int ret = bdrv_commit(bs);
2283 aio_context_release(aio_context);
2287 aio_context_release(aio_context);
2293 * Remove an active request from the tracked requests list
2295 * This function should be called when a tracked request is completing.
2297 static void tracked_request_end(BdrvTrackedRequest *req)
2299 if (req->serialising) {
2300 req->bs->serialising_in_flight--;
2303 QLIST_REMOVE(req, list);
2304 qemu_co_queue_restart_all(&req->wait_queue);
2308 * Add an active request to the tracked requests list
2310 static void tracked_request_begin(BdrvTrackedRequest *req,
2311 BlockDriverState *bs,
2313 unsigned int bytes, bool is_write)
2315 *req = (BdrvTrackedRequest){
2319 .is_write = is_write,
2320 .co = qemu_coroutine_self(),
2321 .serialising = false,
2322 .overlap_offset = offset,
2323 .overlap_bytes = bytes,
2326 qemu_co_queue_init(&req->wait_queue);
2328 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2331 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2333 int64_t overlap_offset = req->offset & ~(align - 1);
2334 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2337 if (!req->serialising) {
2338 req->bs->serialising_in_flight++;
2339 req->serialising = true;
2342 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2343 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2347 * Round a region to cluster boundaries
2349 void bdrv_round_to_clusters(BlockDriverState *bs,
2350 int64_t sector_num, int nb_sectors,
2351 int64_t *cluster_sector_num,
2352 int *cluster_nb_sectors)
2354 BlockDriverInfo bdi;
2356 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2357 *cluster_sector_num = sector_num;
2358 *cluster_nb_sectors = nb_sectors;
2360 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2361 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2362 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2367 static int bdrv_get_cluster_size(BlockDriverState *bs)
2369 BlockDriverInfo bdi;
2372 ret = bdrv_get_info(bs, &bdi);
2373 if (ret < 0 || bdi.cluster_size == 0) {
2374 return bs->request_alignment;
2376 return bdi.cluster_size;
2380 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2381 int64_t offset, unsigned int bytes)
2384 if (offset >= req->overlap_offset + req->overlap_bytes) {
2388 if (req->overlap_offset >= offset + bytes) {
2394 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2396 BlockDriverState *bs = self->bs;
2397 BdrvTrackedRequest *req;
2399 bool waited = false;
2401 if (!bs->serialising_in_flight) {
2407 QLIST_FOREACH(req, &bs->tracked_requests, list) {
2408 if (req == self || (!req->serialising && !self->serialising)) {
2411 if (tracked_request_overlaps(req, self->overlap_offset,
2412 self->overlap_bytes))
2414 /* Hitting this means there was a reentrant request, for
2415 * example, a block driver issuing nested requests. This must
2416 * never happen since it means deadlock.
2418 assert(qemu_coroutine_self() != req->co);
2420 /* If the request is already (indirectly) waiting for us, or
2421 * will wait for us as soon as it wakes up, then just go on
2422 * (instead of producing a deadlock in the former case). */
2423 if (!req->waiting_for) {
2424 self->waiting_for = req;
2425 qemu_co_queue_wait(&req->wait_queue);
2426 self->waiting_for = NULL;
2441 * -EINVAL - backing format specified, but no file
2442 * -ENOSPC - can't update the backing file because no space is left in the
2444 * -ENOTSUP - format driver doesn't support changing the backing file
2446 int bdrv_change_backing_file(BlockDriverState *bs,
2447 const char *backing_file, const char *backing_fmt)
2449 BlockDriver *drv = bs->drv;
2452 /* Backing file format doesn't make sense without a backing file */
2453 if (backing_fmt && !backing_file) {
2457 if (drv->bdrv_change_backing_file != NULL) {
2458 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2464 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2465 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2471 * Finds the image layer in the chain that has 'bs' as its backing file.
2473 * active is the current topmost image.
2475 * Returns NULL if bs is not found in active's image chain,
2476 * or if active == bs.
2478 * Returns the bottommost base image if bs == NULL.
2480 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2481 BlockDriverState *bs)
2483 while (active && bs != active->backing_hd) {
2484 active = active->backing_hd;
2490 /* Given a BDS, searches for the base layer. */
2491 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2493 return bdrv_find_overlay(bs, NULL);
2496 typedef struct BlkIntermediateStates {
2497 BlockDriverState *bs;
2498 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2499 } BlkIntermediateStates;
2503 * Drops images above 'base' up to and including 'top', and sets the image
2504 * above 'top' to have base as its backing file.
2506 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2507 * information in 'bs' can be properly updated.
2509 * E.g., this will convert the following chain:
2510 * bottom <- base <- intermediate <- top <- active
2514 * bottom <- base <- active
2516 * It is allowed for bottom==base, in which case it converts:
2518 * base <- intermediate <- top <- active
2524 * If backing_file_str is non-NULL, it will be used when modifying top's
2525 * overlay image metadata.
2528 * if active == top, that is considered an error
2531 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2532 BlockDriverState *base, const char *backing_file_str)
2534 BlockDriverState *intermediate;
2535 BlockDriverState *base_bs = NULL;
2536 BlockDriverState *new_top_bs = NULL;
2537 BlkIntermediateStates *intermediate_state, *next;
2540 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2541 QSIMPLEQ_INIT(&states_to_delete);
2543 if (!top->drv || !base->drv) {
2547 new_top_bs = bdrv_find_overlay(active, top);
2549 if (new_top_bs == NULL) {
2550 /* we could not find the image above 'top', this is an error */
2554 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2555 * to do, no intermediate images */
2556 if (new_top_bs->backing_hd == base) {
2563 /* now we will go down through the list, and add each BDS we find
2564 * into our deletion queue, until we hit the 'base'
2566 while (intermediate) {
2567 intermediate_state = g_new0(BlkIntermediateStates, 1);
2568 intermediate_state->bs = intermediate;
2569 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2571 if (intermediate->backing_hd == base) {
2572 base_bs = intermediate->backing_hd;
2575 intermediate = intermediate->backing_hd;
2577 if (base_bs == NULL) {
2578 /* something went wrong, we did not end at the base. safely
2579 * unravel everything, and exit with error */
2583 /* success - we can delete the intermediate states, and link top->base */
2584 backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2585 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2586 base_bs->drv ? base_bs->drv->format_name : "");
2590 bdrv_set_backing_hd(new_top_bs, base_bs);
2592 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2593 /* so that bdrv_close() does not recursively close the chain */
2594 bdrv_set_backing_hd(intermediate_state->bs, NULL);
2595 bdrv_unref(intermediate_state->bs);
2600 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2601 g_free(intermediate_state);
2607 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2612 if (size > INT_MAX) {
2616 if (!bdrv_is_inserted(bs))
2622 len = bdrv_getlength(bs);
2627 if ((offset > len) || (len - offset < size))
2633 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2636 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2640 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2641 nb_sectors * BDRV_SECTOR_SIZE);
2644 typedef struct RwCo {
2645 BlockDriverState *bs;
2650 BdrvRequestFlags flags;
2653 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2655 RwCo *rwco = opaque;
2657 if (!rwco->is_write) {
2658 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2659 rwco->qiov->size, rwco->qiov,
2662 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2663 rwco->qiov->size, rwco->qiov,
2669 * Process a vectored synchronous request using coroutines
2671 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2672 QEMUIOVector *qiov, bool is_write,
2673 BdrvRequestFlags flags)
2680 .is_write = is_write,
2686 * In sync call context, when the vcpu is blocked, this throttling timer
2687 * will not fire; so the I/O throttling function has to be disabled here
2688 * if it has been enabled.
2690 if (bs->io_limits_enabled) {
2691 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2692 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2693 bdrv_io_limits_disable(bs);
2696 if (qemu_in_coroutine()) {
2697 /* Fast-path if already in coroutine context */
2698 bdrv_rw_co_entry(&rwco);
2700 AioContext *aio_context = bdrv_get_aio_context(bs);
2702 co = qemu_coroutine_create(bdrv_rw_co_entry);
2703 qemu_coroutine_enter(co, &rwco);
2704 while (rwco.ret == NOT_DONE) {
2705 aio_poll(aio_context, true);
2712 * Process a synchronous request using coroutines
2714 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2715 int nb_sectors, bool is_write, BdrvRequestFlags flags)
2718 struct iovec iov = {
2719 .iov_base = (void *)buf,
2720 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2723 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2727 qemu_iovec_init_external(&qiov, &iov, 1);
2728 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2729 &qiov, is_write, flags);
2732 /* return < 0 if error. See bdrv_write() for the return codes */
2733 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2734 uint8_t *buf, int nb_sectors)
2736 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2739 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2740 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2741 uint8_t *buf, int nb_sectors)
2746 enabled = bs->io_limits_enabled;
2747 bs->io_limits_enabled = false;
2748 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2749 bs->io_limits_enabled = enabled;
2753 /* Return < 0 if error. Important errors are:
2754 -EIO generic I/O error (may happen for all errors)
2755 -ENOMEDIUM No media inserted.
2756 -EINVAL Invalid sector number or nb_sectors
2757 -EACCES Trying to write a read-only device
2759 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2760 const uint8_t *buf, int nb_sectors)
2762 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2765 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2766 int nb_sectors, BdrvRequestFlags flags)
2768 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2769 BDRV_REQ_ZERO_WRITE | flags);
2773 * Completely zero out a block device with the help of bdrv_write_zeroes.
2774 * The operation is sped up by checking the block status and only writing
2775 * zeroes to the device if they currently do not return zeroes. Optional
2776 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2778 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2780 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2782 int64_t target_sectors, ret, nb_sectors, sector_num = 0;
2785 target_sectors = bdrv_nb_sectors(bs);
2786 if (target_sectors < 0) {
2787 return target_sectors;
2791 nb_sectors = target_sectors - sector_num;
2792 if (nb_sectors <= 0) {
2795 if (nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2796 nb_sectors = INT_MAX / BDRV_SECTOR_SIZE;
2798 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2800 error_report("error getting block status at sector %" PRId64 ": %s",
2801 sector_num, strerror(-ret));
2804 if (ret & BDRV_BLOCK_ZERO) {
2808 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2810 error_report("error writing zeroes at sector %" PRId64 ": %s",
2811 sector_num, strerror(-ret));
2818 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2821 struct iovec iov = {
2822 .iov_base = (void *)buf,
2831 qemu_iovec_init_external(&qiov, &iov, 1);
2832 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2840 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2844 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2852 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2853 const void *buf, int bytes)
2856 struct iovec iov = {
2857 .iov_base = (void *) buf,
2865 qemu_iovec_init_external(&qiov, &iov, 1);
2866 return bdrv_pwritev(bs, offset, &qiov);
2870 * Writes to the file and ensures that no writes are reordered across this
2871 * request (acts as a barrier)
2873 * Returns 0 on success, -errno in error cases.
2875 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2876 const void *buf, int count)
2880 ret = bdrv_pwrite(bs, offset, buf, count);
2885 /* No flush needed for cache modes that already do it */
2886 if (bs->enable_write_cache) {
2893 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2894 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2896 /* Perform I/O through a temporary buffer so that users who scribble over
2897 * their read buffer while the operation is in progress do not end up
2898 * modifying the image file. This is critical for zero-copy guest I/O
2899 * where anything might happen inside guest memory.
2901 void *bounce_buffer;
2903 BlockDriver *drv = bs->drv;
2905 QEMUIOVector bounce_qiov;
2906 int64_t cluster_sector_num;
2907 int cluster_nb_sectors;
2911 /* Cover entire cluster so no additional backing file I/O is required when
2912 * allocating cluster in the image file.
2914 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2915 &cluster_sector_num, &cluster_nb_sectors);
2917 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2918 cluster_sector_num, cluster_nb_sectors);
2920 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2921 iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
2922 if (bounce_buffer == NULL) {
2927 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2929 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2935 if (drv->bdrv_co_write_zeroes &&
2936 buffer_is_zero(bounce_buffer, iov.iov_len)) {
2937 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2938 cluster_nb_sectors, 0);
2940 /* This does not change the data on the disk, it is not necessary
2941 * to flush even in cache=writethrough mode.
2943 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
2948 /* It might be okay to ignore write errors for guest requests. If this
2949 * is a deliberate copy-on-read then we don't want to ignore the error.
2950 * Simply report it in all cases.
2955 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
2956 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2957 nb_sectors * BDRV_SECTOR_SIZE);
2960 qemu_vfree(bounce_buffer);
2965 * Forwards an already correctly aligned request to the BlockDriver. This
2966 * handles copy on read and zeroing after EOF; any other features must be
2967 * implemented by the caller.
2969 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
2970 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
2971 int64_t align, QEMUIOVector *qiov, int flags)
2973 BlockDriver *drv = bs->drv;
2976 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
2977 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
2979 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
2980 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
2981 assert(!qiov || bytes == qiov->size);
2983 /* Handle Copy on Read and associated serialisation */
2984 if (flags & BDRV_REQ_COPY_ON_READ) {
2985 /* If we touch the same cluster it counts as an overlap. This
2986 * guarantees that allocating writes will be serialized and not race
2987 * with each other for the same cluster. For example, in copy-on-read
2988 * it ensures that the CoR read and write operations are atomic and
2989 * guest writes cannot interleave between them. */
2990 mark_request_serialising(req, bdrv_get_cluster_size(bs));
2993 wait_serialising_requests(req);
2995 if (flags & BDRV_REQ_COPY_ON_READ) {
2998 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3003 if (!ret || pnum != nb_sectors) {
3004 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3009 /* Forward the request to the BlockDriver */
3010 if (!(bs->zero_beyond_eof && bs->growable)) {
3011 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3013 /* Read zeros after EOF of growable BDSes */
3014 int64_t total_sectors, max_nb_sectors;
3016 total_sectors = bdrv_nb_sectors(bs);
3017 if (total_sectors < 0) {
3018 ret = total_sectors;
3022 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3023 align >> BDRV_SECTOR_BITS);
3024 if (max_nb_sectors > 0) {
3025 QEMUIOVector local_qiov;
3026 size_t local_sectors;
3028 max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
3029 local_sectors = MIN(max_nb_sectors, nb_sectors);
3031 qemu_iovec_init(&local_qiov, qiov->niov);
3032 qemu_iovec_concat(&local_qiov, qiov, 0,
3033 local_sectors * BDRV_SECTOR_SIZE);
3035 ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
3038 qemu_iovec_destroy(&local_qiov);
3043 /* Reading beyond end of file is supposed to produce zeroes */
3044 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3045 uint64_t offset = MAX(0, total_sectors - sector_num);
3046 uint64_t bytes = (sector_num + nb_sectors - offset) *
3048 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3057 * Handle a read request in coroutine context
3059 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3060 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3061 BdrvRequestFlags flags)
3063 BlockDriver *drv = bs->drv;
3064 BdrvTrackedRequest req;
3066 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3067 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3068 uint8_t *head_buf = NULL;
3069 uint8_t *tail_buf = NULL;
3070 QEMUIOVector local_qiov;
3071 bool use_local_qiov = false;
3077 if (bdrv_check_byte_request(bs, offset, bytes)) {
3081 if (bs->copy_on_read) {
3082 flags |= BDRV_REQ_COPY_ON_READ;
3085 /* throttling disk I/O */
3086 if (bs->io_limits_enabled) {
3087 bdrv_io_limits_intercept(bs, bytes, false);
3090 /* Align read if necessary by padding qiov */
3091 if (offset & (align - 1)) {
3092 head_buf = qemu_blockalign(bs, align);
3093 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3094 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3095 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3096 use_local_qiov = true;
3098 bytes += offset & (align - 1);
3099 offset = offset & ~(align - 1);
3102 if ((offset + bytes) & (align - 1)) {
3103 if (!use_local_qiov) {
3104 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3105 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3106 use_local_qiov = true;
3108 tail_buf = qemu_blockalign(bs, align);
3109 qemu_iovec_add(&local_qiov, tail_buf,
3110 align - ((offset + bytes) & (align - 1)));
3112 bytes = ROUND_UP(bytes, align);
3115 tracked_request_begin(&req, bs, offset, bytes, false);
3116 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3117 use_local_qiov ? &local_qiov : qiov,
3119 tracked_request_end(&req);
3121 if (use_local_qiov) {
3122 qemu_iovec_destroy(&local_qiov);
3123 qemu_vfree(head_buf);
3124 qemu_vfree(tail_buf);
3130 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3131 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3132 BdrvRequestFlags flags)
3134 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3138 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3139 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3142 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3143 int nb_sectors, QEMUIOVector *qiov)
3145 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3147 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3150 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3151 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3153 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3155 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3156 BDRV_REQ_COPY_ON_READ);
3159 /* if no limit is specified in the BlockLimits use a default
3160 * of 32768 512-byte sectors (16 MiB) per request.
3162 #define MAX_WRITE_ZEROES_DEFAULT 32768
3164 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3165 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3167 BlockDriver *drv = bs->drv;
3169 struct iovec iov = {0};
3172 int max_write_zeroes = bs->bl.max_write_zeroes ?
3173 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3175 while (nb_sectors > 0 && !ret) {
3176 int num = nb_sectors;
3178 /* Align request. Block drivers can expect the "bulk" of the request
3181 if (bs->bl.write_zeroes_alignment
3182 && num > bs->bl.write_zeroes_alignment) {
3183 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3184 /* Make a small request up to the first aligned sector. */
3185 num = bs->bl.write_zeroes_alignment;
3186 num -= sector_num % bs->bl.write_zeroes_alignment;
3187 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3188 /* Shorten the request to the last aligned sector. num cannot
3189 * underflow because num > bs->bl.write_zeroes_alignment.
3191 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3195 /* limit request size */
3196 if (num > max_write_zeroes) {
3197 num = max_write_zeroes;
3201 /* First try the efficient write zeroes operation */
3202 if (drv->bdrv_co_write_zeroes) {
3203 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3206 if (ret == -ENOTSUP) {
3207 /* Fall back to bounce buffer if write zeroes is unsupported */
3208 iov.iov_len = num * BDRV_SECTOR_SIZE;
3209 if (iov.iov_base == NULL) {
3210 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
3211 if (iov.iov_base == NULL) {
3215 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3217 qemu_iovec_init_external(&qiov, &iov, 1);
3219 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3221 /* Keep bounce buffer around if it is big enough for all
3222 * all future requests.
3224 if (num < max_write_zeroes) {
3225 qemu_vfree(iov.iov_base);
3226 iov.iov_base = NULL;
3235 qemu_vfree(iov.iov_base);
3240 * Forwards an already correctly aligned write request to the BlockDriver.
3242 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3243 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3244 QEMUIOVector *qiov, int flags)
3246 BlockDriver *drv = bs->drv;
3250 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3251 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3253 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3254 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3255 assert(!qiov || bytes == qiov->size);
3257 waited = wait_serialising_requests(req);
3258 assert(!waited || !req->serialising);
3259 assert(req->overlap_offset <= offset);
3260 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3262 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3264 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3265 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3266 qemu_iovec_is_zero(qiov)) {
3267 flags |= BDRV_REQ_ZERO_WRITE;
3268 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3269 flags |= BDRV_REQ_MAY_UNMAP;
3274 /* Do nothing, write notifier decided to fail this request */
3275 } else if (flags & BDRV_REQ_ZERO_WRITE) {
3276 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3277 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3279 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3280 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3282 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3284 if (ret == 0 && !bs->enable_write_cache) {
3285 ret = bdrv_co_flush(bs);
3288 bdrv_set_dirty(bs, sector_num, nb_sectors);
3290 block_acct_highest_sector(&bs->stats, sector_num, nb_sectors);
3292 if (bs->growable && ret >= 0) {
3293 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3300 * Handle a write request in coroutine context
3302 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3303 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3304 BdrvRequestFlags flags)
3306 BdrvTrackedRequest req;
3307 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3308 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3309 uint8_t *head_buf = NULL;
3310 uint8_t *tail_buf = NULL;
3311 QEMUIOVector local_qiov;
3312 bool use_local_qiov = false;
3318 if (bs->read_only) {
3321 if (bdrv_check_byte_request(bs, offset, bytes)) {
3325 /* throttling disk I/O */
3326 if (bs->io_limits_enabled) {
3327 bdrv_io_limits_intercept(bs, bytes, true);
3331 * Align write if necessary by performing a read-modify-write cycle.
3332 * Pad qiov with the read parts and be sure to have a tracked request not
3333 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3335 tracked_request_begin(&req, bs, offset, bytes, true);
3337 if (offset & (align - 1)) {
3338 QEMUIOVector head_qiov;
3339 struct iovec head_iov;
3341 mark_request_serialising(&req, align);
3342 wait_serialising_requests(&req);
3344 head_buf = qemu_blockalign(bs, align);
3345 head_iov = (struct iovec) {
3346 .iov_base = head_buf,
3349 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3351 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3352 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3353 align, &head_qiov, 0);
3357 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3359 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3360 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3361 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3362 use_local_qiov = true;
3364 bytes += offset & (align - 1);
3365 offset = offset & ~(align - 1);
3368 if ((offset + bytes) & (align - 1)) {
3369 QEMUIOVector tail_qiov;
3370 struct iovec tail_iov;
3374 mark_request_serialising(&req, align);
3375 waited = wait_serialising_requests(&req);
3376 assert(!waited || !use_local_qiov);
3378 tail_buf = qemu_blockalign(bs, align);
3379 tail_iov = (struct iovec) {
3380 .iov_base = tail_buf,
3383 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3385 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3386 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3387 align, &tail_qiov, 0);
3391 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3393 if (!use_local_qiov) {
3394 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3395 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3396 use_local_qiov = true;
3399 tail_bytes = (offset + bytes) & (align - 1);
3400 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3402 bytes = ROUND_UP(bytes, align);
3405 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3406 use_local_qiov ? &local_qiov : qiov,
3410 tracked_request_end(&req);
3412 if (use_local_qiov) {
3413 qemu_iovec_destroy(&local_qiov);
3415 qemu_vfree(head_buf);
3416 qemu_vfree(tail_buf);
3421 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3422 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3423 BdrvRequestFlags flags)
3425 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3429 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3430 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3433 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3434 int nb_sectors, QEMUIOVector *qiov)
3436 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3438 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3441 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3442 int64_t sector_num, int nb_sectors,
3443 BdrvRequestFlags flags)
3445 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3447 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3448 flags &= ~BDRV_REQ_MAY_UNMAP;
3451 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3452 BDRV_REQ_ZERO_WRITE | flags);
3456 * Truncate file to 'offset' bytes (needed only for file protocols)
3458 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3460 BlockDriver *drv = bs->drv;
3464 if (!drv->bdrv_truncate)
3469 ret = drv->bdrv_truncate(bs, offset);
3471 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3473 blk_dev_resize_cb(bs->blk);
3480 * Length of a allocated file in bytes. Sparse files are counted by actual
3481 * allocated space. Return < 0 if error or unknown.
3483 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3485 BlockDriver *drv = bs->drv;
3489 if (drv->bdrv_get_allocated_file_size) {
3490 return drv->bdrv_get_allocated_file_size(bs);
3493 return bdrv_get_allocated_file_size(bs->file);
3499 * Return number of sectors on success, -errno on error.
3501 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3503 BlockDriver *drv = bs->drv;
3508 if (drv->has_variable_length) {
3509 int ret = refresh_total_sectors(bs, bs->total_sectors);
3514 return bs->total_sectors;
3518 * Return length in bytes on success, -errno on error.
3519 * The length is always a multiple of BDRV_SECTOR_SIZE.
3521 int64_t bdrv_getlength(BlockDriverState *bs)
3523 int64_t ret = bdrv_nb_sectors(bs);
3525 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3528 /* return 0 as number of sectors if no device present or error */
3529 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3531 int64_t nb_sectors = bdrv_nb_sectors(bs);
3533 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3536 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3537 BlockdevOnError on_write_error)
3539 bs->on_read_error = on_read_error;
3540 bs->on_write_error = on_write_error;
3543 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3545 return is_read ? bs->on_read_error : bs->on_write_error;
3548 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3550 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3553 case BLOCKDEV_ON_ERROR_ENOSPC:
3554 return (error == ENOSPC) ?
3555 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3556 case BLOCKDEV_ON_ERROR_STOP:
3557 return BLOCK_ERROR_ACTION_STOP;
3558 case BLOCKDEV_ON_ERROR_REPORT:
3559 return BLOCK_ERROR_ACTION_REPORT;
3560 case BLOCKDEV_ON_ERROR_IGNORE:
3561 return BLOCK_ERROR_ACTION_IGNORE;
3567 static void send_qmp_error_event(BlockDriverState *bs,
3568 BlockErrorAction action,
3569 bool is_read, int error)
3571 IoOperationType optype;
3573 optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
3574 qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,
3575 bdrv_iostatus_is_enabled(bs),
3576 error == ENOSPC, strerror(error),
3580 /* This is done by device models because, while the block layer knows
3581 * about the error, it does not know whether an operation comes from
3582 * the device or the block layer (from a job, for example).
3584 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3585 bool is_read, int error)
3589 if (action == BLOCK_ERROR_ACTION_STOP) {
3590 /* First set the iostatus, so that "info block" returns an iostatus
3591 * that matches the events raised so far (an additional error iostatus
3592 * is fine, but not a lost one).
3594 bdrv_iostatus_set_err(bs, error);
3596 /* Then raise the request to stop the VM and the event.
3597 * qemu_system_vmstop_request_prepare has two effects. First,
3598 * it ensures that the STOP event always comes after the
3599 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3600 * can observe the STOP event and do a "cont" before the STOP
3601 * event is issued, the VM will not stop. In this case, vm_start()
3602 * also ensures that the STOP/RESUME pair of events is emitted.
3604 qemu_system_vmstop_request_prepare();
3605 send_qmp_error_event(bs, action, is_read, error);
3606 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3608 send_qmp_error_event(bs, action, is_read, error);
3612 int bdrv_is_read_only(BlockDriverState *bs)
3614 return bs->read_only;
3617 int bdrv_is_sg(BlockDriverState *bs)
3622 int bdrv_enable_write_cache(BlockDriverState *bs)
3624 return bs->enable_write_cache;
3627 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3629 bs->enable_write_cache = wce;
3631 /* so a reopen() will preserve wce */
3633 bs->open_flags |= BDRV_O_CACHE_WB;
3635 bs->open_flags &= ~BDRV_O_CACHE_WB;
3639 int bdrv_is_encrypted(BlockDriverState *bs)
3641 if (bs->backing_hd && bs->backing_hd->encrypted)
3643 return bs->encrypted;
3646 int bdrv_key_required(BlockDriverState *bs)
3648 BlockDriverState *backing_hd = bs->backing_hd;
3650 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3652 return (bs->encrypted && !bs->valid_key);
3655 int bdrv_set_key(BlockDriverState *bs, const char *key)
3658 if (bs->backing_hd && bs->backing_hd->encrypted) {
3659 ret = bdrv_set_key(bs->backing_hd, key);
3665 if (!bs->encrypted) {
3667 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3670 ret = bs->drv->bdrv_set_key(bs, key);
3673 } else if (!bs->valid_key) {
3676 /* call the change callback now, we skipped it on open */
3677 blk_dev_change_media_cb(bs->blk, true);
3683 const char *bdrv_get_format_name(BlockDriverState *bs)
3685 return bs->drv ? bs->drv->format_name : NULL;
3688 static int qsort_strcmp(const void *a, const void *b)
3690 return strcmp(a, b);
3693 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3699 const char **formats = NULL;
3701 QLIST_FOREACH(drv, &bdrv_drivers, list) {
3702 if (drv->format_name) {
3705 while (formats && i && !found) {
3706 found = !strcmp(formats[--i], drv->format_name);
3710 formats = g_renew(const char *, formats, count + 1);
3711 formats[count++] = drv->format_name;
3716 qsort(formats, count, sizeof(formats[0]), qsort_strcmp);
3718 for (i = 0; i < count; i++) {
3719 it(opaque, formats[i]);
3725 /* This function is to find block backend bs */
3726 /* TODO convert callers to blk_by_name(), then remove */
3727 BlockDriverState *bdrv_find(const char *name)
3729 BlockBackend *blk = blk_by_name(name);
3731 return blk ? blk_bs(blk) : NULL;
3734 /* This function is to find a node in the bs graph */
3735 BlockDriverState *bdrv_find_node(const char *node_name)
3737 BlockDriverState *bs;
3741 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3742 if (!strcmp(node_name, bs->node_name)) {
3749 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3750 BlockDeviceInfoList *bdrv_named_nodes_list(void)
3752 BlockDeviceInfoList *list, *entry;
3753 BlockDriverState *bs;
3756 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3757 entry = g_malloc0(sizeof(*entry));
3758 entry->value = bdrv_block_device_info(bs);
3766 BlockDriverState *bdrv_lookup_bs(const char *device,
3767 const char *node_name,
3771 BlockDriverState *bs;
3774 blk = blk_by_name(device);
3782 bs = bdrv_find_node(node_name);
3789 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3790 device ? device : "",
3791 node_name ? node_name : "");
3795 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3796 * return false. If either argument is NULL, return false. */
3797 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3799 while (top && top != base) {
3800 top = top->backing_hd;
3806 BlockDriverState *bdrv_next(BlockDriverState *bs)
3809 return QTAILQ_FIRST(&bdrv_states);
3811 return QTAILQ_NEXT(bs, device_list);
3814 /* TODO check what callers really want: bs->node_name or blk_name() */
3815 const char *bdrv_get_device_name(const BlockDriverState *bs)
3817 return bs->blk ? blk_name(bs->blk) : "";
3820 int bdrv_get_flags(BlockDriverState *bs)
3822 return bs->open_flags;
3825 int bdrv_flush_all(void)
3827 BlockDriverState *bs;
3830 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3831 AioContext *aio_context = bdrv_get_aio_context(bs);
3834 aio_context_acquire(aio_context);
3835 ret = bdrv_flush(bs);
3836 if (ret < 0 && !result) {
3839 aio_context_release(aio_context);
3845 int bdrv_has_zero_init_1(BlockDriverState *bs)
3850 int bdrv_has_zero_init(BlockDriverState *bs)
3854 /* If BS is a copy on write image, it is initialized to
3855 the contents of the base image, which may not be zeroes. */
3856 if (bs->backing_hd) {
3859 if (bs->drv->bdrv_has_zero_init) {
3860 return bs->drv->bdrv_has_zero_init(bs);
3867 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3869 BlockDriverInfo bdi;
3871 if (bs->backing_hd) {
3875 if (bdrv_get_info(bs, &bdi) == 0) {
3876 return bdi.unallocated_blocks_are_zero;
3882 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3884 BlockDriverInfo bdi;
3886 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3890 if (bdrv_get_info(bs, &bdi) == 0) {
3891 return bdi.can_write_zeroes_with_unmap;
3897 typedef struct BdrvCoGetBlockStatusData {
3898 BlockDriverState *bs;
3899 BlockDriverState *base;
3905 } BdrvCoGetBlockStatusData;
3908 * Returns the allocation status of the specified sectors.
3909 * Drivers not implementing the functionality are assumed to not support
3910 * backing files, hence all their sectors are reported as allocated.
3912 * If 'sector_num' is beyond the end of the disk image the return value is 0
3913 * and 'pnum' is set to 0.
3915 * 'pnum' is set to the number of sectors (including and immediately following
3916 * the specified sector) that are known to be in the same
3917 * allocated/unallocated state.
3919 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3920 * beyond the end of the disk image it will be clamped.
3922 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3924 int nb_sectors, int *pnum)
3926 int64_t total_sectors;
3930 total_sectors = bdrv_nb_sectors(bs);
3931 if (total_sectors < 0) {
3932 return total_sectors;
3935 if (sector_num >= total_sectors) {
3940 n = total_sectors - sector_num;
3941 if (n < nb_sectors) {
3945 if (!bs->drv->bdrv_co_get_block_status) {
3947 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
3948 if (bs->drv->protocol_name) {
3949 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
3954 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
3960 if (ret & BDRV_BLOCK_RAW) {
3961 assert(ret & BDRV_BLOCK_OFFSET_VALID);
3962 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3966 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
3967 ret |= BDRV_BLOCK_ALLOCATED;
3970 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
3971 if (bdrv_unallocated_blocks_are_zero(bs)) {
3972 ret |= BDRV_BLOCK_ZERO;
3973 } else if (bs->backing_hd) {
3974 BlockDriverState *bs2 = bs->backing_hd;
3975 int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
3976 if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
3977 ret |= BDRV_BLOCK_ZERO;
3983 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
3984 (ret & BDRV_BLOCK_OFFSET_VALID)) {
3987 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
3990 /* Ignore errors. This is just providing extra information, it
3991 * is useful but not necessary.
3994 /* !file_pnum indicates an offset at or beyond the EOF; it is
3995 * perfectly valid for the format block driver to point to such
3996 * offsets, so catch it and mark everything as zero */
3997 ret |= BDRV_BLOCK_ZERO;
3999 /* Limit request to the range reported by the protocol driver */
4001 ret |= (ret2 & BDRV_BLOCK_ZERO);
4009 /* Coroutine wrapper for bdrv_get_block_status() */
4010 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4012 BdrvCoGetBlockStatusData *data = opaque;
4013 BlockDriverState *bs = data->bs;
4015 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4021 * Synchronous wrapper around bdrv_co_get_block_status().
4023 * See bdrv_co_get_block_status() for details.
4025 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4026 int nb_sectors, int *pnum)
4029 BdrvCoGetBlockStatusData data = {
4031 .sector_num = sector_num,
4032 .nb_sectors = nb_sectors,
4037 if (qemu_in_coroutine()) {
4038 /* Fast-path if already in coroutine context */
4039 bdrv_get_block_status_co_entry(&data);
4041 AioContext *aio_context = bdrv_get_aio_context(bs);
4043 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4044 qemu_coroutine_enter(co, &data);
4045 while (!data.done) {
4046 aio_poll(aio_context, true);
4052 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4053 int nb_sectors, int *pnum)
4055 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4059 return !!(ret & BDRV_BLOCK_ALLOCATED);
4063 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4065 * Return true if the given sector is allocated in any image between
4066 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4067 * sector is allocated in any image of the chain. Return false otherwise.
4069 * 'pnum' is set to the number of sectors (including and immediately following
4070 * the specified sector) that are known to be in the same
4071 * allocated/unallocated state.
4074 int bdrv_is_allocated_above(BlockDriverState *top,
4075 BlockDriverState *base,
4077 int nb_sectors, int *pnum)
4079 BlockDriverState *intermediate;
4080 int ret, n = nb_sectors;
4083 while (intermediate && intermediate != base) {
4085 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4095 * [sector_num, nb_sectors] is unallocated on top but intermediate
4098 * [sector_num+x, nr_sectors] allocated.
4100 if (n > pnum_inter &&
4101 (intermediate == top ||
4102 sector_num + pnum_inter < intermediate->total_sectors)) {
4106 intermediate = intermediate->backing_hd;
4113 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4115 if (bs->backing_hd && bs->backing_hd->encrypted)
4116 return bs->backing_file;
4117 else if (bs->encrypted)
4118 return bs->filename;
4123 void bdrv_get_backing_filename(BlockDriverState *bs,
4124 char *filename, int filename_size)
4126 pstrcpy(filename, filename_size, bs->backing_file);
4129 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
4130 const uint8_t *buf, int nb_sectors)
4132 BlockDriver *drv = bs->drv;
4135 if (!drv->bdrv_write_compressed)
4137 if (bdrv_check_request(bs, sector_num, nb_sectors))
4140 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4142 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4145 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4147 BlockDriver *drv = bs->drv;
4150 if (!drv->bdrv_get_info)
4152 memset(bdi, 0, sizeof(*bdi));
4153 return drv->bdrv_get_info(bs, bdi);
4156 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4158 BlockDriver *drv = bs->drv;
4159 if (drv && drv->bdrv_get_specific_info) {
4160 return drv->bdrv_get_specific_info(bs);
4165 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4166 int64_t pos, int size)
4169 struct iovec iov = {
4170 .iov_base = (void *) buf,
4174 qemu_iovec_init_external(&qiov, &iov, 1);
4175 return bdrv_writev_vmstate(bs, &qiov, pos);
4178 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4180 BlockDriver *drv = bs->drv;
4184 } else if (drv->bdrv_save_vmstate) {
4185 return drv->bdrv_save_vmstate(bs, qiov, pos);
4186 } else if (bs->file) {
4187 return bdrv_writev_vmstate(bs->file, qiov, pos);
4193 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4194 int64_t pos, int size)
4196 BlockDriver *drv = bs->drv;
4199 if (drv->bdrv_load_vmstate)
4200 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4202 return bdrv_load_vmstate(bs->file, buf, pos, size);
4206 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4208 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4212 bs->drv->bdrv_debug_event(bs, event);
4215 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4218 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4222 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4223 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4229 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4231 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4235 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4236 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4242 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4244 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4248 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4249 return bs->drv->bdrv_debug_resume(bs, tag);
4255 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4257 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4261 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4262 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4268 int bdrv_is_snapshot(BlockDriverState *bs)
4270 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4273 /* backing_file can either be relative, or absolute, or a protocol. If it is
4274 * relative, it must be relative to the chain. So, passing in bs->filename
4275 * from a BDS as backing_file should not be done, as that may be relative to
4276 * the CWD rather than the chain. */
4277 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4278 const char *backing_file)
4280 char *filename_full = NULL;
4281 char *backing_file_full = NULL;
4282 char *filename_tmp = NULL;
4283 int is_protocol = 0;
4284 BlockDriverState *curr_bs = NULL;
4285 BlockDriverState *retval = NULL;
4287 if (!bs || !bs->drv || !backing_file) {
4291 filename_full = g_malloc(PATH_MAX);
4292 backing_file_full = g_malloc(PATH_MAX);
4293 filename_tmp = g_malloc(PATH_MAX);
4295 is_protocol = path_has_protocol(backing_file);
4297 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4299 /* If either of the filename paths is actually a protocol, then
4300 * compare unmodified paths; otherwise make paths relative */
4301 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4302 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4303 retval = curr_bs->backing_hd;
4307 /* If not an absolute filename path, make it relative to the current
4308 * image's filename path */
4309 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4312 /* We are going to compare absolute pathnames */
4313 if (!realpath(filename_tmp, filename_full)) {
4317 /* We need to make sure the backing filename we are comparing against
4318 * is relative to the current image filename (or absolute) */
4319 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4320 curr_bs->backing_file);
4322 if (!realpath(filename_tmp, backing_file_full)) {
4326 if (strcmp(backing_file_full, filename_full) == 0) {
4327 retval = curr_bs->backing_hd;
4333 g_free(filename_full);
4334 g_free(backing_file_full);
4335 g_free(filename_tmp);
4339 int bdrv_get_backing_file_depth(BlockDriverState *bs)
4345 if (!bs->backing_hd) {
4349 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4352 /**************************************************************/
4355 BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4356 QEMUIOVector *qiov, int nb_sectors,
4357 BlockCompletionFunc *cb, void *opaque)
4359 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4361 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4365 BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4366 QEMUIOVector *qiov, int nb_sectors,
4367 BlockCompletionFunc *cb, void *opaque)
4369 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4371 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4375 BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4376 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4377 BlockCompletionFunc *cb, void *opaque)
4379 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4381 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4382 BDRV_REQ_ZERO_WRITE | flags,
4387 typedef struct MultiwriteCB {
4392 BlockCompletionFunc *cb;
4394 QEMUIOVector *free_qiov;
4398 static void multiwrite_user_cb(MultiwriteCB *mcb)
4402 for (i = 0; i < mcb->num_callbacks; i++) {
4403 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4404 if (mcb->callbacks[i].free_qiov) {
4405 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4407 g_free(mcb->callbacks[i].free_qiov);
4411 static void multiwrite_cb(void *opaque, int ret)
4413 MultiwriteCB *mcb = opaque;
4415 trace_multiwrite_cb(mcb, ret);
4417 if (ret < 0 && !mcb->error) {
4421 mcb->num_requests--;
4422 if (mcb->num_requests == 0) {
4423 multiwrite_user_cb(mcb);
4428 static int multiwrite_req_compare(const void *a, const void *b)
4430 const BlockRequest *req1 = a, *req2 = b;
4433 * Note that we can't simply subtract req2->sector from req1->sector
4434 * here as that could overflow the return value.
4436 if (req1->sector > req2->sector) {
4438 } else if (req1->sector < req2->sector) {
4446 * Takes a bunch of requests and tries to merge them. Returns the number of
4447 * requests that remain after merging.
4449 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4450 int num_reqs, MultiwriteCB *mcb)
4454 // Sort requests by start sector
4455 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4457 // Check if adjacent requests touch the same clusters. If so, combine them,
4458 // filling up gaps with zero sectors.
4460 for (i = 1; i < num_reqs; i++) {
4462 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4464 // Handle exactly sequential writes and overlapping writes.
4465 if (reqs[i].sector <= oldreq_last) {
4469 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4473 if (bs->bl.max_transfer_length && reqs[outidx].nb_sectors +
4474 reqs[i].nb_sectors > bs->bl.max_transfer_length) {
4480 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
4481 qemu_iovec_init(qiov,
4482 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4484 // Add the first request to the merged one. If the requests are
4485 // overlapping, drop the last sectors of the first request.
4486 size = (reqs[i].sector - reqs[outidx].sector) << 9;
4487 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
4489 // We should need to add any zeros between the two requests
4490 assert (reqs[i].sector <= oldreq_last);
4492 // Add the second request
4493 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
4495 // Add tail of first request, if necessary
4496 if (qiov->size < reqs[outidx].qiov->size) {
4497 qemu_iovec_concat(qiov, reqs[outidx].qiov, qiov->size,
4498 reqs[outidx].qiov->size - qiov->size);
4501 reqs[outidx].nb_sectors = qiov->size >> 9;
4502 reqs[outidx].qiov = qiov;
4504 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4507 reqs[outidx].sector = reqs[i].sector;
4508 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4509 reqs[outidx].qiov = reqs[i].qiov;
4517 * Submit multiple AIO write requests at once.
4519 * On success, the function returns 0 and all requests in the reqs array have
4520 * been submitted. In error case this function returns -1, and any of the
4521 * requests may or may not be submitted yet. In particular, this means that the
4522 * callback will be called for some of the requests, for others it won't. The
4523 * caller must check the error field of the BlockRequest to wait for the right
4524 * callbacks (if error != 0, no callback will be called).
4526 * The implementation may modify the contents of the reqs array, e.g. to merge
4527 * requests. However, the fields opaque and error are left unmodified as they
4528 * are used to signal failure for a single request to the caller.
4530 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4535 /* don't submit writes if we don't have a medium */
4536 if (bs->drv == NULL) {
4537 for (i = 0; i < num_reqs; i++) {
4538 reqs[i].error = -ENOMEDIUM;
4543 if (num_reqs == 0) {
4547 // Create MultiwriteCB structure
4548 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
4549 mcb->num_requests = 0;
4550 mcb->num_callbacks = num_reqs;
4552 for (i = 0; i < num_reqs; i++) {
4553 mcb->callbacks[i].cb = reqs[i].cb;
4554 mcb->callbacks[i].opaque = reqs[i].opaque;
4557 // Check for mergable requests
4558 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4560 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4562 /* Run the aio requests. */
4563 mcb->num_requests = num_reqs;
4564 for (i = 0; i < num_reqs; i++) {
4565 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4566 reqs[i].nb_sectors, reqs[i].flags,
4574 void bdrv_aio_cancel(BlockAIOCB *acb)
4577 bdrv_aio_cancel_async(acb);
4578 while (acb->refcnt > 1) {
4579 if (acb->aiocb_info->get_aio_context) {
4580 aio_poll(acb->aiocb_info->get_aio_context(acb), true);
4581 } else if (acb->bs) {
4582 aio_poll(bdrv_get_aio_context(acb->bs), true);
4587 qemu_aio_unref(acb);
4590 /* Async version of aio cancel. The caller is not blocked if the acb implements
4591 * cancel_async, otherwise we do nothing and let the request normally complete.
4592 * In either case the completion callback must be called. */
4593 void bdrv_aio_cancel_async(BlockAIOCB *acb)
4595 if (acb->aiocb_info->cancel_async) {
4596 acb->aiocb_info->cancel_async(acb);
4600 /**************************************************************/
4601 /* async block device emulation */
4603 typedef struct BlockAIOCBSync {
4607 /* vector translation state */
4613 static const AIOCBInfo bdrv_em_aiocb_info = {
4614 .aiocb_size = sizeof(BlockAIOCBSync),
4617 static void bdrv_aio_bh_cb(void *opaque)
4619 BlockAIOCBSync *acb = opaque;
4621 if (!acb->is_write && acb->ret >= 0) {
4622 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4624 qemu_vfree(acb->bounce);
4625 acb->common.cb(acb->common.opaque, acb->ret);
4626 qemu_bh_delete(acb->bh);
4628 qemu_aio_unref(acb);
4631 static BlockAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4635 BlockCompletionFunc *cb,
4640 BlockAIOCBSync *acb;
4642 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4643 acb->is_write = is_write;
4645 acb->bounce = qemu_try_blockalign(bs, qiov->size);
4646 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4648 if (acb->bounce == NULL) {
4650 } else if (is_write) {
4651 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4652 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4654 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4657 qemu_bh_schedule(acb->bh);
4659 return &acb->common;
4662 static BlockAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4663 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4664 BlockCompletionFunc *cb, void *opaque)
4666 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4669 static BlockAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4670 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4671 BlockCompletionFunc *cb, void *opaque)
4673 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4677 typedef struct BlockAIOCBCoroutine {
4683 } BlockAIOCBCoroutine;
4685 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4686 .aiocb_size = sizeof(BlockAIOCBCoroutine),
4689 static void bdrv_co_em_bh(void *opaque)
4691 BlockAIOCBCoroutine *acb = opaque;
4693 acb->common.cb(acb->common.opaque, acb->req.error);
4695 qemu_bh_delete(acb->bh);
4696 qemu_aio_unref(acb);
4699 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4700 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4702 BlockAIOCBCoroutine *acb = opaque;
4703 BlockDriverState *bs = acb->common.bs;
4705 if (!acb->is_write) {
4706 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4707 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4709 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4710 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4713 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4714 qemu_bh_schedule(acb->bh);
4717 static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4721 BdrvRequestFlags flags,
4722 BlockCompletionFunc *cb,
4727 BlockAIOCBCoroutine *acb;
4729 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4730 acb->req.sector = sector_num;
4731 acb->req.nb_sectors = nb_sectors;
4732 acb->req.qiov = qiov;
4733 acb->req.flags = flags;
4734 acb->is_write = is_write;
4736 co = qemu_coroutine_create(bdrv_co_do_rw);
4737 qemu_coroutine_enter(co, acb);
4739 return &acb->common;
4742 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4744 BlockAIOCBCoroutine *acb = opaque;
4745 BlockDriverState *bs = acb->common.bs;
4747 acb->req.error = bdrv_co_flush(bs);
4748 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4749 qemu_bh_schedule(acb->bh);
4752 BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4753 BlockCompletionFunc *cb, void *opaque)
4755 trace_bdrv_aio_flush(bs, opaque);
4758 BlockAIOCBCoroutine *acb;
4760 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4762 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4763 qemu_coroutine_enter(co, acb);
4765 return &acb->common;
4768 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4770 BlockAIOCBCoroutine *acb = opaque;
4771 BlockDriverState *bs = acb->common.bs;
4773 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4774 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4775 qemu_bh_schedule(acb->bh);
4778 BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4779 int64_t sector_num, int nb_sectors,
4780 BlockCompletionFunc *cb, void *opaque)
4783 BlockAIOCBCoroutine *acb;
4785 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4787 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4788 acb->req.sector = sector_num;
4789 acb->req.nb_sectors = nb_sectors;
4790 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4791 qemu_coroutine_enter(co, acb);
4793 return &acb->common;
4796 void bdrv_init(void)
4798 module_call_init(MODULE_INIT_BLOCK);
4801 void bdrv_init_with_whitelist(void)
4803 use_bdrv_whitelist = 1;
4807 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4808 BlockCompletionFunc *cb, void *opaque)
4812 acb = g_slice_alloc(aiocb_info->aiocb_size);
4813 acb->aiocb_info = aiocb_info;
4816 acb->opaque = opaque;
4821 void qemu_aio_ref(void *p)
4823 BlockAIOCB *acb = p;
4827 void qemu_aio_unref(void *p)
4829 BlockAIOCB *acb = p;
4830 assert(acb->refcnt > 0);
4831 if (--acb->refcnt == 0) {
4832 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4836 /**************************************************************/
4837 /* Coroutine block device emulation */
4839 typedef struct CoroutineIOCompletion {
4840 Coroutine *coroutine;
4842 } CoroutineIOCompletion;
4844 static void bdrv_co_io_em_complete(void *opaque, int ret)
4846 CoroutineIOCompletion *co = opaque;
4849 qemu_coroutine_enter(co->coroutine, NULL);
4852 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4853 int nb_sectors, QEMUIOVector *iov,
4856 CoroutineIOCompletion co = {
4857 .coroutine = qemu_coroutine_self(),
4862 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4863 bdrv_co_io_em_complete, &co);
4865 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4866 bdrv_co_io_em_complete, &co);
4869 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4873 qemu_coroutine_yield();
4878 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4879 int64_t sector_num, int nb_sectors,
4882 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4885 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4886 int64_t sector_num, int nb_sectors,
4889 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4892 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4894 RwCo *rwco = opaque;
4896 rwco->ret = bdrv_co_flush(rwco->bs);
4899 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4903 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4907 /* Write back cached data to the OS even with cache=unsafe */
4908 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
4909 if (bs->drv->bdrv_co_flush_to_os) {
4910 ret = bs->drv->bdrv_co_flush_to_os(bs);
4916 /* But don't actually force it to the disk with cache=unsafe */
4917 if (bs->open_flags & BDRV_O_NO_FLUSH) {
4921 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
4922 if (bs->drv->bdrv_co_flush_to_disk) {
4923 ret = bs->drv->bdrv_co_flush_to_disk(bs);
4924 } else if (bs->drv->bdrv_aio_flush) {
4926 CoroutineIOCompletion co = {
4927 .coroutine = qemu_coroutine_self(),
4930 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4934 qemu_coroutine_yield();
4939 * Some block drivers always operate in either writethrough or unsafe
4940 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4941 * know how the server works (because the behaviour is hardcoded or
4942 * depends on server-side configuration), so we can't ensure that
4943 * everything is safe on disk. Returning an error doesn't work because
4944 * that would break guests even if the server operates in writethrough
4947 * Let's hope the user knows what he's doing.
4955 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4956 * in the case of cache=unsafe, so there are no useless flushes.
4959 return bdrv_co_flush(bs->file);
4962 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4964 Error *local_err = NULL;
4971 if (!(bs->open_flags & BDRV_O_INCOMING)) {
4974 bs->open_flags &= ~BDRV_O_INCOMING;
4976 if (bs->drv->bdrv_invalidate_cache) {
4977 bs->drv->bdrv_invalidate_cache(bs, &local_err);
4978 } else if (bs->file) {
4979 bdrv_invalidate_cache(bs->file, &local_err);
4982 error_propagate(errp, local_err);
4986 ret = refresh_total_sectors(bs, bs->total_sectors);
4988 error_setg_errno(errp, -ret, "Could not refresh total sector count");
4993 void bdrv_invalidate_cache_all(Error **errp)
4995 BlockDriverState *bs;
4996 Error *local_err = NULL;
4998 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
4999 AioContext *aio_context = bdrv_get_aio_context(bs);
5001 aio_context_acquire(aio_context);
5002 bdrv_invalidate_cache(bs, &local_err);
5003 aio_context_release(aio_context);
5005 error_propagate(errp, local_err);
5011 int bdrv_flush(BlockDriverState *bs)
5019 if (qemu_in_coroutine()) {
5020 /* Fast-path if already in coroutine context */
5021 bdrv_flush_co_entry(&rwco);
5023 AioContext *aio_context = bdrv_get_aio_context(bs);
5025 co = qemu_coroutine_create(bdrv_flush_co_entry);
5026 qemu_coroutine_enter(co, &rwco);
5027 while (rwco.ret == NOT_DONE) {
5028 aio_poll(aio_context, true);
5035 typedef struct DiscardCo {
5036 BlockDriverState *bs;
5041 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5043 DiscardCo *rwco = opaque;
5045 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5048 /* if no limit is specified in the BlockLimits use a default
5049 * of 32768 512-byte sectors (16 MiB) per request.
5051 #define MAX_DISCARD_DEFAULT 32768
5053 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5060 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5062 } else if (bs->read_only) {
5066 bdrv_reset_dirty(bs, sector_num, nb_sectors);
5068 /* Do nothing if disabled. */
5069 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5073 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
5077 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5078 while (nb_sectors > 0) {
5080 int num = nb_sectors;
5083 if (bs->bl.discard_alignment &&
5084 num >= bs->bl.discard_alignment &&
5085 sector_num % bs->bl.discard_alignment) {
5086 if (num > bs->bl.discard_alignment) {
5087 num = bs->bl.discard_alignment;
5089 num -= sector_num % bs->bl.discard_alignment;
5092 /* limit request size */
5093 if (num > max_discard) {
5097 if (bs->drv->bdrv_co_discard) {
5098 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5101 CoroutineIOCompletion co = {
5102 .coroutine = qemu_coroutine_self(),
5105 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5106 bdrv_co_io_em_complete, &co);
5110 qemu_coroutine_yield();
5114 if (ret && ret != -ENOTSUP) {
5124 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5129 .sector_num = sector_num,
5130 .nb_sectors = nb_sectors,
5134 if (qemu_in_coroutine()) {
5135 /* Fast-path if already in coroutine context */
5136 bdrv_discard_co_entry(&rwco);
5138 AioContext *aio_context = bdrv_get_aio_context(bs);
5140 co = qemu_coroutine_create(bdrv_discard_co_entry);
5141 qemu_coroutine_enter(co, &rwco);
5142 while (rwco.ret == NOT_DONE) {
5143 aio_poll(aio_context, true);
5150 /**************************************************************/
5151 /* removable device support */
5154 * Return TRUE if the media is present
5156 int bdrv_is_inserted(BlockDriverState *bs)
5158 BlockDriver *drv = bs->drv;
5162 if (!drv->bdrv_is_inserted)
5164 return drv->bdrv_is_inserted(bs);
5168 * Return whether the media changed since the last call to this
5169 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5171 int bdrv_media_changed(BlockDriverState *bs)
5173 BlockDriver *drv = bs->drv;
5175 if (drv && drv->bdrv_media_changed) {
5176 return drv->bdrv_media_changed(bs);
5182 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5184 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5186 BlockDriver *drv = bs->drv;
5187 const char *device_name;
5189 if (drv && drv->bdrv_eject) {
5190 drv->bdrv_eject(bs, eject_flag);
5193 device_name = bdrv_get_device_name(bs);
5194 if (device_name[0] != '\0') {
5195 qapi_event_send_device_tray_moved(device_name,
5196 eject_flag, &error_abort);
5201 * Lock or unlock the media (if it is locked, the user won't be able
5202 * to eject it manually).
5204 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5206 BlockDriver *drv = bs->drv;
5208 trace_bdrv_lock_medium(bs, locked);
5210 if (drv && drv->bdrv_lock_medium) {
5211 drv->bdrv_lock_medium(bs, locked);
5215 /* needed for generic scsi interface */
5217 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5219 BlockDriver *drv = bs->drv;
5221 if (drv && drv->bdrv_ioctl)
5222 return drv->bdrv_ioctl(bs, req, buf);
5226 BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5227 unsigned long int req, void *buf,
5228 BlockCompletionFunc *cb, void *opaque)
5230 BlockDriver *drv = bs->drv;
5232 if (drv && drv->bdrv_aio_ioctl)
5233 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5237 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5239 bs->guest_block_size = align;
5242 void *qemu_blockalign(BlockDriverState *bs, size_t size)
5244 return qemu_memalign(bdrv_opt_mem_align(bs), size);
5247 void *qemu_blockalign0(BlockDriverState *bs, size_t size)
5249 return memset(qemu_blockalign(bs, size), 0, size);
5252 void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
5254 size_t align = bdrv_opt_mem_align(bs);
5256 /* Ensure that NULL is never returned on success */
5262 return qemu_try_memalign(align, size);
5265 void *qemu_try_blockalign0(BlockDriverState *bs, size_t size)
5267 void *mem = qemu_try_blockalign(bs, size);
5270 memset(mem, 0, size);
5277 * Check if all memory in this vector is sector aligned.
5279 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5282 size_t alignment = bdrv_opt_mem_align(bs);
5284 for (i = 0; i < qiov->niov; i++) {
5285 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5288 if (qiov->iov[i].iov_len % alignment) {
5296 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5299 int64_t bitmap_size;
5300 BdrvDirtyBitmap *bitmap;
5302 assert((granularity & (granularity - 1)) == 0);
5304 granularity >>= BDRV_SECTOR_BITS;
5305 assert(granularity);
5306 bitmap_size = bdrv_nb_sectors(bs);
5307 if (bitmap_size < 0) {
5308 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5309 errno = -bitmap_size;
5312 bitmap = g_new0(BdrvDirtyBitmap, 1);
5313 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5314 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5318 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5320 BdrvDirtyBitmap *bm, *next;
5321 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5323 QLIST_REMOVE(bitmap, list);
5324 hbitmap_free(bitmap->bitmap);
5331 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5333 BdrvDirtyBitmap *bm;
5334 BlockDirtyInfoList *list = NULL;
5335 BlockDirtyInfoList **plist = &list;
5337 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5338 BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);
5339 BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);
5340 info->count = bdrv_get_dirty_count(bs, bm);
5342 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5343 entry->value = info;
5345 plist = &entry->next;
5351 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5354 return hbitmap_get(bitmap->bitmap, sector);
5360 void bdrv_dirty_iter_init(BlockDriverState *bs,
5361 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5363 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5366 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5369 BdrvDirtyBitmap *bitmap;
5370 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5371 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5375 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5377 BdrvDirtyBitmap *bitmap;
5378 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5379 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5383 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5385 return hbitmap_count(bitmap->bitmap);
5388 /* Get a reference to bs */
5389 void bdrv_ref(BlockDriverState *bs)
5394 /* Release a previously grabbed reference to bs.
5395 * If after releasing, reference count is zero, the BlockDriverState is
5397 void bdrv_unref(BlockDriverState *bs)
5402 assert(bs->refcnt > 0);
5403 if (--bs->refcnt == 0) {
5408 struct BdrvOpBlocker {
5410 QLIST_ENTRY(BdrvOpBlocker) list;
5413 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5415 BdrvOpBlocker *blocker;
5416 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5417 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5418 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5420 error_setg(errp, "Device '%s' is busy: %s",
5421 bdrv_get_device_name(bs),
5422 error_get_pretty(blocker->reason));
5429 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5431 BdrvOpBlocker *blocker;
5432 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5434 blocker = g_new0(BdrvOpBlocker, 1);
5435 blocker->reason = reason;
5436 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5439 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5441 BdrvOpBlocker *blocker, *next;
5442 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5443 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5444 if (blocker->reason == reason) {
5445 QLIST_REMOVE(blocker, list);
5451 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5454 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5455 bdrv_op_block(bs, i, reason);
5459 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5462 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5463 bdrv_op_unblock(bs, i, reason);
5467 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5471 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5472 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5479 void bdrv_iostatus_enable(BlockDriverState *bs)
5481 bs->iostatus_enabled = true;
5482 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5485 /* The I/O status is only enabled if the drive explicitly
5486 * enables it _and_ the VM is configured to stop on errors */
5487 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5489 return (bs->iostatus_enabled &&
5490 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5491 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5492 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5495 void bdrv_iostatus_disable(BlockDriverState *bs)
5497 bs->iostatus_enabled = false;
5500 void bdrv_iostatus_reset(BlockDriverState *bs)
5502 if (bdrv_iostatus_is_enabled(bs)) {
5503 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5505 block_job_iostatus_reset(bs->job);
5510 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5512 assert(bdrv_iostatus_is_enabled(bs));
5513 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5514 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5515 BLOCK_DEVICE_IO_STATUS_FAILED;
5519 void bdrv_img_create(const char *filename, const char *fmt,
5520 const char *base_filename, const char *base_fmt,
5521 char *options, uint64_t img_size, int flags,
5522 Error **errp, bool quiet)
5524 QemuOptsList *create_opts = NULL;
5525 QemuOpts *opts = NULL;
5526 const char *backing_fmt, *backing_file;
5528 BlockDriver *drv, *proto_drv;
5529 BlockDriver *backing_drv = NULL;
5530 Error *local_err = NULL;
5533 /* Find driver and parse its options */
5534 drv = bdrv_find_format(fmt);
5536 error_setg(errp, "Unknown file format '%s'", fmt);
5540 proto_drv = bdrv_find_protocol(filename, true);
5542 error_setg(errp, "Unknown protocol '%s'", filename);
5546 create_opts = qemu_opts_append(create_opts, drv->create_opts);
5547 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5549 /* Create parameter list with default values */
5550 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5551 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
5553 /* Parse -o options */
5555 if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5556 error_setg(errp, "Invalid options for file format '%s'", fmt);
5561 if (base_filename) {
5562 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5563 error_setg(errp, "Backing file not supported for file format '%s'",
5570 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5571 error_setg(errp, "Backing file format not supported for file "
5572 "format '%s'", fmt);
5577 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5579 if (!strcmp(filename, backing_file)) {
5580 error_setg(errp, "Error: Trying to create an image with the "
5581 "same filename as the backing file");
5586 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5588 backing_drv = bdrv_find_format(backing_fmt);
5590 error_setg(errp, "Unknown backing file format '%s'",
5596 // The size for the image must always be specified, with one exception:
5597 // If we are using a backing file, we can obtain the size from there
5598 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5601 BlockDriverState *bs;
5605 /* backing files always opened read-only */
5607 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5610 ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5611 backing_drv, &local_err);
5615 size = bdrv_getlength(bs);
5617 error_setg_errno(errp, -size, "Could not get size of '%s'",
5623 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5627 error_setg(errp, "Image creation needs a size parameter");
5633 printf("Formatting '%s', fmt=%s ", filename, fmt);
5634 qemu_opts_print(opts);
5638 ret = bdrv_create(drv, filename, opts, &local_err);
5640 if (ret == -EFBIG) {
5641 /* This is generally a better message than whatever the driver would
5642 * deliver (especially because of the cluster_size_hint), since that
5643 * is most probably not much different from "image too large". */
5644 const char *cluster_size_hint = "";
5645 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5646 cluster_size_hint = " (try using a larger cluster size)";
5648 error_setg(errp, "The image size is too large for file format '%s'"
5649 "%s", fmt, cluster_size_hint);
5650 error_free(local_err);
5655 qemu_opts_del(opts);
5656 qemu_opts_free(create_opts);
5658 error_propagate(errp, local_err);
5662 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5664 return bs->aio_context;
5667 void bdrv_detach_aio_context(BlockDriverState *bs)
5669 BdrvAioNotifier *baf;
5675 QLIST_FOREACH(baf, &bs->aio_notifiers, list) {
5676 baf->detach_aio_context(baf->opaque);
5679 if (bs->io_limits_enabled) {
5680 throttle_detach_aio_context(&bs->throttle_state);
5682 if (bs->drv->bdrv_detach_aio_context) {
5683 bs->drv->bdrv_detach_aio_context(bs);
5686 bdrv_detach_aio_context(bs->file);
5688 if (bs->backing_hd) {
5689 bdrv_detach_aio_context(bs->backing_hd);
5692 bs->aio_context = NULL;
5695 void bdrv_attach_aio_context(BlockDriverState *bs,
5696 AioContext *new_context)
5698 BdrvAioNotifier *ban;
5704 bs->aio_context = new_context;
5706 if (bs->backing_hd) {
5707 bdrv_attach_aio_context(bs->backing_hd, new_context);
5710 bdrv_attach_aio_context(bs->file, new_context);
5712 if (bs->drv->bdrv_attach_aio_context) {
5713 bs->drv->bdrv_attach_aio_context(bs, new_context);
5715 if (bs->io_limits_enabled) {
5716 throttle_attach_aio_context(&bs->throttle_state, new_context);
5719 QLIST_FOREACH(ban, &bs->aio_notifiers, list) {
5720 ban->attached_aio_context(new_context, ban->opaque);
5724 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5726 bdrv_drain_all(); /* ensure there are no in-flight requests */
5728 bdrv_detach_aio_context(bs);
5730 /* This function executes in the old AioContext so acquire the new one in
5731 * case it runs in a different thread.
5733 aio_context_acquire(new_context);
5734 bdrv_attach_aio_context(bs, new_context);
5735 aio_context_release(new_context);
5738 void bdrv_add_aio_context_notifier(BlockDriverState *bs,
5739 void (*attached_aio_context)(AioContext *new_context, void *opaque),
5740 void (*detach_aio_context)(void *opaque), void *opaque)
5742 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1);
5743 *ban = (BdrvAioNotifier){
5744 .attached_aio_context = attached_aio_context,
5745 .detach_aio_context = detach_aio_context,
5749 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list);
5752 void bdrv_remove_aio_context_notifier(BlockDriverState *bs,
5753 void (*attached_aio_context)(AioContext *,
5755 void (*detach_aio_context)(void *),
5758 BdrvAioNotifier *ban, *ban_next;
5760 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) {
5761 if (ban->attached_aio_context == attached_aio_context &&
5762 ban->detach_aio_context == detach_aio_context &&
5763 ban->opaque == opaque)
5765 QLIST_REMOVE(ban, list);
5775 void bdrv_add_before_write_notifier(BlockDriverState *bs,
5776 NotifierWithReturn *notifier)
5778 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5781 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,
5782 BlockDriverAmendStatusCB *status_cb)
5784 if (!bs->drv->bdrv_amend_options) {
5787 return bs->drv->bdrv_amend_options(bs, opts, status_cb);
5790 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5791 * of block filter and by bdrv_is_first_non_filter.
5792 * It is used to test if the given bs is the candidate or recurse more in the
5795 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5796 BlockDriverState *candidate)
5798 /* return false if basic checks fails */
5799 if (!bs || !bs->drv) {
5803 /* the code reached a non block filter driver -> check if the bs is
5804 * the same as the candidate. It's the recursion termination condition.
5806 if (!bs->drv->is_filter) {
5807 return bs == candidate;
5809 /* Down this path the driver is a block filter driver */
5811 /* If the block filter recursion method is defined use it to recurse down
5814 if (bs->drv->bdrv_recurse_is_first_non_filter) {
5815 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5818 /* the driver is a block filter but don't allow to recurse -> return false
5823 /* This function checks if the candidate is the first non filter bs down it's
5824 * bs chain. Since we don't have pointers to parents it explore all bs chains
5825 * from the top. Some filters can choose not to pass down the recursion.
5827 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5829 BlockDriverState *bs;
5831 /* walk down the bs forest recursively */
5832 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5835 /* try to recurse in this top level bs */
5836 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5838 /* candidate is the first non filter */
5847 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5849 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5850 AioContext *aio_context;
5852 if (!to_replace_bs) {
5853 error_setg(errp, "Node name '%s' not found", node_name);
5857 aio_context = bdrv_get_aio_context(to_replace_bs);
5858 aio_context_acquire(aio_context);
5860 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5861 to_replace_bs = NULL;
5865 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5866 * most non filter in order to prevent data corruption.
5867 * Another benefit is that this tests exclude backing files which are
5868 * blocked by the backing blockers.
5870 if (!bdrv_is_first_non_filter(to_replace_bs)) {
5871 error_setg(errp, "Only top most non filter can be replaced");
5872 to_replace_bs = NULL;
5877 aio_context_release(aio_context);
5878 return to_replace_bs;
5881 void bdrv_io_plug(BlockDriverState *bs)
5883 BlockDriver *drv = bs->drv;
5884 if (drv && drv->bdrv_io_plug) {
5885 drv->bdrv_io_plug(bs);
5886 } else if (bs->file) {
5887 bdrv_io_plug(bs->file);
5891 void bdrv_io_unplug(BlockDriverState *bs)
5893 BlockDriver *drv = bs->drv;
5894 if (drv && drv->bdrv_io_unplug) {
5895 drv->bdrv_io_unplug(bs);
5896 } else if (bs->file) {
5897 bdrv_io_unplug(bs->file);
5901 void bdrv_flush_io_queue(BlockDriverState *bs)
5903 BlockDriver *drv = bs->drv;
5904 if (drv && drv->bdrv_flush_io_queue) {
5905 drv->bdrv_flush_io_queue(bs);
5906 } else if (bs->file) {
5907 bdrv_flush_io_queue(bs->file);
5911 static bool append_open_options(QDict *d, BlockDriverState *bs)
5913 const QDictEntry *entry;
5914 bool found_any = false;
5916 for (entry = qdict_first(bs->options); entry;
5917 entry = qdict_next(bs->options, entry))
5919 /* Only take options for this level and exclude all non-driver-specific
5921 if (!strchr(qdict_entry_key(entry), '.') &&
5922 strcmp(qdict_entry_key(entry), "node-name"))
5924 qobject_incref(qdict_entry_value(entry));
5925 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry));
5933 /* Updates the following BDS fields:
5934 * - exact_filename: A filename which may be used for opening a block device
5935 * which (mostly) equals the given BDS (even without any
5936 * other options; so reading and writing must return the same
5937 * results, but caching etc. may be different)
5938 * - full_open_options: Options which, when given when opening a block device
5939 * (without a filename), result in a BDS (mostly)
5940 * equalling the given one
5941 * - filename: If exact_filename is set, it is copied here. Otherwise,
5942 * full_open_options is converted to a JSON object, prefixed with
5943 * "json:" (for use through the JSON pseudo protocol) and put here.
5945 void bdrv_refresh_filename(BlockDriverState *bs)
5947 BlockDriver *drv = bs->drv;
5954 /* This BDS's file name will most probably depend on its file's name, so
5955 * refresh that first */
5957 bdrv_refresh_filename(bs->file);
5960 if (drv->bdrv_refresh_filename) {
5961 /* Obsolete information is of no use here, so drop the old file name
5962 * information before refreshing it */
5963 bs->exact_filename[0] = '\0';
5964 if (bs->full_open_options) {
5965 QDECREF(bs->full_open_options);
5966 bs->full_open_options = NULL;
5969 drv->bdrv_refresh_filename(bs);
5970 } else if (bs->file) {
5971 /* Try to reconstruct valid information from the underlying file */
5972 bool has_open_options;
5974 bs->exact_filename[0] = '\0';
5975 if (bs->full_open_options) {
5976 QDECREF(bs->full_open_options);
5977 bs->full_open_options = NULL;
5981 has_open_options = append_open_options(opts, bs);
5983 /* If no specific options have been given for this BDS, the filename of
5984 * the underlying file should suffice for this one as well */
5985 if (bs->file->exact_filename[0] && !has_open_options) {
5986 strcpy(bs->exact_filename, bs->file->exact_filename);
5988 /* Reconstructing the full options QDict is simple for most format block
5989 * drivers, as long as the full options are known for the underlying
5990 * file BDS. The full options QDict of that file BDS should somehow
5991 * contain a representation of the filename, therefore the following
5992 * suffices without querying the (exact_)filename of this BDS. */
5993 if (bs->file->full_open_options) {
5994 qdict_put_obj(opts, "driver",
5995 QOBJECT(qstring_from_str(drv->format_name)));
5996 QINCREF(bs->file->full_open_options);
5997 qdict_put_obj(opts, "file", QOBJECT(bs->file->full_open_options));
5999 bs->full_open_options = opts;
6003 } else if (!bs->full_open_options && qdict_size(bs->options)) {
6004 /* There is no underlying file BDS (at least referenced by BDS.file),
6005 * so the full options QDict should be equal to the options given
6006 * specifically for this block device when it was opened (plus the
6007 * driver specification).
6008 * Because those options don't change, there is no need to update
6009 * full_open_options when it's already set. */
6012 append_open_options(opts, bs);
6013 qdict_put_obj(opts, "driver",
6014 QOBJECT(qstring_from_str(drv->format_name)));
6016 if (bs->exact_filename[0]) {
6017 /* This may not work for all block protocol drivers (some may
6018 * require this filename to be parsed), but we have to find some
6019 * default solution here, so just include it. If some block driver
6020 * does not support pure options without any filename at all or
6021 * needs some special format of the options QDict, it needs to
6022 * implement the driver-specific bdrv_refresh_filename() function.
6024 qdict_put_obj(opts, "filename",
6025 QOBJECT(qstring_from_str(bs->exact_filename)));
6028 bs->full_open_options = opts;
6031 if (bs->exact_filename[0]) {
6032 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename);
6033 } else if (bs->full_open_options) {
6034 QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
6035 snprintf(bs->filename, sizeof(bs->filename), "json:%s",
6036 qstring_get_str(json));
6041 /* This accessor function purpose is to allow the device models to access the
6042 * BlockAcctStats structure embedded inside a BlockDriverState without being
6043 * aware of the BlockDriverState structure layout.
6044 * It will go away when the BlockAcctStats structure will be moved inside
6045 * the device models.
6047 BlockAcctStats *bdrv_get_stats(BlockDriverState *bs)