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 "sysemu/qtest.h"
34 #include "qemu/notify.h"
35 #include "block/coroutine.h"
36 #include "block/qapi.h"
37 #include "qmp-commands.h"
38 #include "qemu/timer.h"
39 #include "qapi-event.h"
42 #include <sys/types.h>
44 #include <sys/ioctl.h>
45 #include <sys/queue.h>
56 * A BdrvDirtyBitmap can be in three possible states:
57 * (1) successor is NULL and disabled is false: full r/w mode
58 * (2) successor is NULL and disabled is true: read only mode ("disabled")
59 * (3) successor is set: frozen mode.
60 * A frozen bitmap cannot be renamed, deleted, anonymized, cleared, set,
61 * or enabled. A frozen bitmap can only abdicate() or reclaim().
63 struct BdrvDirtyBitmap
{
65 BdrvDirtyBitmap
*successor
;
68 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
71 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
73 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
74 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
75 BlockCompletionFunc
*cb
, void *opaque
);
76 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
77 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
78 BlockCompletionFunc
*cb
, void *opaque
);
79 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
80 int64_t sector_num
, int nb_sectors
,
82 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
83 int64_t sector_num
, int nb_sectors
,
85 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
86 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
87 BdrvRequestFlags flags
);
88 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
89 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
90 BdrvRequestFlags flags
);
91 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
95 BdrvRequestFlags flags
,
96 BlockCompletionFunc
*cb
,
99 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
100 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
101 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
103 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
104 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
106 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
107 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
109 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
110 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
112 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
114 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
116 /* If non-zero, use only whitelisted block drivers */
117 static int use_bdrv_whitelist
;
120 static int is_windows_drive_prefix(const char *filename
)
122 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
123 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
127 int is_windows_drive(const char *filename
)
129 if (is_windows_drive_prefix(filename
) &&
132 if (strstart(filename
, "\\\\.\\", NULL
) ||
133 strstart(filename
, "//./", NULL
))
139 /* throttling disk I/O limits */
140 void bdrv_set_io_limits(BlockDriverState
*bs
,
145 throttle_config(&bs
->throttle_state
, cfg
);
147 for (i
= 0; i
< 2; i
++) {
148 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
152 /* this function drain all the throttled IOs */
153 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
155 bool drained
= false;
156 bool enabled
= bs
->io_limits_enabled
;
159 bs
->io_limits_enabled
= false;
161 for (i
= 0; i
< 2; i
++) {
162 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
167 bs
->io_limits_enabled
= enabled
;
172 void bdrv_io_limits_disable(BlockDriverState
*bs
)
174 bs
->io_limits_enabled
= false;
176 bdrv_start_throttled_reqs(bs
);
178 throttle_destroy(&bs
->throttle_state
);
181 static void bdrv_throttle_read_timer_cb(void *opaque
)
183 BlockDriverState
*bs
= opaque
;
184 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
187 static void bdrv_throttle_write_timer_cb(void *opaque
)
189 BlockDriverState
*bs
= opaque
;
190 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
193 /* should be called before bdrv_set_io_limits if a limit is set */
194 void bdrv_io_limits_enable(BlockDriverState
*bs
)
196 int clock_type
= QEMU_CLOCK_REALTIME
;
198 if (qtest_enabled()) {
199 /* For testing block IO throttling only */
200 clock_type
= QEMU_CLOCK_VIRTUAL
;
202 assert(!bs
->io_limits_enabled
);
203 throttle_init(&bs
->throttle_state
,
204 bdrv_get_aio_context(bs
),
206 bdrv_throttle_read_timer_cb
,
207 bdrv_throttle_write_timer_cb
,
209 bs
->io_limits_enabled
= true;
212 /* This function makes an IO wait if needed
214 * @nb_sectors: the number of sectors of the IO
215 * @is_write: is the IO a write
217 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
221 /* does this io must wait */
222 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
224 /* if must wait or any request of this type throttled queue the IO */
226 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
227 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
230 /* the IO will be executed, do the accounting */
231 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
234 /* if the next request must wait -> do nothing */
235 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
239 /* else queue next request for execution */
240 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
243 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
245 if (!bs
|| !bs
->drv
) {
246 /* 4k should be on the safe side */
250 return bs
->bl
.opt_mem_alignment
;
253 /* check if the path starts with "<protocol>:" */
254 int path_has_protocol(const char *path
)
259 if (is_windows_drive(path
) ||
260 is_windows_drive_prefix(path
)) {
263 p
= path
+ strcspn(path
, ":/\\");
265 p
= path
+ strcspn(path
, ":/");
271 int path_is_absolute(const char *path
)
274 /* specific case for names like: "\\.\d:" */
275 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
278 return (*path
== '/' || *path
== '\\');
280 return (*path
== '/');
284 /* if filename is absolute, just copy it to dest. Otherwise, build a
285 path to it by considering it is relative to base_path. URL are
287 void path_combine(char *dest
, int dest_size
,
288 const char *base_path
,
289 const char *filename
)
296 if (path_is_absolute(filename
)) {
297 pstrcpy(dest
, dest_size
, filename
);
299 p
= strchr(base_path
, ':');
304 p1
= strrchr(base_path
, '/');
308 p2
= strrchr(base_path
, '\\');
320 if (len
> dest_size
- 1)
322 memcpy(dest
, base_path
, len
);
324 pstrcat(dest
, dest_size
, filename
);
328 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
330 char *dest
, size_t sz
,
333 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
334 path_is_absolute(backing
))
336 pstrcpy(dest
, sz
, backing
);
337 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
338 error_setg(errp
, "Cannot use relative backing file names for '%s'",
341 path_combine(dest
, sz
, backed
, backing
);
345 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
348 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
350 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
354 void bdrv_register(BlockDriver
*bdrv
)
356 /* Block drivers without coroutine functions need emulation */
357 if (!bdrv
->bdrv_co_readv
) {
358 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
359 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
361 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
362 * the block driver lacks aio we need to emulate that too.
364 if (!bdrv
->bdrv_aio_readv
) {
365 /* add AIO emulation layer */
366 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
367 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
371 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
374 BlockDriverState
*bdrv_new_root(void)
376 BlockDriverState
*bs
= bdrv_new();
378 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
382 BlockDriverState
*bdrv_new(void)
384 BlockDriverState
*bs
;
387 bs
= g_new0(BlockDriverState
, 1);
388 QLIST_INIT(&bs
->dirty_bitmaps
);
389 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
390 QLIST_INIT(&bs
->op_blockers
[i
]);
392 bdrv_iostatus_disable(bs
);
393 notifier_list_init(&bs
->close_notifiers
);
394 notifier_with_return_list_init(&bs
->before_write_notifiers
);
395 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
396 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
398 bs
->aio_context
= qemu_get_aio_context();
403 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
405 notifier_list_add(&bs
->close_notifiers
, notify
);
408 BlockDriver
*bdrv_find_format(const char *format_name
)
411 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
412 if (!strcmp(drv1
->format_name
, format_name
)) {
419 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
421 static const char *whitelist_rw
[] = {
422 CONFIG_BDRV_RW_WHITELIST
424 static const char *whitelist_ro
[] = {
425 CONFIG_BDRV_RO_WHITELIST
429 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
430 return 1; /* no whitelist, anything goes */
433 for (p
= whitelist_rw
; *p
; p
++) {
434 if (!strcmp(drv
->format_name
, *p
)) {
439 for (p
= whitelist_ro
; *p
; p
++) {
440 if (!strcmp(drv
->format_name
, *p
)) {
448 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
451 BlockDriver
*drv
= bdrv_find_format(format_name
);
452 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
455 typedef struct CreateCo
{
463 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
465 Error
*local_err
= NULL
;
468 CreateCo
*cco
= opaque
;
471 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
473 error_propagate(&cco
->err
, local_err
);
478 int bdrv_create(BlockDriver
*drv
, const char* filename
,
479 QemuOpts
*opts
, Error
**errp
)
486 .filename
= g_strdup(filename
),
492 if (!drv
->bdrv_create
) {
493 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
498 if (qemu_in_coroutine()) {
499 /* Fast-path if already in coroutine context */
500 bdrv_create_co_entry(&cco
);
502 co
= qemu_coroutine_create(bdrv_create_co_entry
);
503 qemu_coroutine_enter(co
, &cco
);
504 while (cco
.ret
== NOT_DONE
) {
505 aio_poll(qemu_get_aio_context(), true);
512 error_propagate(errp
, cco
.err
);
514 error_setg_errno(errp
, -ret
, "Could not create image");
519 g_free(cco
.filename
);
523 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
526 Error
*local_err
= NULL
;
529 drv
= bdrv_find_protocol(filename
, true, errp
);
534 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
536 error_propagate(errp
, local_err
);
541 void bdrv_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
543 BlockDriver
*drv
= bs
->drv
;
544 Error
*local_err
= NULL
;
546 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
552 /* Take some limits from the children as a default */
554 bdrv_refresh_limits(bs
->file
, &local_err
);
556 error_propagate(errp
, local_err
);
559 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
560 bs
->bl
.max_transfer_length
= bs
->file
->bl
.max_transfer_length
;
561 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
563 bs
->bl
.opt_mem_alignment
= 512;
566 if (bs
->backing_hd
) {
567 bdrv_refresh_limits(bs
->backing_hd
, &local_err
);
569 error_propagate(errp
, local_err
);
572 bs
->bl
.opt_transfer_length
=
573 MAX(bs
->bl
.opt_transfer_length
,
574 bs
->backing_hd
->bl
.opt_transfer_length
);
575 bs
->bl
.max_transfer_length
=
576 MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
577 bs
->backing_hd
->bl
.max_transfer_length
);
578 bs
->bl
.opt_mem_alignment
=
579 MAX(bs
->bl
.opt_mem_alignment
,
580 bs
->backing_hd
->bl
.opt_mem_alignment
);
583 /* Then let the driver override it */
584 if (drv
->bdrv_refresh_limits
) {
585 drv
->bdrv_refresh_limits(bs
, errp
);
590 * Try to get @bs's logical and physical block size.
591 * On success, store them in @bsz struct and return 0.
592 * On failure return -errno.
593 * @bs must not be empty.
595 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
597 BlockDriver
*drv
= bs
->drv
;
599 if (drv
&& drv
->bdrv_probe_blocksizes
) {
600 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
607 * Try to get @bs's geometry (cyls, heads, sectors).
608 * On success, store them in @geo struct and return 0.
609 * On failure return -errno.
610 * @bs must not be empty.
612 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
614 BlockDriver
*drv
= bs
->drv
;
616 if (drv
&& drv
->bdrv_probe_geometry
) {
617 return drv
->bdrv_probe_geometry(bs
, geo
);
624 * Create a uniquely-named empty temporary file.
625 * Return 0 upon success, otherwise a negative errno value.
627 int get_tmp_filename(char *filename
, int size
)
630 char temp_dir
[MAX_PATH
];
631 /* GetTempFileName requires that its output buffer (4th param)
632 have length MAX_PATH or greater. */
633 assert(size
>= MAX_PATH
);
634 return (GetTempPath(MAX_PATH
, temp_dir
)
635 && GetTempFileName(temp_dir
, "qem", 0, filename
)
636 ? 0 : -GetLastError());
640 tmpdir
= getenv("TMPDIR");
644 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
647 fd
= mkstemp(filename
);
651 if (close(fd
) != 0) {
660 * Detect host devices. By convention, /dev/cdrom[N] is always
661 * recognized as a host CDROM.
663 static BlockDriver
*find_hdev_driver(const char *filename
)
665 int score_max
= 0, score
;
666 BlockDriver
*drv
= NULL
, *d
;
668 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
669 if (d
->bdrv_probe_device
) {
670 score
= d
->bdrv_probe_device(filename
);
671 if (score
> score_max
) {
681 BlockDriver
*bdrv_find_protocol(const char *filename
,
682 bool allow_protocol_prefix
,
690 /* TODO Drivers without bdrv_file_open must be specified explicitly */
693 * XXX(hch): we really should not let host device detection
694 * override an explicit protocol specification, but moving this
695 * later breaks access to device names with colons in them.
696 * Thanks to the brain-dead persistent naming schemes on udev-
697 * based Linux systems those actually are quite common.
699 drv1
= find_hdev_driver(filename
);
704 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
708 p
= strchr(filename
, ':');
711 if (len
> sizeof(protocol
) - 1)
712 len
= sizeof(protocol
) - 1;
713 memcpy(protocol
, filename
, len
);
714 protocol
[len
] = '\0';
715 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
716 if (drv1
->protocol_name
&&
717 !strcmp(drv1
->protocol_name
, protocol
)) {
722 error_setg(errp
, "Unknown protocol '%s'", protocol
);
727 * Guess image format by probing its contents.
728 * This is not a good idea when your image is raw (CVE-2008-2004), but
729 * we do it anyway for backward compatibility.
731 * @buf contains the image's first @buf_size bytes.
732 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
733 * but can be smaller if the image file is smaller)
734 * @filename is its filename.
736 * For all block drivers, call the bdrv_probe() method to get its
738 * Return the first block driver with the highest probing score.
740 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
741 const char *filename
)
743 int score_max
= 0, score
;
744 BlockDriver
*drv
= NULL
, *d
;
746 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
748 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
749 if (score
> score_max
) {
759 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
760 BlockDriver
**pdrv
, Error
**errp
)
763 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
766 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
767 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
772 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
774 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
780 drv
= bdrv_probe_all(buf
, ret
, filename
);
782 error_setg(errp
, "Could not determine image format: No compatible "
791 * Set the current 'total_sectors' value
792 * Return 0 on success, -errno on error.
794 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
796 BlockDriver
*drv
= bs
->drv
;
798 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
802 /* query actual device if possible, otherwise just trust the hint */
803 if (drv
->bdrv_getlength
) {
804 int64_t length
= drv
->bdrv_getlength(bs
);
808 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
811 bs
->total_sectors
= hint
;
816 * Set open flags for a given discard mode
818 * Return 0 on success, -1 if the discard mode was invalid.
820 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
822 *flags
&= ~BDRV_O_UNMAP
;
824 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
826 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
827 *flags
|= BDRV_O_UNMAP
;
836 * Set open flags for a given cache mode
838 * Return 0 on success, -1 if the cache mode was invalid.
840 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
842 *flags
&= ~BDRV_O_CACHE_MASK
;
844 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
845 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
846 } else if (!strcmp(mode
, "directsync")) {
847 *flags
|= BDRV_O_NOCACHE
;
848 } else if (!strcmp(mode
, "writeback")) {
849 *flags
|= BDRV_O_CACHE_WB
;
850 } else if (!strcmp(mode
, "unsafe")) {
851 *flags
|= BDRV_O_CACHE_WB
;
852 *flags
|= BDRV_O_NO_FLUSH
;
853 } else if (!strcmp(mode
, "writethrough")) {
854 /* this is the default */
863 * The copy-on-read flag is actually a reference count so multiple users may
864 * use the feature without worrying about clobbering its previous state.
865 * Copy-on-read stays enabled until all users have called to disable it.
867 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
872 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
874 assert(bs
->copy_on_read
> 0);
879 * Returns the flags that a temporary snapshot should get, based on the
880 * originally requested flags (the originally requested image will have flags
881 * like a backing file)
883 static int bdrv_temp_snapshot_flags(int flags
)
885 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
889 * Returns the flags that bs->file should get, based on the given flags for
892 static int bdrv_inherited_flags(int flags
)
894 /* Enable protocol handling, disable format probing for bs->file */
895 flags
|= BDRV_O_PROTOCOL
;
897 /* Our block drivers take care to send flushes and respect unmap policy,
898 * so we can enable both unconditionally on lower layers. */
899 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
901 /* Clear flags that only apply to the top layer */
902 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
908 * Returns the flags that bs->backing_hd should get, based on the given flags
911 static int bdrv_backing_flags(int flags
)
913 /* backing files always opened read-only */
914 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
916 /* snapshot=on is handled on the top layer */
917 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
922 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
924 int open_flags
= flags
| BDRV_O_CACHE_WB
;
927 * Clear flags that are internal to the block layer before opening the
930 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
933 * Snapshots should be writable.
935 if (flags
& BDRV_O_TEMPORARY
) {
936 open_flags
|= BDRV_O_RDWR
;
942 static void bdrv_assign_node_name(BlockDriverState
*bs
,
943 const char *node_name
,
950 /* Check for empty string or invalid characters */
951 if (!id_wellformed(node_name
)) {
952 error_setg(errp
, "Invalid node name");
956 /* takes care of avoiding namespaces collisions */
957 if (blk_by_name(node_name
)) {
958 error_setg(errp
, "node-name=%s is conflicting with a device id",
963 /* takes care of avoiding duplicates node names */
964 if (bdrv_find_node(node_name
)) {
965 error_setg(errp
, "Duplicate node name");
969 /* copy node name into the bs and insert it into the graph list */
970 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
971 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
975 * Common part for opening disk images and files
977 * Removes all processed options from *options.
979 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
980 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
983 const char *filename
;
984 const char *node_name
= NULL
;
985 Error
*local_err
= NULL
;
988 assert(bs
->file
== NULL
);
989 assert(options
!= NULL
&& bs
->options
!= options
);
992 filename
= file
->filename
;
994 filename
= qdict_get_try_str(options
, "filename");
997 if (drv
->bdrv_needs_filename
&& !filename
) {
998 error_setg(errp
, "The '%s' block driver requires a file name",
1003 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
1005 node_name
= qdict_get_try_str(options
, "node-name");
1006 bdrv_assign_node_name(bs
, node_name
, &local_err
);
1008 error_propagate(errp
, local_err
);
1011 qdict_del(options
, "node-name");
1013 /* bdrv_open() with directly using a protocol as drv. This layer is already
1014 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
1015 * and return immediately. */
1016 if (file
!= NULL
&& drv
->bdrv_file_open
) {
1017 bdrv_swap(file
, bs
);
1021 bs
->open_flags
= flags
;
1022 bs
->guest_block_size
= 512;
1023 bs
->request_alignment
= 512;
1024 bs
->zero_beyond_eof
= true;
1025 open_flags
= bdrv_open_flags(bs
, flags
);
1026 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
1028 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
1030 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
1031 ? "Driver '%s' can only be used for read-only devices"
1032 : "Driver '%s' is not whitelisted",
1037 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
1038 if (flags
& BDRV_O_COPY_ON_READ
) {
1039 if (!bs
->read_only
) {
1040 bdrv_enable_copy_on_read(bs
);
1042 error_setg(errp
, "Can't use copy-on-read on read-only device");
1047 if (filename
!= NULL
) {
1048 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
1050 bs
->filename
[0] = '\0';
1052 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
1055 bs
->opaque
= g_malloc0(drv
->instance_size
);
1057 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
1059 /* Open the image, either directly or using a protocol */
1060 if (drv
->bdrv_file_open
) {
1061 assert(file
== NULL
);
1062 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
1063 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
1066 error_setg(errp
, "Can't use '%s' as a block driver for the "
1067 "protocol level", drv
->format_name
);
1072 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1077 error_propagate(errp
, local_err
);
1078 } else if (bs
->filename
[0]) {
1079 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1081 error_setg_errno(errp
, -ret
, "Could not open image");
1086 if (bs
->encrypted
) {
1087 error_report("Encrypted images are deprecated");
1088 error_printf("Support for them will be removed in a future release.\n"
1089 "You can use 'qemu-img convert' to convert your image"
1090 " to an unencrypted one.\n");
1093 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1095 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1099 bdrv_refresh_limits(bs
, &local_err
);
1101 error_propagate(errp
, local_err
);
1106 assert(bdrv_opt_mem_align(bs
) != 0);
1107 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1118 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1120 QObject
*options_obj
;
1124 ret
= strstart(filename
, "json:", &filename
);
1127 options_obj
= qobject_from_json(filename
);
1129 error_setg(errp
, "Could not parse the JSON options");
1133 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1134 qobject_decref(options_obj
);
1135 error_setg(errp
, "Invalid JSON object given");
1139 options
= qobject_to_qdict(options_obj
);
1140 qdict_flatten(options
);
1146 * Fills in default options for opening images and converts the legacy
1147 * filename/flags pair to option QDict entries.
1149 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
1150 BlockDriver
*drv
, Error
**errp
)
1152 const char *filename
= *pfilename
;
1153 const char *drvname
;
1154 bool protocol
= flags
& BDRV_O_PROTOCOL
;
1155 bool parse_filename
= false;
1156 Error
*local_err
= NULL
;
1158 /* Parse json: pseudo-protocol */
1159 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1160 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1162 error_propagate(errp
, local_err
);
1166 /* Options given in the filename have lower priority than options
1167 * specified directly */
1168 qdict_join(*options
, json_options
, false);
1169 QDECREF(json_options
);
1170 *pfilename
= filename
= NULL
;
1173 /* Fetch the file name from the options QDict if necessary */
1174 if (protocol
&& filename
) {
1175 if (!qdict_haskey(*options
, "filename")) {
1176 qdict_put(*options
, "filename", qstring_from_str(filename
));
1177 parse_filename
= true;
1179 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1185 /* Find the right block driver */
1186 filename
= qdict_get_try_str(*options
, "filename");
1187 drvname
= qdict_get_try_str(*options
, "driver");
1191 error_setg(errp
, "Driver specified twice");
1194 drvname
= drv
->format_name
;
1195 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1197 if (!drvname
&& protocol
) {
1199 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1204 drvname
= drv
->format_name
;
1205 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1207 error_setg(errp
, "Must specify either driver or file");
1210 } else if (drvname
) {
1211 drv
= bdrv_find_format(drvname
);
1213 error_setg(errp
, "Unknown driver '%s'", drvname
);
1219 assert(drv
|| !protocol
);
1221 /* Driver-specific filename parsing */
1222 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1223 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1225 error_propagate(errp
, local_err
);
1229 if (!drv
->bdrv_needs_filename
) {
1230 qdict_del(*options
, "filename");
1237 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1240 if (bs
->backing_hd
) {
1241 assert(bs
->backing_blocker
);
1242 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1243 } else if (backing_hd
) {
1244 error_setg(&bs
->backing_blocker
,
1245 "node is used as backing hd of '%s'",
1246 bdrv_get_device_or_node_name(bs
));
1249 bs
->backing_hd
= backing_hd
;
1251 error_free(bs
->backing_blocker
);
1252 bs
->backing_blocker
= NULL
;
1255 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1256 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1257 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1258 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1260 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1261 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1262 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1263 bs
->backing_blocker
);
1265 bdrv_refresh_limits(bs
, NULL
);
1269 * Opens the backing file for a BlockDriverState if not yet open
1271 * options is a QDict of options to pass to the block drivers, or NULL for an
1272 * empty set of options. The reference to the QDict is transferred to this
1273 * function (even on failure), so if the caller intends to reuse the dictionary,
1274 * it needs to use QINCREF() before calling bdrv_file_open.
1276 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1278 char *backing_filename
= g_malloc0(PATH_MAX
);
1280 BlockDriverState
*backing_hd
;
1281 Error
*local_err
= NULL
;
1283 if (bs
->backing_hd
!= NULL
) {
1288 /* NULL means an empty set of options */
1289 if (options
== NULL
) {
1290 options
= qdict_new();
1293 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1294 if (qdict_haskey(options
, "file.filename")) {
1295 backing_filename
[0] = '\0';
1296 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1300 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1304 error_propagate(errp
, local_err
);
1310 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1312 error_setg(errp
, "Driver doesn't support backing files");
1317 backing_hd
= bdrv_new();
1319 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1320 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1323 assert(bs
->backing_hd
== NULL
);
1324 ret
= bdrv_open(&backing_hd
,
1325 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1326 bdrv_backing_flags(bs
->open_flags
), NULL
, &local_err
);
1328 bdrv_unref(backing_hd
);
1330 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1331 error_setg(errp
, "Could not open backing file: %s",
1332 error_get_pretty(local_err
));
1333 error_free(local_err
);
1336 bdrv_set_backing_hd(bs
, backing_hd
);
1339 g_free(backing_filename
);
1344 * Opens a disk image whose options are given as BlockdevRef in another block
1347 * If allow_none is true, no image will be opened if filename is false and no
1348 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1350 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1351 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1352 * itself, all options starting with "${bdref_key}." are considered part of the
1355 * The BlockdevRef will be removed from the options QDict.
1357 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1359 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1360 QDict
*options
, const char *bdref_key
, int flags
,
1361 bool allow_none
, Error
**errp
)
1363 QDict
*image_options
;
1365 char *bdref_key_dot
;
1366 const char *reference
;
1369 assert(*pbs
== NULL
);
1371 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1372 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1373 g_free(bdref_key_dot
);
1375 reference
= qdict_get_try_str(options
, bdref_key
);
1376 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1380 error_setg(errp
, "A block device must be specified for \"%s\"",
1384 QDECREF(image_options
);
1388 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1391 qdict_del(options
, bdref_key
);
1395 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1397 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1398 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1400 QemuOpts
*opts
= NULL
;
1401 QDict
*snapshot_options
;
1402 BlockDriverState
*bs_snapshot
;
1406 /* if snapshot, we create a temporary backing file and open it
1407 instead of opening 'filename' directly */
1409 /* Get the required size from the image */
1410 total_size
= bdrv_getlength(bs
);
1411 if (total_size
< 0) {
1413 error_setg_errno(errp
, -total_size
, "Could not get image size");
1417 /* Create the temporary image */
1418 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1420 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1424 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1426 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1427 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1428 qemu_opts_del(opts
);
1430 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1431 "'%s': %s", tmp_filename
,
1432 error_get_pretty(local_err
));
1433 error_free(local_err
);
1437 /* Prepare a new options QDict for the temporary file */
1438 snapshot_options
= qdict_new();
1439 qdict_put(snapshot_options
, "file.driver",
1440 qstring_from_str("file"));
1441 qdict_put(snapshot_options
, "file.filename",
1442 qstring_from_str(tmp_filename
));
1444 bs_snapshot
= bdrv_new();
1446 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1447 flags
, &bdrv_qcow2
, &local_err
);
1449 error_propagate(errp
, local_err
);
1453 bdrv_append(bs_snapshot
, bs
);
1456 g_free(tmp_filename
);
1461 * Opens a disk image (raw, qcow2, vmdk, ...)
1463 * options is a QDict of options to pass to the block drivers, or NULL for an
1464 * empty set of options. The reference to the QDict belongs to the block layer
1465 * after the call (even on failure), so if the caller intends to reuse the
1466 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1468 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1469 * If it is not NULL, the referenced BDS will be reused.
1471 * The reference parameter may be used to specify an existing block device which
1472 * should be opened. If specified, neither options nor a filename may be given,
1473 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1475 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1476 const char *reference
, QDict
*options
, int flags
,
1477 BlockDriver
*drv
, Error
**errp
)
1480 BlockDriverState
*file
= NULL
, *bs
;
1481 const char *drvname
;
1482 Error
*local_err
= NULL
;
1483 int snapshot_flags
= 0;
1488 bool options_non_empty
= options
? qdict_size(options
) : false;
1492 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1493 "another block device");
1497 if (filename
|| options_non_empty
) {
1498 error_setg(errp
, "Cannot reference an existing block device with "
1499 "additional options or a new filename");
1503 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1518 /* NULL means an empty set of options */
1519 if (options
== NULL
) {
1520 options
= qdict_new();
1523 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1528 /* Find the right image format driver */
1530 drvname
= qdict_get_try_str(options
, "driver");
1532 drv
= bdrv_find_format(drvname
);
1533 qdict_del(options
, "driver");
1535 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1541 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1542 if (drv
&& !drv
->bdrv_file_open
) {
1543 /* If the user explicitly wants a format driver here, we'll need to add
1544 * another layer for the protocol in bs->file */
1545 flags
&= ~BDRV_O_PROTOCOL
;
1548 bs
->options
= options
;
1549 options
= qdict_clone_shallow(options
);
1551 /* Open image file without format layer */
1552 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1553 if (flags
& BDRV_O_RDWR
) {
1554 flags
|= BDRV_O_ALLOW_RDWR
;
1556 if (flags
& BDRV_O_SNAPSHOT
) {
1557 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1558 flags
= bdrv_backing_flags(flags
);
1561 assert(file
== NULL
);
1562 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1563 bdrv_inherited_flags(flags
),
1570 /* Image format probing */
1573 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1578 error_setg(errp
, "Must specify either driver or file");
1583 /* Open the image */
1584 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1589 if (file
&& (bs
->file
!= file
)) {
1594 /* If there is a backing file, use it */
1595 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1596 QDict
*backing_options
;
1598 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1599 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1601 goto close_and_fail
;
1605 bdrv_refresh_filename(bs
);
1607 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1608 * temporary snapshot afterwards. */
1609 if (snapshot_flags
) {
1610 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1612 goto close_and_fail
;
1616 /* Check if any unknown options were used */
1617 if (options
&& (qdict_size(options
) != 0)) {
1618 const QDictEntry
*entry
= qdict_first(options
);
1619 if (flags
& BDRV_O_PROTOCOL
) {
1620 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1621 "'%s'", drv
->format_name
, entry
->key
);
1623 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1624 "support the option '%s'", drv
->format_name
,
1625 bdrv_get_device_name(bs
), entry
->key
);
1629 goto close_and_fail
;
1632 if (!bdrv_key_required(bs
)) {
1634 blk_dev_change_media_cb(bs
->blk
, true);
1636 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1637 && !runstate_check(RUN_STATE_INMIGRATE
)
1638 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1640 "Guest must be stopped for opening of encrypted image");
1642 goto close_and_fail
;
1653 QDECREF(bs
->options
);
1657 /* If *pbs is NULL, a new BDS has been created in this function and
1658 needs to be freed now. Otherwise, it does not need to be closed,
1659 since it has not really been opened yet. */
1663 error_propagate(errp
, local_err
);
1668 /* See fail path, but now the BDS has to be always closed */
1676 error_propagate(errp
, local_err
);
1681 typedef struct BlockReopenQueueEntry
{
1683 BDRVReopenState state
;
1684 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1685 } BlockReopenQueueEntry
;
1688 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1689 * reopen of multiple devices.
1691 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1692 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1693 * be created and initialized. This newly created BlockReopenQueue should be
1694 * passed back in for subsequent calls that are intended to be of the same
1697 * bs is the BlockDriverState to add to the reopen queue.
1699 * flags contains the open flags for the associated bs
1701 * returns a pointer to bs_queue, which is either the newly allocated
1702 * bs_queue, or the existing bs_queue being used.
1705 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1706 BlockDriverState
*bs
, int flags
)
1710 BlockReopenQueueEntry
*bs_entry
;
1711 if (bs_queue
== NULL
) {
1712 bs_queue
= g_new0(BlockReopenQueue
, 1);
1713 QSIMPLEQ_INIT(bs_queue
);
1716 /* bdrv_open() masks this flag out */
1717 flags
&= ~BDRV_O_PROTOCOL
;
1720 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1723 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1724 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1726 bs_entry
->state
.bs
= bs
;
1727 bs_entry
->state
.flags
= flags
;
1733 * Reopen multiple BlockDriverStates atomically & transactionally.
1735 * The queue passed in (bs_queue) must have been built up previous
1736 * via bdrv_reopen_queue().
1738 * Reopens all BDS specified in the queue, with the appropriate
1739 * flags. All devices are prepared for reopen, and failure of any
1740 * device will cause all device changes to be abandonded, and intermediate
1743 * If all devices prepare successfully, then the changes are committed
1747 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1750 BlockReopenQueueEntry
*bs_entry
, *next
;
1751 Error
*local_err
= NULL
;
1753 assert(bs_queue
!= NULL
);
1757 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1758 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1759 error_propagate(errp
, local_err
);
1762 bs_entry
->prepared
= true;
1765 /* If we reach this point, we have success and just need to apply the
1768 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1769 bdrv_reopen_commit(&bs_entry
->state
);
1775 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1776 if (ret
&& bs_entry
->prepared
) {
1777 bdrv_reopen_abort(&bs_entry
->state
);
1786 /* Reopen a single BlockDriverState with the specified flags. */
1787 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1790 Error
*local_err
= NULL
;
1791 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1793 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1794 if (local_err
!= NULL
) {
1795 error_propagate(errp
, local_err
);
1802 * Prepares a BlockDriverState for reopen. All changes are staged in the
1803 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1804 * the block driver layer .bdrv_reopen_prepare()
1806 * bs is the BlockDriverState to reopen
1807 * flags are the new open flags
1808 * queue is the reopen queue
1810 * Returns 0 on success, non-zero on error. On error errp will be set
1813 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1814 * It is the responsibility of the caller to then call the abort() or
1815 * commit() for any other BDS that have been left in a prepare() state
1818 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1822 Error
*local_err
= NULL
;
1825 assert(reopen_state
!= NULL
);
1826 assert(reopen_state
->bs
->drv
!= NULL
);
1827 drv
= reopen_state
->bs
->drv
;
1829 /* if we are to stay read-only, do not allow permission change
1831 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1832 reopen_state
->flags
& BDRV_O_RDWR
) {
1833 error_setg(errp
, "Node '%s' is read only",
1834 bdrv_get_device_or_node_name(reopen_state
->bs
));
1839 ret
= bdrv_flush(reopen_state
->bs
);
1841 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1846 if (drv
->bdrv_reopen_prepare
) {
1847 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1849 if (local_err
!= NULL
) {
1850 error_propagate(errp
, local_err
);
1852 error_setg(errp
, "failed while preparing to reopen image '%s'",
1853 reopen_state
->bs
->filename
);
1858 /* It is currently mandatory to have a bdrv_reopen_prepare()
1859 * handler for each supported drv. */
1860 error_setg(errp
, "Block format '%s' used by node '%s' "
1861 "does not support reopening files", drv
->format_name
,
1862 bdrv_get_device_or_node_name(reopen_state
->bs
));
1874 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1875 * makes them final by swapping the staging BlockDriverState contents into
1876 * the active BlockDriverState contents.
1878 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1882 assert(reopen_state
!= NULL
);
1883 drv
= reopen_state
->bs
->drv
;
1884 assert(drv
!= NULL
);
1886 /* If there are any driver level actions to take */
1887 if (drv
->bdrv_reopen_commit
) {
1888 drv
->bdrv_reopen_commit(reopen_state
);
1891 /* set BDS specific flags now */
1892 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1893 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1895 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1897 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1901 * Abort the reopen, and delete and free the staged changes in
1904 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1908 assert(reopen_state
!= NULL
);
1909 drv
= reopen_state
->bs
->drv
;
1910 assert(drv
!= NULL
);
1912 if (drv
->bdrv_reopen_abort
) {
1913 drv
->bdrv_reopen_abort(reopen_state
);
1918 void bdrv_close(BlockDriverState
*bs
)
1920 BdrvAioNotifier
*ban
, *ban_next
;
1923 block_job_cancel_sync(bs
->job
);
1925 bdrv_drain_all(); /* complete I/O */
1927 bdrv_drain_all(); /* in case flush left pending I/O */
1928 notifier_list_notify(&bs
->close_notifiers
, bs
);
1931 if (bs
->backing_hd
) {
1932 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1933 bdrv_set_backing_hd(bs
, NULL
);
1934 bdrv_unref(backing_hd
);
1936 bs
->drv
->bdrv_close(bs
);
1940 bs
->copy_on_read
= 0;
1941 bs
->backing_file
[0] = '\0';
1942 bs
->backing_format
[0] = '\0';
1943 bs
->total_sectors
= 0;
1947 bs
->zero_beyond_eof
= false;
1948 QDECREF(bs
->options
);
1950 QDECREF(bs
->full_open_options
);
1951 bs
->full_open_options
= NULL
;
1953 if (bs
->file
!= NULL
) {
1954 bdrv_unref(bs
->file
);
1960 blk_dev_change_media_cb(bs
->blk
, false);
1963 /*throttling disk I/O limits*/
1964 if (bs
->io_limits_enabled
) {
1965 bdrv_io_limits_disable(bs
);
1968 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1971 QLIST_INIT(&bs
->aio_notifiers
);
1974 void bdrv_close_all(void)
1976 BlockDriverState
*bs
;
1978 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1979 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1981 aio_context_acquire(aio_context
);
1983 aio_context_release(aio_context
);
1987 /* Check if any requests are in-flight (including throttled requests) */
1988 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1990 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1993 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1996 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1999 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
2002 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
2008 static bool bdrv_drain_one(BlockDriverState
*bs
)
2012 bdrv_flush_io_queue(bs
);
2013 bdrv_start_throttled_reqs(bs
);
2014 bs_busy
= bdrv_requests_pending(bs
);
2015 bs_busy
|= aio_poll(bdrv_get_aio_context(bs
), bs_busy
);
2020 * Wait for pending requests to complete on a single BlockDriverState subtree
2022 * See the warning in bdrv_drain_all(). This function can only be called if
2023 * you are sure nothing can generate I/O because you have op blockers
2026 * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
2029 void bdrv_drain(BlockDriverState
*bs
)
2031 while (bdrv_drain_one(bs
)) {
2032 /* Keep iterating */
2037 * Wait for pending requests to complete across all BlockDriverStates
2039 * This function does not flush data to disk, use bdrv_flush_all() for that
2040 * after calling this function.
2042 * Note that completion of an asynchronous I/O operation can trigger any
2043 * number of other I/O operations on other devices---for example a coroutine
2044 * can be arbitrarily complex and a constant flow of I/O can come until the
2045 * coroutine is complete. Because of this, it is not possible to have a
2046 * function to drain a single device's I/O queue.
2048 void bdrv_drain_all(void)
2050 /* Always run first iteration so any pending completion BHs run */
2052 BlockDriverState
*bs
;
2054 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2055 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2057 aio_context_acquire(aio_context
);
2059 block_job_pause(bs
->job
);
2061 aio_context_release(aio_context
);
2067 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2068 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2070 aio_context_acquire(aio_context
);
2071 busy
|= bdrv_drain_one(bs
);
2072 aio_context_release(aio_context
);
2076 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2077 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2079 aio_context_acquire(aio_context
);
2081 block_job_resume(bs
->job
);
2083 aio_context_release(aio_context
);
2087 /* make a BlockDriverState anonymous by removing from bdrv_state and
2088 * graph_bdrv_state list.
2089 Also, NULL terminate the device_name to prevent double remove */
2090 void bdrv_make_anon(BlockDriverState
*bs
)
2093 * Take care to remove bs from bdrv_states only when it's actually
2094 * in it. Note that bs->device_list.tqe_prev is initially null,
2095 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2096 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2097 * resetting it to null on remove.
2099 if (bs
->device_list
.tqe_prev
) {
2100 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
2101 bs
->device_list
.tqe_prev
= NULL
;
2103 if (bs
->node_name
[0] != '\0') {
2104 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2106 bs
->node_name
[0] = '\0';
2109 static void bdrv_rebind(BlockDriverState
*bs
)
2111 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
2112 bs
->drv
->bdrv_rebind(bs
);
2116 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2117 BlockDriverState
*bs_src
)
2119 /* move some fields that need to stay attached to the device */
2122 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
2123 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2125 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2127 /* i/o throttled req */
2128 memcpy(&bs_dest
->throttle_state
,
2129 &bs_src
->throttle_state
,
2130 sizeof(ThrottleState
));
2131 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2132 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2133 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
2136 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2137 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2140 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2141 bs_dest
->iostatus
= bs_src
->iostatus
;
2144 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2146 /* reference count */
2147 bs_dest
->refcnt
= bs_src
->refcnt
;
2150 bs_dest
->job
= bs_src
->job
;
2152 /* keep the same entry in bdrv_states */
2153 bs_dest
->device_list
= bs_src
->device_list
;
2154 bs_dest
->blk
= bs_src
->blk
;
2156 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2157 sizeof(bs_dest
->op_blockers
));
2161 * Swap bs contents for two image chains while they are live,
2162 * while keeping required fields on the BlockDriverState that is
2163 * actually attached to a device.
2165 * This will modify the BlockDriverState fields, and swap contents
2166 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2168 * bs_new must not be attached to a BlockBackend.
2170 * This function does not create any image files.
2172 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2174 BlockDriverState tmp
;
2176 /* The code needs to swap the node_name but simply swapping node_list won't
2177 * work so first remove the nodes from the graph list, do the swap then
2178 * insert them back if needed.
2180 if (bs_new
->node_name
[0] != '\0') {
2181 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2183 if (bs_old
->node_name
[0] != '\0') {
2184 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2187 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2188 assert(!bs_new
->blk
);
2189 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2190 assert(bs_new
->job
== NULL
);
2191 assert(bs_new
->io_limits_enabled
== false);
2192 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2198 /* there are some fields that should not be swapped, move them back */
2199 bdrv_move_feature_fields(&tmp
, bs_old
);
2200 bdrv_move_feature_fields(bs_old
, bs_new
);
2201 bdrv_move_feature_fields(bs_new
, &tmp
);
2203 /* bs_new must remain unattached */
2204 assert(!bs_new
->blk
);
2206 /* Check a few fields that should remain attached to the device */
2207 assert(bs_new
->job
== NULL
);
2208 assert(bs_new
->io_limits_enabled
== false);
2209 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2211 /* insert the nodes back into the graph node list if needed */
2212 if (bs_new
->node_name
[0] != '\0') {
2213 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2215 if (bs_old
->node_name
[0] != '\0') {
2216 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2219 bdrv_rebind(bs_new
);
2220 bdrv_rebind(bs_old
);
2224 * Add new bs contents at the top of an image chain while the chain is
2225 * live, while keeping required fields on the top layer.
2227 * This will modify the BlockDriverState fields, and swap contents
2228 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2230 * bs_new must not be attached to a BlockBackend.
2232 * This function does not create any image files.
2234 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2236 bdrv_swap(bs_new
, bs_top
);
2238 /* The contents of 'tmp' will become bs_top, as we are
2239 * swapping bs_new and bs_top contents. */
2240 bdrv_set_backing_hd(bs_top
, bs_new
);
2243 static void bdrv_delete(BlockDriverState
*bs
)
2246 assert(bdrv_op_blocker_is_empty(bs
));
2247 assert(!bs
->refcnt
);
2248 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2252 /* remove from list, if necessary */
2259 * Run consistency checks on an image
2261 * Returns 0 if the check could be completed (it doesn't mean that the image is
2262 * free of errors) or -errno when an internal error occurred. The results of the
2263 * check are stored in res.
2265 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2267 if (bs
->drv
== NULL
) {
2270 if (bs
->drv
->bdrv_check
== NULL
) {
2274 memset(res
, 0, sizeof(*res
));
2275 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2278 #define COMMIT_BUF_SECTORS 2048
2280 /* commit COW file into the raw image */
2281 int bdrv_commit(BlockDriverState
*bs
)
2283 BlockDriver
*drv
= bs
->drv
;
2284 int64_t sector
, total_sectors
, length
, backing_length
;
2285 int n
, ro
, open_flags
;
2287 uint8_t *buf
= NULL
;
2292 if (!bs
->backing_hd
) {
2296 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2297 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2301 ro
= bs
->backing_hd
->read_only
;
2302 open_flags
= bs
->backing_hd
->open_flags
;
2305 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2310 length
= bdrv_getlength(bs
);
2316 backing_length
= bdrv_getlength(bs
->backing_hd
);
2317 if (backing_length
< 0) {
2318 ret
= backing_length
;
2322 /* If our top snapshot is larger than the backing file image,
2323 * grow the backing file image if possible. If not possible,
2324 * we must return an error */
2325 if (length
> backing_length
) {
2326 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2332 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2334 /* qemu_try_blockalign() for bs will choose an alignment that works for
2335 * bs->backing_hd as well, so no need to compare the alignment manually. */
2336 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2342 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2343 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2348 ret
= bdrv_read(bs
, sector
, buf
, n
);
2353 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2360 if (drv
->bdrv_make_empty
) {
2361 ret
= drv
->bdrv_make_empty(bs
);
2369 * Make sure all data we wrote to the backing device is actually
2372 if (bs
->backing_hd
) {
2373 bdrv_flush(bs
->backing_hd
);
2381 /* ignoring error return here */
2382 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2388 int bdrv_commit_all(void)
2390 BlockDriverState
*bs
;
2392 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2393 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2395 aio_context_acquire(aio_context
);
2396 if (bs
->drv
&& bs
->backing_hd
) {
2397 int ret
= bdrv_commit(bs
);
2399 aio_context_release(aio_context
);
2403 aio_context_release(aio_context
);
2409 * Remove an active request from the tracked requests list
2411 * This function should be called when a tracked request is completing.
2413 static void tracked_request_end(BdrvTrackedRequest
*req
)
2415 if (req
->serialising
) {
2416 req
->bs
->serialising_in_flight
--;
2419 QLIST_REMOVE(req
, list
);
2420 qemu_co_queue_restart_all(&req
->wait_queue
);
2424 * Add an active request to the tracked requests list
2426 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2427 BlockDriverState
*bs
,
2429 unsigned int bytes
, bool is_write
)
2431 *req
= (BdrvTrackedRequest
){
2435 .is_write
= is_write
,
2436 .co
= qemu_coroutine_self(),
2437 .serialising
= false,
2438 .overlap_offset
= offset
,
2439 .overlap_bytes
= bytes
,
2442 qemu_co_queue_init(&req
->wait_queue
);
2444 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2447 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2449 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2450 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2453 if (!req
->serialising
) {
2454 req
->bs
->serialising_in_flight
++;
2455 req
->serialising
= true;
2458 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2459 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2463 * Round a region to cluster boundaries
2465 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2466 int64_t sector_num
, int nb_sectors
,
2467 int64_t *cluster_sector_num
,
2468 int *cluster_nb_sectors
)
2470 BlockDriverInfo bdi
;
2472 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2473 *cluster_sector_num
= sector_num
;
2474 *cluster_nb_sectors
= nb_sectors
;
2476 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2477 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2478 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2483 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2485 BlockDriverInfo bdi
;
2488 ret
= bdrv_get_info(bs
, &bdi
);
2489 if (ret
< 0 || bdi
.cluster_size
== 0) {
2490 return bs
->request_alignment
;
2492 return bdi
.cluster_size
;
2496 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2497 int64_t offset
, unsigned int bytes
)
2500 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2504 if (req
->overlap_offset
>= offset
+ bytes
) {
2510 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2512 BlockDriverState
*bs
= self
->bs
;
2513 BdrvTrackedRequest
*req
;
2515 bool waited
= false;
2517 if (!bs
->serialising_in_flight
) {
2523 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2524 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2527 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2528 self
->overlap_bytes
))
2530 /* Hitting this means there was a reentrant request, for
2531 * example, a block driver issuing nested requests. This must
2532 * never happen since it means deadlock.
2534 assert(qemu_coroutine_self() != req
->co
);
2536 /* If the request is already (indirectly) waiting for us, or
2537 * will wait for us as soon as it wakes up, then just go on
2538 * (instead of producing a deadlock in the former case). */
2539 if (!req
->waiting_for
) {
2540 self
->waiting_for
= req
;
2541 qemu_co_queue_wait(&req
->wait_queue
);
2542 self
->waiting_for
= NULL
;
2557 * -EINVAL - backing format specified, but no file
2558 * -ENOSPC - can't update the backing file because no space is left in the
2560 * -ENOTSUP - format driver doesn't support changing the backing file
2562 int bdrv_change_backing_file(BlockDriverState
*bs
,
2563 const char *backing_file
, const char *backing_fmt
)
2565 BlockDriver
*drv
= bs
->drv
;
2568 /* Backing file format doesn't make sense without a backing file */
2569 if (backing_fmt
&& !backing_file
) {
2573 if (drv
->bdrv_change_backing_file
!= NULL
) {
2574 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2580 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2581 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2587 * Finds the image layer in the chain that has 'bs' as its backing file.
2589 * active is the current topmost image.
2591 * Returns NULL if bs is not found in active's image chain,
2592 * or if active == bs.
2594 * Returns the bottommost base image if bs == NULL.
2596 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2597 BlockDriverState
*bs
)
2599 while (active
&& bs
!= active
->backing_hd
) {
2600 active
= active
->backing_hd
;
2606 /* Given a BDS, searches for the base layer. */
2607 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2609 return bdrv_find_overlay(bs
, NULL
);
2612 typedef struct BlkIntermediateStates
{
2613 BlockDriverState
*bs
;
2614 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2615 } BlkIntermediateStates
;
2619 * Drops images above 'base' up to and including 'top', and sets the image
2620 * above 'top' to have base as its backing file.
2622 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2623 * information in 'bs' can be properly updated.
2625 * E.g., this will convert the following chain:
2626 * bottom <- base <- intermediate <- top <- active
2630 * bottom <- base <- active
2632 * It is allowed for bottom==base, in which case it converts:
2634 * base <- intermediate <- top <- active
2640 * If backing_file_str is non-NULL, it will be used when modifying top's
2641 * overlay image metadata.
2644 * if active == top, that is considered an error
2647 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2648 BlockDriverState
*base
, const char *backing_file_str
)
2650 BlockDriverState
*intermediate
;
2651 BlockDriverState
*base_bs
= NULL
;
2652 BlockDriverState
*new_top_bs
= NULL
;
2653 BlkIntermediateStates
*intermediate_state
, *next
;
2656 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2657 QSIMPLEQ_INIT(&states_to_delete
);
2659 if (!top
->drv
|| !base
->drv
) {
2663 new_top_bs
= bdrv_find_overlay(active
, top
);
2665 if (new_top_bs
== NULL
) {
2666 /* we could not find the image above 'top', this is an error */
2670 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2671 * to do, no intermediate images */
2672 if (new_top_bs
->backing_hd
== base
) {
2679 /* now we will go down through the list, and add each BDS we find
2680 * into our deletion queue, until we hit the 'base'
2682 while (intermediate
) {
2683 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2684 intermediate_state
->bs
= intermediate
;
2685 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2687 if (intermediate
->backing_hd
== base
) {
2688 base_bs
= intermediate
->backing_hd
;
2691 intermediate
= intermediate
->backing_hd
;
2693 if (base_bs
== NULL
) {
2694 /* something went wrong, we did not end at the base. safely
2695 * unravel everything, and exit with error */
2699 /* success - we can delete the intermediate states, and link top->base */
2700 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2701 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2702 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2706 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2708 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2709 /* so that bdrv_close() does not recursively close the chain */
2710 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2711 bdrv_unref(intermediate_state
->bs
);
2716 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2717 g_free(intermediate_state
);
2723 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2726 if (size
> BDRV_REQUEST_MAX_SECTORS
<< BDRV_SECTOR_BITS
) {
2730 if (!bdrv_is_inserted(bs
)) {
2741 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2744 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2748 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2749 nb_sectors
* BDRV_SECTOR_SIZE
);
2752 typedef struct RwCo
{
2753 BlockDriverState
*bs
;
2758 BdrvRequestFlags flags
;
2761 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2763 RwCo
*rwco
= opaque
;
2765 if (!rwco
->is_write
) {
2766 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2767 rwco
->qiov
->size
, rwco
->qiov
,
2770 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2771 rwco
->qiov
->size
, rwco
->qiov
,
2777 * Process a vectored synchronous request using coroutines
2779 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2780 QEMUIOVector
*qiov
, bool is_write
,
2781 BdrvRequestFlags flags
)
2788 .is_write
= is_write
,
2794 * In sync call context, when the vcpu is blocked, this throttling timer
2795 * will not fire; so the I/O throttling function has to be disabled here
2796 * if it has been enabled.
2798 if (bs
->io_limits_enabled
) {
2799 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2800 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2801 bdrv_io_limits_disable(bs
);
2804 if (qemu_in_coroutine()) {
2805 /* Fast-path if already in coroutine context */
2806 bdrv_rw_co_entry(&rwco
);
2808 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2810 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2811 qemu_coroutine_enter(co
, &rwco
);
2812 while (rwco
.ret
== NOT_DONE
) {
2813 aio_poll(aio_context
, true);
2820 * Process a synchronous request using coroutines
2822 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2823 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2826 struct iovec iov
= {
2827 .iov_base
= (void *)buf
,
2828 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2831 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2835 qemu_iovec_init_external(&qiov
, &iov
, 1);
2836 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2837 &qiov
, is_write
, flags
);
2840 /* return < 0 if error. See bdrv_write() for the return codes */
2841 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2842 uint8_t *buf
, int nb_sectors
)
2844 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2847 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2848 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2849 uint8_t *buf
, int nb_sectors
)
2854 enabled
= bs
->io_limits_enabled
;
2855 bs
->io_limits_enabled
= false;
2856 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2857 bs
->io_limits_enabled
= enabled
;
2861 /* Return < 0 if error. Important errors are:
2862 -EIO generic I/O error (may happen for all errors)
2863 -ENOMEDIUM No media inserted.
2864 -EINVAL Invalid sector number or nb_sectors
2865 -EACCES Trying to write a read-only device
2867 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2868 const uint8_t *buf
, int nb_sectors
)
2870 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2873 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2874 int nb_sectors
, BdrvRequestFlags flags
)
2876 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2877 BDRV_REQ_ZERO_WRITE
| flags
);
2881 * Completely zero out a block device with the help of bdrv_write_zeroes.
2882 * The operation is sped up by checking the block status and only writing
2883 * zeroes to the device if they currently do not return zeroes. Optional
2884 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2886 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2888 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2890 int64_t target_sectors
, ret
, nb_sectors
, sector_num
= 0;
2893 target_sectors
= bdrv_nb_sectors(bs
);
2894 if (target_sectors
< 0) {
2895 return target_sectors
;
2899 nb_sectors
= MIN(target_sectors
- sector_num
, BDRV_REQUEST_MAX_SECTORS
);
2900 if (nb_sectors
<= 0) {
2903 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2905 error_report("error getting block status at sector %" PRId64
": %s",
2906 sector_num
, strerror(-ret
));
2909 if (ret
& BDRV_BLOCK_ZERO
) {
2913 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2915 error_report("error writing zeroes at sector %" PRId64
": %s",
2916 sector_num
, strerror(-ret
));
2923 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2926 struct iovec iov
= {
2927 .iov_base
= (void *)buf
,
2936 qemu_iovec_init_external(&qiov
, &iov
, 1);
2937 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2945 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2949 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2957 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2958 const void *buf
, int bytes
)
2961 struct iovec iov
= {
2962 .iov_base
= (void *) buf
,
2970 qemu_iovec_init_external(&qiov
, &iov
, 1);
2971 return bdrv_pwritev(bs
, offset
, &qiov
);
2975 * Writes to the file and ensures that no writes are reordered across this
2976 * request (acts as a barrier)
2978 * Returns 0 on success, -errno in error cases.
2980 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2981 const void *buf
, int count
)
2985 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2990 /* No flush needed for cache modes that already do it */
2991 if (bs
->enable_write_cache
) {
2998 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2999 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3001 /* Perform I/O through a temporary buffer so that users who scribble over
3002 * their read buffer while the operation is in progress do not end up
3003 * modifying the image file. This is critical for zero-copy guest I/O
3004 * where anything might happen inside guest memory.
3006 void *bounce_buffer
;
3008 BlockDriver
*drv
= bs
->drv
;
3010 QEMUIOVector bounce_qiov
;
3011 int64_t cluster_sector_num
;
3012 int cluster_nb_sectors
;
3016 /* Cover entire cluster so no additional backing file I/O is required when
3017 * allocating cluster in the image file.
3019 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
3020 &cluster_sector_num
, &cluster_nb_sectors
);
3022 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
3023 cluster_sector_num
, cluster_nb_sectors
);
3025 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
3026 iov
.iov_base
= bounce_buffer
= qemu_try_blockalign(bs
, iov
.iov_len
);
3027 if (bounce_buffer
== NULL
) {
3032 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
3034 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
3040 if (drv
->bdrv_co_write_zeroes
&&
3041 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
3042 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
3043 cluster_nb_sectors
, 0);
3045 /* This does not change the data on the disk, it is not necessary
3046 * to flush even in cache=writethrough mode.
3048 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
3053 /* It might be okay to ignore write errors for guest requests. If this
3054 * is a deliberate copy-on-read then we don't want to ignore the error.
3055 * Simply report it in all cases.
3060 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
3061 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
3062 nb_sectors
* BDRV_SECTOR_SIZE
);
3065 qemu_vfree(bounce_buffer
);
3070 * Forwards an already correctly aligned request to the BlockDriver. This
3071 * handles copy on read and zeroing after EOF; any other features must be
3072 * implemented by the caller.
3074 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
3075 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3076 int64_t align
, QEMUIOVector
*qiov
, int flags
)
3078 BlockDriver
*drv
= bs
->drv
;
3081 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3082 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3084 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3085 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3086 assert(!qiov
|| bytes
== qiov
->size
);
3088 /* Handle Copy on Read and associated serialisation */
3089 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3090 /* If we touch the same cluster it counts as an overlap. This
3091 * guarantees that allocating writes will be serialized and not race
3092 * with each other for the same cluster. For example, in copy-on-read
3093 * it ensures that the CoR read and write operations are atomic and
3094 * guest writes cannot interleave between them. */
3095 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3098 wait_serialising_requests(req
);
3100 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3103 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3108 if (!ret
|| pnum
!= nb_sectors
) {
3109 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3114 /* Forward the request to the BlockDriver */
3115 if (!bs
->zero_beyond_eof
) {
3116 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3118 /* Read zeros after EOF */
3119 int64_t total_sectors
, max_nb_sectors
;
3121 total_sectors
= bdrv_nb_sectors(bs
);
3122 if (total_sectors
< 0) {
3123 ret
= total_sectors
;
3127 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3128 align
>> BDRV_SECTOR_BITS
);
3129 if (nb_sectors
< max_nb_sectors
) {
3130 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3131 } else if (max_nb_sectors
> 0) {
3132 QEMUIOVector local_qiov
;
3134 qemu_iovec_init(&local_qiov
, qiov
->niov
);
3135 qemu_iovec_concat(&local_qiov
, qiov
, 0,
3136 max_nb_sectors
* BDRV_SECTOR_SIZE
);
3138 ret
= drv
->bdrv_co_readv(bs
, sector_num
, max_nb_sectors
,
3141 qemu_iovec_destroy(&local_qiov
);
3146 /* Reading beyond end of file is supposed to produce zeroes */
3147 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3148 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3149 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3151 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3159 static inline uint64_t bdrv_get_align(BlockDriverState
*bs
)
3161 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3162 return MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3165 static inline bool bdrv_req_is_aligned(BlockDriverState
*bs
,
3166 int64_t offset
, size_t bytes
)
3168 int64_t align
= bdrv_get_align(bs
);
3169 return !(offset
& (align
- 1) || (bytes
& (align
- 1)));
3173 * Handle a read request in coroutine context
3175 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3176 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3177 BdrvRequestFlags flags
)
3179 BlockDriver
*drv
= bs
->drv
;
3180 BdrvTrackedRequest req
;
3182 uint64_t align
= bdrv_get_align(bs
);
3183 uint8_t *head_buf
= NULL
;
3184 uint8_t *tail_buf
= NULL
;
3185 QEMUIOVector local_qiov
;
3186 bool use_local_qiov
= false;
3193 ret
= bdrv_check_byte_request(bs
, offset
, bytes
);
3198 if (bs
->copy_on_read
) {
3199 flags
|= BDRV_REQ_COPY_ON_READ
;
3202 /* throttling disk I/O */
3203 if (bs
->io_limits_enabled
) {
3204 bdrv_io_limits_intercept(bs
, bytes
, false);
3207 /* Align read if necessary by padding qiov */
3208 if (offset
& (align
- 1)) {
3209 head_buf
= qemu_blockalign(bs
, align
);
3210 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3211 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3212 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3213 use_local_qiov
= true;
3215 bytes
+= offset
& (align
- 1);
3216 offset
= offset
& ~(align
- 1);
3219 if ((offset
+ bytes
) & (align
- 1)) {
3220 if (!use_local_qiov
) {
3221 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3222 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3223 use_local_qiov
= true;
3225 tail_buf
= qemu_blockalign(bs
, align
);
3226 qemu_iovec_add(&local_qiov
, tail_buf
,
3227 align
- ((offset
+ bytes
) & (align
- 1)));
3229 bytes
= ROUND_UP(bytes
, align
);
3232 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3233 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3234 use_local_qiov
? &local_qiov
: qiov
,
3236 tracked_request_end(&req
);
3238 if (use_local_qiov
) {
3239 qemu_iovec_destroy(&local_qiov
);
3240 qemu_vfree(head_buf
);
3241 qemu_vfree(tail_buf
);
3247 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3248 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3249 BdrvRequestFlags flags
)
3251 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3255 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3256 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3259 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3260 int nb_sectors
, QEMUIOVector
*qiov
)
3262 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3264 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3267 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3268 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3270 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3272 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3273 BDRV_REQ_COPY_ON_READ
);
3276 #define MAX_WRITE_ZEROES_BOUNCE_BUFFER 32768
3278 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3279 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3281 BlockDriver
*drv
= bs
->drv
;
3283 struct iovec iov
= {0};
3286 int max_write_zeroes
= MIN_NON_ZERO(bs
->bl
.max_write_zeroes
,
3287 BDRV_REQUEST_MAX_SECTORS
);
3289 while (nb_sectors
> 0 && !ret
) {
3290 int num
= nb_sectors
;
3292 /* Align request. Block drivers can expect the "bulk" of the request
3295 if (bs
->bl
.write_zeroes_alignment
3296 && num
> bs
->bl
.write_zeroes_alignment
) {
3297 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3298 /* Make a small request up to the first aligned sector. */
3299 num
= bs
->bl
.write_zeroes_alignment
;
3300 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3301 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3302 /* Shorten the request to the last aligned sector. num cannot
3303 * underflow because num > bs->bl.write_zeroes_alignment.
3305 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3309 /* limit request size */
3310 if (num
> max_write_zeroes
) {
3311 num
= max_write_zeroes
;
3315 /* First try the efficient write zeroes operation */
3316 if (drv
->bdrv_co_write_zeroes
) {
3317 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3320 if (ret
== -ENOTSUP
) {
3321 /* Fall back to bounce buffer if write zeroes is unsupported */
3322 int max_xfer_len
= MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
3323 MAX_WRITE_ZEROES_BOUNCE_BUFFER
);
3324 num
= MIN(num
, max_xfer_len
);
3325 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3326 if (iov
.iov_base
== NULL
) {
3327 iov
.iov_base
= qemu_try_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3328 if (iov
.iov_base
== NULL
) {
3332 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3334 qemu_iovec_init_external(&qiov
, &iov
, 1);
3336 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3338 /* Keep bounce buffer around if it is big enough for all
3339 * all future requests.
3341 if (num
< max_xfer_len
) {
3342 qemu_vfree(iov
.iov_base
);
3343 iov
.iov_base
= NULL
;
3352 qemu_vfree(iov
.iov_base
);
3357 * Forwards an already correctly aligned write request to the BlockDriver.
3359 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3360 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3361 QEMUIOVector
*qiov
, int flags
)
3363 BlockDriver
*drv
= bs
->drv
;
3367 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3368 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3370 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3371 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3372 assert(!qiov
|| bytes
== qiov
->size
);
3374 waited
= wait_serialising_requests(req
);
3375 assert(!waited
|| !req
->serialising
);
3376 assert(req
->overlap_offset
<= offset
);
3377 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3379 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3381 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3382 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3383 qemu_iovec_is_zero(qiov
)) {
3384 flags
|= BDRV_REQ_ZERO_WRITE
;
3385 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3386 flags
|= BDRV_REQ_MAY_UNMAP
;
3391 /* Do nothing, write notifier decided to fail this request */
3392 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3393 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3394 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3396 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3397 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3399 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3401 if (ret
== 0 && !bs
->enable_write_cache
) {
3402 ret
= bdrv_co_flush(bs
);
3405 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3407 block_acct_highest_sector(&bs
->stats
, sector_num
, nb_sectors
);
3410 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3417 * Handle a write request in coroutine context
3419 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3420 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3421 BdrvRequestFlags flags
)
3423 BdrvTrackedRequest req
;
3424 uint64_t align
= bdrv_get_align(bs
);
3425 uint8_t *head_buf
= NULL
;
3426 uint8_t *tail_buf
= NULL
;
3427 QEMUIOVector local_qiov
;
3428 bool use_local_qiov
= false;
3434 if (bs
->read_only
) {
3438 ret
= bdrv_check_byte_request(bs
, offset
, bytes
);
3443 /* throttling disk I/O */
3444 if (bs
->io_limits_enabled
) {
3445 bdrv_io_limits_intercept(bs
, bytes
, true);
3449 * Align write if necessary by performing a read-modify-write cycle.
3450 * Pad qiov with the read parts and be sure to have a tracked request not
3451 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3453 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3455 if (offset
& (align
- 1)) {
3456 QEMUIOVector head_qiov
;
3457 struct iovec head_iov
;
3459 mark_request_serialising(&req
, align
);
3460 wait_serialising_requests(&req
);
3462 head_buf
= qemu_blockalign(bs
, align
);
3463 head_iov
= (struct iovec
) {
3464 .iov_base
= head_buf
,
3467 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3469 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3470 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3471 align
, &head_qiov
, 0);
3475 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3477 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3478 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3479 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3480 use_local_qiov
= true;
3482 bytes
+= offset
& (align
- 1);
3483 offset
= offset
& ~(align
- 1);
3486 if ((offset
+ bytes
) & (align
- 1)) {
3487 QEMUIOVector tail_qiov
;
3488 struct iovec tail_iov
;
3492 mark_request_serialising(&req
, align
);
3493 waited
= wait_serialising_requests(&req
);
3494 assert(!waited
|| !use_local_qiov
);
3496 tail_buf
= qemu_blockalign(bs
, align
);
3497 tail_iov
= (struct iovec
) {
3498 .iov_base
= tail_buf
,
3501 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3503 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3504 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3505 align
, &tail_qiov
, 0);
3509 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3511 if (!use_local_qiov
) {
3512 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3513 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3514 use_local_qiov
= true;
3517 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3518 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3520 bytes
= ROUND_UP(bytes
, align
);
3523 if (use_local_qiov
) {
3524 /* Local buffer may have non-zero data. */
3525 flags
&= ~BDRV_REQ_ZERO_WRITE
;
3527 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3528 use_local_qiov
? &local_qiov
: qiov
,
3532 tracked_request_end(&req
);
3534 if (use_local_qiov
) {
3535 qemu_iovec_destroy(&local_qiov
);
3537 qemu_vfree(head_buf
);
3538 qemu_vfree(tail_buf
);
3543 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3544 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3545 BdrvRequestFlags flags
)
3547 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3551 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3552 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3555 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3556 int nb_sectors
, QEMUIOVector
*qiov
)
3558 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3560 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3563 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3564 int64_t sector_num
, int nb_sectors
,
3565 BdrvRequestFlags flags
)
3569 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3571 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3572 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3574 if (bdrv_req_is_aligned(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3575 nb_sectors
<< BDRV_SECTOR_BITS
)) {
3576 ret
= bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3577 BDRV_REQ_ZERO_WRITE
| flags
);
3580 QEMUIOVector local_qiov
;
3581 size_t bytes
= nb_sectors
<< BDRV_SECTOR_BITS
;
3583 buf
= qemu_memalign(bdrv_opt_mem_align(bs
), bytes
);
3584 memset(buf
, 0, bytes
);
3585 qemu_iovec_init(&local_qiov
, 1);
3586 qemu_iovec_add(&local_qiov
, buf
, bytes
);
3588 ret
= bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, &local_qiov
,
3589 BDRV_REQ_ZERO_WRITE
| flags
);
3596 * Truncate file to 'offset' bytes (needed only for file protocols)
3598 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3600 BlockDriver
*drv
= bs
->drv
;
3604 if (!drv
->bdrv_truncate
)
3609 ret
= drv
->bdrv_truncate(bs
, offset
);
3611 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3613 blk_dev_resize_cb(bs
->blk
);
3620 * Length of a allocated file in bytes. Sparse files are counted by actual
3621 * allocated space. Return < 0 if error or unknown.
3623 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3625 BlockDriver
*drv
= bs
->drv
;
3629 if (drv
->bdrv_get_allocated_file_size
) {
3630 return drv
->bdrv_get_allocated_file_size(bs
);
3633 return bdrv_get_allocated_file_size(bs
->file
);
3639 * Return number of sectors on success, -errno on error.
3641 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
3643 BlockDriver
*drv
= bs
->drv
;
3648 if (drv
->has_variable_length
) {
3649 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3654 return bs
->total_sectors
;
3658 * Return length in bytes on success, -errno on error.
3659 * The length is always a multiple of BDRV_SECTOR_SIZE.
3661 int64_t bdrv_getlength(BlockDriverState
*bs
)
3663 int64_t ret
= bdrv_nb_sectors(bs
);
3665 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
3668 /* return 0 as number of sectors if no device present or error */
3669 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3671 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
3673 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
3676 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3677 BlockdevOnError on_write_error
)
3679 bs
->on_read_error
= on_read_error
;
3680 bs
->on_write_error
= on_write_error
;
3683 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3685 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3688 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3690 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3693 case BLOCKDEV_ON_ERROR_ENOSPC
:
3694 return (error
== ENOSPC
) ?
3695 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
3696 case BLOCKDEV_ON_ERROR_STOP
:
3697 return BLOCK_ERROR_ACTION_STOP
;
3698 case BLOCKDEV_ON_ERROR_REPORT
:
3699 return BLOCK_ERROR_ACTION_REPORT
;
3700 case BLOCKDEV_ON_ERROR_IGNORE
:
3701 return BLOCK_ERROR_ACTION_IGNORE
;
3707 static void send_qmp_error_event(BlockDriverState
*bs
,
3708 BlockErrorAction action
,
3709 bool is_read
, int error
)
3711 IoOperationType optype
;
3713 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
3714 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
3715 bdrv_iostatus_is_enabled(bs
),
3716 error
== ENOSPC
, strerror(error
),
3720 /* This is done by device models because, while the block layer knows
3721 * about the error, it does not know whether an operation comes from
3722 * the device or the block layer (from a job, for example).
3724 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3725 bool is_read
, int error
)
3729 if (action
== BLOCK_ERROR_ACTION_STOP
) {
3730 /* First set the iostatus, so that "info block" returns an iostatus
3731 * that matches the events raised so far (an additional error iostatus
3732 * is fine, but not a lost one).
3734 bdrv_iostatus_set_err(bs
, error
);
3736 /* Then raise the request to stop the VM and the event.
3737 * qemu_system_vmstop_request_prepare has two effects. First,
3738 * it ensures that the STOP event always comes after the
3739 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3740 * can observe the STOP event and do a "cont" before the STOP
3741 * event is issued, the VM will not stop. In this case, vm_start()
3742 * also ensures that the STOP/RESUME pair of events is emitted.
3744 qemu_system_vmstop_request_prepare();
3745 send_qmp_error_event(bs
, action
, is_read
, error
);
3746 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
3748 send_qmp_error_event(bs
, action
, is_read
, error
);
3752 int bdrv_is_read_only(BlockDriverState
*bs
)
3754 return bs
->read_only
;
3757 int bdrv_is_sg(BlockDriverState
*bs
)
3762 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3764 return bs
->enable_write_cache
;
3767 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3769 bs
->enable_write_cache
= wce
;
3771 /* so a reopen() will preserve wce */
3773 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3775 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3779 int bdrv_is_encrypted(BlockDriverState
*bs
)
3781 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3783 return bs
->encrypted
;
3786 int bdrv_key_required(BlockDriverState
*bs
)
3788 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3790 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3792 return (bs
->encrypted
&& !bs
->valid_key
);
3795 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3798 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3799 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3805 if (!bs
->encrypted
) {
3807 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3810 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3813 } else if (!bs
->valid_key
) {
3816 /* call the change callback now, we skipped it on open */
3817 blk_dev_change_media_cb(bs
->blk
, true);
3824 * Provide an encryption key for @bs.
3825 * If @key is non-null:
3826 * If @bs is not encrypted, fail.
3827 * Else if the key is invalid, fail.
3828 * Else set @bs's key to @key, replacing the existing key, if any.
3830 * If @bs is encrypted and still lacks a key, fail.
3832 * On failure, store an error object through @errp if non-null.
3834 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
3837 if (!bdrv_is_encrypted(bs
)) {
3838 error_setg(errp
, "Node '%s' is not encrypted",
3839 bdrv_get_device_or_node_name(bs
));
3840 } else if (bdrv_set_key(bs
, key
) < 0) {
3841 error_set(errp
, QERR_INVALID_PASSWORD
);
3844 if (bdrv_key_required(bs
)) {
3845 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
3846 "'%s' (%s) is encrypted",
3847 bdrv_get_device_or_node_name(bs
),
3848 bdrv_get_encrypted_filename(bs
));
3853 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3855 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3858 static int qsort_strcmp(const void *a
, const void *b
)
3860 return strcmp(a
, b
);
3863 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3869 const char **formats
= NULL
;
3871 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3872 if (drv
->format_name
) {
3875 while (formats
&& i
&& !found
) {
3876 found
= !strcmp(formats
[--i
], drv
->format_name
);
3880 formats
= g_renew(const char *, formats
, count
+ 1);
3881 formats
[count
++] = drv
->format_name
;
3886 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
3888 for (i
= 0; i
< count
; i
++) {
3889 it(opaque
, formats
[i
]);
3895 /* This function is to find a node in the bs graph */
3896 BlockDriverState
*bdrv_find_node(const char *node_name
)
3898 BlockDriverState
*bs
;
3902 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3903 if (!strcmp(node_name
, bs
->node_name
)) {
3910 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3911 BlockDeviceInfoList
*bdrv_named_nodes_list(Error
**errp
)
3913 BlockDeviceInfoList
*list
, *entry
;
3914 BlockDriverState
*bs
;
3917 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3918 BlockDeviceInfo
*info
= bdrv_block_device_info(bs
, errp
);
3920 qapi_free_BlockDeviceInfoList(list
);
3923 entry
= g_malloc0(sizeof(*entry
));
3924 entry
->value
= info
;
3932 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3933 const char *node_name
,
3937 BlockDriverState
*bs
;
3940 blk
= blk_by_name(device
);
3948 bs
= bdrv_find_node(node_name
);
3955 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3956 device
? device
: "",
3957 node_name
? node_name
: "");
3961 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3962 * return false. If either argument is NULL, return false. */
3963 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
3965 while (top
&& top
!= base
) {
3966 top
= top
->backing_hd
;
3972 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
3975 return QTAILQ_FIRST(&graph_bdrv_states
);
3977 return QTAILQ_NEXT(bs
, node_list
);
3980 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3983 return QTAILQ_FIRST(&bdrv_states
);
3985 return QTAILQ_NEXT(bs
, device_list
);
3988 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
3990 return bs
->node_name
;
3993 /* TODO check what callers really want: bs->node_name or blk_name() */
3994 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
3996 return bs
->blk
? blk_name(bs
->blk
) : "";
3999 /* This can be used to identify nodes that might not have a device
4000 * name associated. Since node and device names live in the same
4001 * namespace, the result is unambiguous. The exception is if both are
4002 * absent, then this returns an empty (non-null) string. */
4003 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
4005 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
4008 int bdrv_get_flags(BlockDriverState
*bs
)
4010 return bs
->open_flags
;
4013 int bdrv_flush_all(void)
4015 BlockDriverState
*bs
;
4018 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4019 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4022 aio_context_acquire(aio_context
);
4023 ret
= bdrv_flush(bs
);
4024 if (ret
< 0 && !result
) {
4027 aio_context_release(aio_context
);
4033 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
4038 int bdrv_has_zero_init(BlockDriverState
*bs
)
4042 /* If BS is a copy on write image, it is initialized to
4043 the contents of the base image, which may not be zeroes. */
4044 if (bs
->backing_hd
) {
4047 if (bs
->drv
->bdrv_has_zero_init
) {
4048 return bs
->drv
->bdrv_has_zero_init(bs
);
4055 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
4057 BlockDriverInfo bdi
;
4059 if (bs
->backing_hd
) {
4063 if (bdrv_get_info(bs
, &bdi
) == 0) {
4064 return bdi
.unallocated_blocks_are_zero
;
4070 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
4072 BlockDriverInfo bdi
;
4074 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
4078 if (bdrv_get_info(bs
, &bdi
) == 0) {
4079 return bdi
.can_write_zeroes_with_unmap
;
4085 typedef struct BdrvCoGetBlockStatusData
{
4086 BlockDriverState
*bs
;
4087 BlockDriverState
*base
;
4093 } BdrvCoGetBlockStatusData
;
4096 * Returns the allocation status of the specified sectors.
4097 * Drivers not implementing the functionality are assumed to not support
4098 * backing files, hence all their sectors are reported as allocated.
4100 * If 'sector_num' is beyond the end of the disk image the return value is 0
4101 * and 'pnum' is set to 0.
4103 * 'pnum' is set to the number of sectors (including and immediately following
4104 * the specified sector) that are known to be in the same
4105 * allocated/unallocated state.
4107 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
4108 * beyond the end of the disk image it will be clamped.
4110 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
4112 int nb_sectors
, int *pnum
)
4114 int64_t total_sectors
;
4118 total_sectors
= bdrv_nb_sectors(bs
);
4119 if (total_sectors
< 0) {
4120 return total_sectors
;
4123 if (sector_num
>= total_sectors
) {
4128 n
= total_sectors
- sector_num
;
4129 if (n
< nb_sectors
) {
4133 if (!bs
->drv
->bdrv_co_get_block_status
) {
4135 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
;
4136 if (bs
->drv
->protocol_name
) {
4137 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
4142 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4148 if (ret
& BDRV_BLOCK_RAW
) {
4149 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
4150 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4154 if (ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ZERO
)) {
4155 ret
|= BDRV_BLOCK_ALLOCATED
;
4158 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
4159 if (bdrv_unallocated_blocks_are_zero(bs
)) {
4160 ret
|= BDRV_BLOCK_ZERO
;
4161 } else if (bs
->backing_hd
) {
4162 BlockDriverState
*bs2
= bs
->backing_hd
;
4163 int64_t nb_sectors2
= bdrv_nb_sectors(bs2
);
4164 if (nb_sectors2
>= 0 && sector_num
>= nb_sectors2
) {
4165 ret
|= BDRV_BLOCK_ZERO
;
4171 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
4172 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
4175 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4178 /* Ignore errors. This is just providing extra information, it
4179 * is useful but not necessary.
4182 /* !file_pnum indicates an offset at or beyond the EOF; it is
4183 * perfectly valid for the format block driver to point to such
4184 * offsets, so catch it and mark everything as zero */
4185 ret
|= BDRV_BLOCK_ZERO
;
4187 /* Limit request to the range reported by the protocol driver */
4189 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
4197 /* Coroutine wrapper for bdrv_get_block_status() */
4198 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
4200 BdrvCoGetBlockStatusData
*data
= opaque
;
4201 BlockDriverState
*bs
= data
->bs
;
4203 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
4209 * Synchronous wrapper around bdrv_co_get_block_status().
4211 * See bdrv_co_get_block_status() for details.
4213 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
4214 int nb_sectors
, int *pnum
)
4217 BdrvCoGetBlockStatusData data
= {
4219 .sector_num
= sector_num
,
4220 .nb_sectors
= nb_sectors
,
4225 if (qemu_in_coroutine()) {
4226 /* Fast-path if already in coroutine context */
4227 bdrv_get_block_status_co_entry(&data
);
4229 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4231 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
4232 qemu_coroutine_enter(co
, &data
);
4233 while (!data
.done
) {
4234 aio_poll(aio_context
, true);
4240 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
4241 int nb_sectors
, int *pnum
)
4243 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4247 return !!(ret
& BDRV_BLOCK_ALLOCATED
);
4251 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4253 * Return true if the given sector is allocated in any image between
4254 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4255 * sector is allocated in any image of the chain. Return false otherwise.
4257 * 'pnum' is set to the number of sectors (including and immediately following
4258 * the specified sector) that are known to be in the same
4259 * allocated/unallocated state.
4262 int bdrv_is_allocated_above(BlockDriverState
*top
,
4263 BlockDriverState
*base
,
4265 int nb_sectors
, int *pnum
)
4267 BlockDriverState
*intermediate
;
4268 int ret
, n
= nb_sectors
;
4271 while (intermediate
&& intermediate
!= base
) {
4273 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
4283 * [sector_num, nb_sectors] is unallocated on top but intermediate
4286 * [sector_num+x, nr_sectors] allocated.
4288 if (n
> pnum_inter
&&
4289 (intermediate
== top
||
4290 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
4294 intermediate
= intermediate
->backing_hd
;
4301 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
4303 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
4304 return bs
->backing_file
;
4305 else if (bs
->encrypted
)
4306 return bs
->filename
;
4311 void bdrv_get_backing_filename(BlockDriverState
*bs
,
4312 char *filename
, int filename_size
)
4314 pstrcpy(filename
, filename_size
, bs
->backing_file
);
4317 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
4318 const uint8_t *buf
, int nb_sectors
)
4320 BlockDriver
*drv
= bs
->drv
;
4326 if (!drv
->bdrv_write_compressed
) {
4329 ret
= bdrv_check_request(bs
, sector_num
, nb_sectors
);
4334 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
4336 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
4339 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4341 BlockDriver
*drv
= bs
->drv
;
4344 if (!drv
->bdrv_get_info
)
4346 memset(bdi
, 0, sizeof(*bdi
));
4347 return drv
->bdrv_get_info(bs
, bdi
);
4350 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
4352 BlockDriver
*drv
= bs
->drv
;
4353 if (drv
&& drv
->bdrv_get_specific_info
) {
4354 return drv
->bdrv_get_specific_info(bs
);
4359 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4360 int64_t pos
, int size
)
4363 struct iovec iov
= {
4364 .iov_base
= (void *) buf
,
4368 qemu_iovec_init_external(&qiov
, &iov
, 1);
4369 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4372 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4374 BlockDriver
*drv
= bs
->drv
;
4378 } else if (drv
->bdrv_save_vmstate
) {
4379 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4380 } else if (bs
->file
) {
4381 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4387 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4388 int64_t pos
, int size
)
4390 BlockDriver
*drv
= bs
->drv
;
4393 if (drv
->bdrv_load_vmstate
)
4394 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4396 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4400 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4402 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4406 bs
->drv
->bdrv_debug_event(bs
, event
);
4409 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4412 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4416 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4417 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4423 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4425 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4429 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4430 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4436 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4438 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
4442 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4443 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4449 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4451 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4455 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4456 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4462 int bdrv_is_snapshot(BlockDriverState
*bs
)
4464 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4467 /* backing_file can either be relative, or absolute, or a protocol. If it is
4468 * relative, it must be relative to the chain. So, passing in bs->filename
4469 * from a BDS as backing_file should not be done, as that may be relative to
4470 * the CWD rather than the chain. */
4471 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4472 const char *backing_file
)
4474 char *filename_full
= NULL
;
4475 char *backing_file_full
= NULL
;
4476 char *filename_tmp
= NULL
;
4477 int is_protocol
= 0;
4478 BlockDriverState
*curr_bs
= NULL
;
4479 BlockDriverState
*retval
= NULL
;
4481 if (!bs
|| !bs
->drv
|| !backing_file
) {
4485 filename_full
= g_malloc(PATH_MAX
);
4486 backing_file_full
= g_malloc(PATH_MAX
);
4487 filename_tmp
= g_malloc(PATH_MAX
);
4489 is_protocol
= path_has_protocol(backing_file
);
4491 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4493 /* If either of the filename paths is actually a protocol, then
4494 * compare unmodified paths; otherwise make paths relative */
4495 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4496 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4497 retval
= curr_bs
->backing_hd
;
4501 /* If not an absolute filename path, make it relative to the current
4502 * image's filename path */
4503 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4506 /* We are going to compare absolute pathnames */
4507 if (!realpath(filename_tmp
, filename_full
)) {
4511 /* We need to make sure the backing filename we are comparing against
4512 * is relative to the current image filename (or absolute) */
4513 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4514 curr_bs
->backing_file
);
4516 if (!realpath(filename_tmp
, backing_file_full
)) {
4520 if (strcmp(backing_file_full
, filename_full
) == 0) {
4521 retval
= curr_bs
->backing_hd
;
4527 g_free(filename_full
);
4528 g_free(backing_file_full
);
4529 g_free(filename_tmp
);
4533 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4539 if (!bs
->backing_hd
) {
4543 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4546 /**************************************************************/
4549 BlockAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4550 QEMUIOVector
*qiov
, int nb_sectors
,
4551 BlockCompletionFunc
*cb
, void *opaque
)
4553 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4555 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4559 BlockAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4560 QEMUIOVector
*qiov
, int nb_sectors
,
4561 BlockCompletionFunc
*cb
, void *opaque
)
4563 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4565 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4569 BlockAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4570 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4571 BlockCompletionFunc
*cb
, void *opaque
)
4573 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4575 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4576 BDRV_REQ_ZERO_WRITE
| flags
,
4581 typedef struct MultiwriteCB
{
4586 BlockCompletionFunc
*cb
;
4588 QEMUIOVector
*free_qiov
;
4592 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4596 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4597 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4598 if (mcb
->callbacks
[i
].free_qiov
) {
4599 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4601 g_free(mcb
->callbacks
[i
].free_qiov
);
4605 static void multiwrite_cb(void *opaque
, int ret
)
4607 MultiwriteCB
*mcb
= opaque
;
4609 trace_multiwrite_cb(mcb
, ret
);
4611 if (ret
< 0 && !mcb
->error
) {
4615 mcb
->num_requests
--;
4616 if (mcb
->num_requests
== 0) {
4617 multiwrite_user_cb(mcb
);
4622 static int multiwrite_req_compare(const void *a
, const void *b
)
4624 const BlockRequest
*req1
= a
, *req2
= b
;
4627 * Note that we can't simply subtract req2->sector from req1->sector
4628 * here as that could overflow the return value.
4630 if (req1
->sector
> req2
->sector
) {
4632 } else if (req1
->sector
< req2
->sector
) {
4640 * Takes a bunch of requests and tries to merge them. Returns the number of
4641 * requests that remain after merging.
4643 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4644 int num_reqs
, MultiwriteCB
*mcb
)
4648 // Sort requests by start sector
4649 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4651 // Check if adjacent requests touch the same clusters. If so, combine them,
4652 // filling up gaps with zero sectors.
4654 for (i
= 1; i
< num_reqs
; i
++) {
4656 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4658 // Handle exactly sequential writes and overlapping writes.
4659 if (reqs
[i
].sector
<= oldreq_last
) {
4663 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4667 if (bs
->bl
.max_transfer_length
&& reqs
[outidx
].nb_sectors
+
4668 reqs
[i
].nb_sectors
> bs
->bl
.max_transfer_length
) {
4674 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4675 qemu_iovec_init(qiov
,
4676 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4678 // Add the first request to the merged one. If the requests are
4679 // overlapping, drop the last sectors of the first request.
4680 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4681 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4683 // We should need to add any zeros between the two requests
4684 assert (reqs
[i
].sector
<= oldreq_last
);
4686 // Add the second request
4687 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4689 // Add tail of first request, if necessary
4690 if (qiov
->size
< reqs
[outidx
].qiov
->size
) {
4691 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, qiov
->size
,
4692 reqs
[outidx
].qiov
->size
- qiov
->size
);
4695 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4696 reqs
[outidx
].qiov
= qiov
;
4698 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4701 reqs
[outidx
].sector
= reqs
[i
].sector
;
4702 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4703 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4707 block_acct_merge_done(&bs
->stats
, BLOCK_ACCT_WRITE
, num_reqs
- outidx
- 1);
4713 * Submit multiple AIO write requests at once.
4715 * On success, the function returns 0 and all requests in the reqs array have
4716 * been submitted. In error case this function returns -1, and any of the
4717 * requests may or may not be submitted yet. In particular, this means that the
4718 * callback will be called for some of the requests, for others it won't. The
4719 * caller must check the error field of the BlockRequest to wait for the right
4720 * callbacks (if error != 0, no callback will be called).
4722 * The implementation may modify the contents of the reqs array, e.g. to merge
4723 * requests. However, the fields opaque and error are left unmodified as they
4724 * are used to signal failure for a single request to the caller.
4726 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4731 /* don't submit writes if we don't have a medium */
4732 if (bs
->drv
== NULL
) {
4733 for (i
= 0; i
< num_reqs
; i
++) {
4734 reqs
[i
].error
= -ENOMEDIUM
;
4739 if (num_reqs
== 0) {
4743 // Create MultiwriteCB structure
4744 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4745 mcb
->num_requests
= 0;
4746 mcb
->num_callbacks
= num_reqs
;
4748 for (i
= 0; i
< num_reqs
; i
++) {
4749 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4750 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4753 // Check for mergable requests
4754 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4756 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4758 /* Run the aio requests. */
4759 mcb
->num_requests
= num_reqs
;
4760 for (i
= 0; i
< num_reqs
; i
++) {
4761 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4762 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4770 void bdrv_aio_cancel(BlockAIOCB
*acb
)
4773 bdrv_aio_cancel_async(acb
);
4774 while (acb
->refcnt
> 1) {
4775 if (acb
->aiocb_info
->get_aio_context
) {
4776 aio_poll(acb
->aiocb_info
->get_aio_context(acb
), true);
4777 } else if (acb
->bs
) {
4778 aio_poll(bdrv_get_aio_context(acb
->bs
), true);
4783 qemu_aio_unref(acb
);
4786 /* Async version of aio cancel. The caller is not blocked if the acb implements
4787 * cancel_async, otherwise we do nothing and let the request normally complete.
4788 * In either case the completion callback must be called. */
4789 void bdrv_aio_cancel_async(BlockAIOCB
*acb
)
4791 if (acb
->aiocb_info
->cancel_async
) {
4792 acb
->aiocb_info
->cancel_async(acb
);
4796 /**************************************************************/
4797 /* async block device emulation */
4799 typedef struct BlockAIOCBSync
{
4803 /* vector translation state */
4809 static const AIOCBInfo bdrv_em_aiocb_info
= {
4810 .aiocb_size
= sizeof(BlockAIOCBSync
),
4813 static void bdrv_aio_bh_cb(void *opaque
)
4815 BlockAIOCBSync
*acb
= opaque
;
4817 if (!acb
->is_write
&& acb
->ret
>= 0) {
4818 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4820 qemu_vfree(acb
->bounce
);
4821 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4822 qemu_bh_delete(acb
->bh
);
4824 qemu_aio_unref(acb
);
4827 static BlockAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4831 BlockCompletionFunc
*cb
,
4836 BlockAIOCBSync
*acb
;
4838 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4839 acb
->is_write
= is_write
;
4841 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
4842 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_aio_bh_cb
, acb
);
4844 if (acb
->bounce
== NULL
) {
4846 } else if (is_write
) {
4847 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4848 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4850 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4853 qemu_bh_schedule(acb
->bh
);
4855 return &acb
->common
;
4858 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4859 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4860 BlockCompletionFunc
*cb
, void *opaque
)
4862 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4865 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4866 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4867 BlockCompletionFunc
*cb
, void *opaque
)
4869 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4873 typedef struct BlockAIOCBCoroutine
{
4880 } BlockAIOCBCoroutine
;
4882 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4883 .aiocb_size
= sizeof(BlockAIOCBCoroutine
),
4886 static void bdrv_co_complete(BlockAIOCBCoroutine
*acb
)
4888 if (!acb
->need_bh
) {
4889 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4890 qemu_aio_unref(acb
);
4894 static void bdrv_co_em_bh(void *opaque
)
4896 BlockAIOCBCoroutine
*acb
= opaque
;
4898 assert(!acb
->need_bh
);
4899 qemu_bh_delete(acb
->bh
);
4900 bdrv_co_complete(acb
);
4903 static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine
*acb
)
4905 acb
->need_bh
= false;
4906 if (acb
->req
.error
!= -EINPROGRESS
) {
4907 BlockDriverState
*bs
= acb
->common
.bs
;
4909 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4910 qemu_bh_schedule(acb
->bh
);
4914 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4915 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4917 BlockAIOCBCoroutine
*acb
= opaque
;
4918 BlockDriverState
*bs
= acb
->common
.bs
;
4920 if (!acb
->is_write
) {
4921 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4922 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4924 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4925 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4928 bdrv_co_complete(acb
);
4931 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4935 BdrvRequestFlags flags
,
4936 BlockCompletionFunc
*cb
,
4941 BlockAIOCBCoroutine
*acb
;
4943 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4944 acb
->need_bh
= true;
4945 acb
->req
.error
= -EINPROGRESS
;
4946 acb
->req
.sector
= sector_num
;
4947 acb
->req
.nb_sectors
= nb_sectors
;
4948 acb
->req
.qiov
= qiov
;
4949 acb
->req
.flags
= flags
;
4950 acb
->is_write
= is_write
;
4952 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4953 qemu_coroutine_enter(co
, acb
);
4955 bdrv_co_maybe_schedule_bh(acb
);
4956 return &acb
->common
;
4959 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4961 BlockAIOCBCoroutine
*acb
= opaque
;
4962 BlockDriverState
*bs
= acb
->common
.bs
;
4964 acb
->req
.error
= bdrv_co_flush(bs
);
4965 bdrv_co_complete(acb
);
4968 BlockAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4969 BlockCompletionFunc
*cb
, void *opaque
)
4971 trace_bdrv_aio_flush(bs
, opaque
);
4974 BlockAIOCBCoroutine
*acb
;
4976 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4977 acb
->need_bh
= true;
4978 acb
->req
.error
= -EINPROGRESS
;
4980 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4981 qemu_coroutine_enter(co
, acb
);
4983 bdrv_co_maybe_schedule_bh(acb
);
4984 return &acb
->common
;
4987 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4989 BlockAIOCBCoroutine
*acb
= opaque
;
4990 BlockDriverState
*bs
= acb
->common
.bs
;
4992 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4993 bdrv_co_complete(acb
);
4996 BlockAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4997 int64_t sector_num
, int nb_sectors
,
4998 BlockCompletionFunc
*cb
, void *opaque
)
5001 BlockAIOCBCoroutine
*acb
;
5003 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
5005 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
5006 acb
->need_bh
= true;
5007 acb
->req
.error
= -EINPROGRESS
;
5008 acb
->req
.sector
= sector_num
;
5009 acb
->req
.nb_sectors
= nb_sectors
;
5010 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
5011 qemu_coroutine_enter(co
, acb
);
5013 bdrv_co_maybe_schedule_bh(acb
);
5014 return &acb
->common
;
5017 void bdrv_init(void)
5019 module_call_init(MODULE_INIT_BLOCK
);
5022 void bdrv_init_with_whitelist(void)
5024 use_bdrv_whitelist
= 1;
5028 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
5029 BlockCompletionFunc
*cb
, void *opaque
)
5033 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
5034 acb
->aiocb_info
= aiocb_info
;
5037 acb
->opaque
= opaque
;
5042 void qemu_aio_ref(void *p
)
5044 BlockAIOCB
*acb
= p
;
5048 void qemu_aio_unref(void *p
)
5050 BlockAIOCB
*acb
= p
;
5051 assert(acb
->refcnt
> 0);
5052 if (--acb
->refcnt
== 0) {
5053 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
5057 /**************************************************************/
5058 /* Coroutine block device emulation */
5060 typedef struct CoroutineIOCompletion
{
5061 Coroutine
*coroutine
;
5063 } CoroutineIOCompletion
;
5065 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
5067 CoroutineIOCompletion
*co
= opaque
;
5070 qemu_coroutine_enter(co
->coroutine
, NULL
);
5073 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
5074 int nb_sectors
, QEMUIOVector
*iov
,
5077 CoroutineIOCompletion co
= {
5078 .coroutine
= qemu_coroutine_self(),
5083 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
5084 bdrv_co_io_em_complete
, &co
);
5086 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
5087 bdrv_co_io_em_complete
, &co
);
5090 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
5094 qemu_coroutine_yield();
5099 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
5100 int64_t sector_num
, int nb_sectors
,
5103 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
5106 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
5107 int64_t sector_num
, int nb_sectors
,
5110 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
5113 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
5115 RwCo
*rwco
= opaque
;
5117 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
5120 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
5124 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
5128 /* Write back cached data to the OS even with cache=unsafe */
5129 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
5130 if (bs
->drv
->bdrv_co_flush_to_os
) {
5131 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
5137 /* But don't actually force it to the disk with cache=unsafe */
5138 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
5142 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
5143 if (bs
->drv
->bdrv_co_flush_to_disk
) {
5144 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
5145 } else if (bs
->drv
->bdrv_aio_flush
) {
5147 CoroutineIOCompletion co
= {
5148 .coroutine
= qemu_coroutine_self(),
5151 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
5155 qemu_coroutine_yield();
5160 * Some block drivers always operate in either writethrough or unsafe
5161 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
5162 * know how the server works (because the behaviour is hardcoded or
5163 * depends on server-side configuration), so we can't ensure that
5164 * everything is safe on disk. Returning an error doesn't work because
5165 * that would break guests even if the server operates in writethrough
5168 * Let's hope the user knows what he's doing.
5176 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
5177 * in the case of cache=unsafe, so there are no useless flushes.
5180 return bdrv_co_flush(bs
->file
);
5183 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
5185 Error
*local_err
= NULL
;
5192 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
5195 bs
->open_flags
&= ~BDRV_O_INCOMING
;
5197 if (bs
->drv
->bdrv_invalidate_cache
) {
5198 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
5199 } else if (bs
->file
) {
5200 bdrv_invalidate_cache(bs
->file
, &local_err
);
5203 error_propagate(errp
, local_err
);
5207 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
5209 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
5214 void bdrv_invalidate_cache_all(Error
**errp
)
5216 BlockDriverState
*bs
;
5217 Error
*local_err
= NULL
;
5219 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5220 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5222 aio_context_acquire(aio_context
);
5223 bdrv_invalidate_cache(bs
, &local_err
);
5224 aio_context_release(aio_context
);
5226 error_propagate(errp
, local_err
);
5232 int bdrv_flush(BlockDriverState
*bs
)
5240 if (qemu_in_coroutine()) {
5241 /* Fast-path if already in coroutine context */
5242 bdrv_flush_co_entry(&rwco
);
5244 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5246 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
5247 qemu_coroutine_enter(co
, &rwco
);
5248 while (rwco
.ret
== NOT_DONE
) {
5249 aio_poll(aio_context
, true);
5256 typedef struct DiscardCo
{
5257 BlockDriverState
*bs
;
5262 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
5264 DiscardCo
*rwco
= opaque
;
5266 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
5269 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
5272 int max_discard
, ret
;
5278 ret
= bdrv_check_request(bs
, sector_num
, nb_sectors
);
5281 } else if (bs
->read_only
) {
5285 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
5287 /* Do nothing if disabled. */
5288 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
5292 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
5296 max_discard
= MIN_NON_ZERO(bs
->bl
.max_discard
, BDRV_REQUEST_MAX_SECTORS
);
5297 while (nb_sectors
> 0) {
5299 int num
= nb_sectors
;
5302 if (bs
->bl
.discard_alignment
&&
5303 num
>= bs
->bl
.discard_alignment
&&
5304 sector_num
% bs
->bl
.discard_alignment
) {
5305 if (num
> bs
->bl
.discard_alignment
) {
5306 num
= bs
->bl
.discard_alignment
;
5308 num
-= sector_num
% bs
->bl
.discard_alignment
;
5311 /* limit request size */
5312 if (num
> max_discard
) {
5316 if (bs
->drv
->bdrv_co_discard
) {
5317 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
5320 CoroutineIOCompletion co
= {
5321 .coroutine
= qemu_coroutine_self(),
5324 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
5325 bdrv_co_io_em_complete
, &co
);
5329 qemu_coroutine_yield();
5333 if (ret
&& ret
!= -ENOTSUP
) {
5343 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
5348 .sector_num
= sector_num
,
5349 .nb_sectors
= nb_sectors
,
5353 if (qemu_in_coroutine()) {
5354 /* Fast-path if already in coroutine context */
5355 bdrv_discard_co_entry(&rwco
);
5357 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5359 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
5360 qemu_coroutine_enter(co
, &rwco
);
5361 while (rwco
.ret
== NOT_DONE
) {
5362 aio_poll(aio_context
, true);
5369 /**************************************************************/
5370 /* removable device support */
5373 * Return TRUE if the media is present
5375 int bdrv_is_inserted(BlockDriverState
*bs
)
5377 BlockDriver
*drv
= bs
->drv
;
5381 if (!drv
->bdrv_is_inserted
)
5383 return drv
->bdrv_is_inserted(bs
);
5387 * Return whether the media changed since the last call to this
5388 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5390 int bdrv_media_changed(BlockDriverState
*bs
)
5392 BlockDriver
*drv
= bs
->drv
;
5394 if (drv
&& drv
->bdrv_media_changed
) {
5395 return drv
->bdrv_media_changed(bs
);
5401 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5403 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
5405 BlockDriver
*drv
= bs
->drv
;
5406 const char *device_name
;
5408 if (drv
&& drv
->bdrv_eject
) {
5409 drv
->bdrv_eject(bs
, eject_flag
);
5412 device_name
= bdrv_get_device_name(bs
);
5413 if (device_name
[0] != '\0') {
5414 qapi_event_send_device_tray_moved(device_name
,
5415 eject_flag
, &error_abort
);
5420 * Lock or unlock the media (if it is locked, the user won't be able
5421 * to eject it manually).
5423 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5425 BlockDriver
*drv
= bs
->drv
;
5427 trace_bdrv_lock_medium(bs
, locked
);
5429 if (drv
&& drv
->bdrv_lock_medium
) {
5430 drv
->bdrv_lock_medium(bs
, locked
);
5434 /* needed for generic scsi interface */
5436 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5438 BlockDriver
*drv
= bs
->drv
;
5440 if (drv
&& drv
->bdrv_ioctl
)
5441 return drv
->bdrv_ioctl(bs
, req
, buf
);
5445 BlockAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5446 unsigned long int req
, void *buf
,
5447 BlockCompletionFunc
*cb
, void *opaque
)
5449 BlockDriver
*drv
= bs
->drv
;
5451 if (drv
&& drv
->bdrv_aio_ioctl
)
5452 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5456 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5458 bs
->guest_block_size
= align
;
5461 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5463 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5466 void *qemu_blockalign0(BlockDriverState
*bs
, size_t size
)
5468 return memset(qemu_blockalign(bs
, size
), 0, size
);
5471 void *qemu_try_blockalign(BlockDriverState
*bs
, size_t size
)
5473 size_t align
= bdrv_opt_mem_align(bs
);
5475 /* Ensure that NULL is never returned on success */
5481 return qemu_try_memalign(align
, size
);
5484 void *qemu_try_blockalign0(BlockDriverState
*bs
, size_t size
)
5486 void *mem
= qemu_try_blockalign(bs
, size
);
5489 memset(mem
, 0, size
);
5496 * Check if all memory in this vector is sector aligned.
5498 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5501 size_t alignment
= bdrv_opt_mem_align(bs
);
5503 for (i
= 0; i
< qiov
->niov
; i
++) {
5504 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5507 if (qiov
->iov
[i
].iov_len
% alignment
) {
5515 BdrvDirtyBitmap
*bdrv_find_dirty_bitmap(BlockDriverState
*bs
, const char *name
)
5517 BdrvDirtyBitmap
*bm
;
5520 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5521 if (bm
->name
&& !strcmp(name
, bm
->name
)) {
5528 void bdrv_dirty_bitmap_make_anon(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5530 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
5531 g_free(bitmap
->name
);
5532 bitmap
->name
= NULL
;
5535 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
,
5536 uint32_t granularity
,
5540 int64_t bitmap_size
;
5541 BdrvDirtyBitmap
*bitmap
;
5542 uint32_t sector_granularity
;
5544 assert((granularity
& (granularity
- 1)) == 0);
5546 if (name
&& bdrv_find_dirty_bitmap(bs
, name
)) {
5547 error_setg(errp
, "Bitmap already exists: %s", name
);
5550 sector_granularity
= granularity
>> BDRV_SECTOR_BITS
;
5551 assert(sector_granularity
);
5552 bitmap_size
= bdrv_nb_sectors(bs
);
5553 if (bitmap_size
< 0) {
5554 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
5555 errno
= -bitmap_size
;
5558 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
5559 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(sector_granularity
));
5560 bitmap
->name
= g_strdup(name
);
5561 bitmap
->disabled
= false;
5562 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5566 bool bdrv_dirty_bitmap_frozen(BdrvDirtyBitmap
*bitmap
)
5568 return bitmap
->successor
;
5571 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap
*bitmap
)
5573 return !(bitmap
->disabled
|| bitmap
->successor
);
5577 * Create a successor bitmap destined to replace this bitmap after an operation.
5578 * Requires that the bitmap is not frozen and has no successor.
5580 int bdrv_dirty_bitmap_create_successor(BlockDriverState
*bs
,
5581 BdrvDirtyBitmap
*bitmap
, Error
**errp
)
5583 uint64_t granularity
;
5584 BdrvDirtyBitmap
*child
;
5586 if (bdrv_dirty_bitmap_frozen(bitmap
)) {
5587 error_setg(errp
, "Cannot create a successor for a bitmap that is "
5588 "currently frozen");
5591 assert(!bitmap
->successor
);
5593 /* Create an anonymous successor */
5594 granularity
= bdrv_dirty_bitmap_granularity(bitmap
);
5595 child
= bdrv_create_dirty_bitmap(bs
, granularity
, NULL
, errp
);
5600 /* Successor will be on or off based on our current state. */
5601 child
->disabled
= bitmap
->disabled
;
5603 /* Install the successor and freeze the parent */
5604 bitmap
->successor
= child
;
5609 * For a bitmap with a successor, yield our name to the successor,
5610 * delete the old bitmap, and return a handle to the new bitmap.
5612 BdrvDirtyBitmap
*bdrv_dirty_bitmap_abdicate(BlockDriverState
*bs
,
5613 BdrvDirtyBitmap
*bitmap
,
5617 BdrvDirtyBitmap
*successor
= bitmap
->successor
;
5619 if (successor
== NULL
) {
5620 error_setg(errp
, "Cannot relinquish control if "
5621 "there's no successor present");
5625 name
= bitmap
->name
;
5626 bitmap
->name
= NULL
;
5627 successor
->name
= name
;
5628 bitmap
->successor
= NULL
;
5629 bdrv_release_dirty_bitmap(bs
, bitmap
);
5635 * In cases of failure where we can no longer safely delete the parent,
5636 * we may wish to re-join the parent and child/successor.
5637 * The merged parent will be un-frozen, but not explicitly re-enabled.
5639 BdrvDirtyBitmap
*bdrv_reclaim_dirty_bitmap(BlockDriverState
*bs
,
5640 BdrvDirtyBitmap
*parent
,
5643 BdrvDirtyBitmap
*successor
= parent
->successor
;
5646 error_setg(errp
, "Cannot reclaim a successor when none is present");
5650 if (!hbitmap_merge(parent
->bitmap
, successor
->bitmap
)) {
5651 error_setg(errp
, "Merging of parent and successor bitmap failed");
5654 bdrv_release_dirty_bitmap(bs
, successor
);
5655 parent
->successor
= NULL
;
5660 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5662 BdrvDirtyBitmap
*bm
, *next
;
5663 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5665 assert(!bdrv_dirty_bitmap_frozen(bm
));
5666 QLIST_REMOVE(bitmap
, list
);
5667 hbitmap_free(bitmap
->bitmap
);
5668 g_free(bitmap
->name
);
5675 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
5677 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
5678 bitmap
->disabled
= true;
5681 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap
*bitmap
)
5683 assert(!bdrv_dirty_bitmap_frozen(bitmap
));
5684 bitmap
->disabled
= false;
5687 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5689 BdrvDirtyBitmap
*bm
;
5690 BlockDirtyInfoList
*list
= NULL
;
5691 BlockDirtyInfoList
**plist
= &list
;
5693 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5694 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
5695 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
5696 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5697 info
->granularity
= bdrv_dirty_bitmap_granularity(bm
);
5698 info
->has_name
= !!bm
->name
;
5699 info
->name
= g_strdup(bm
->name
);
5700 entry
->value
= info
;
5702 plist
= &entry
->next
;
5708 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5711 return hbitmap_get(bitmap
->bitmap
, sector
);
5718 * Chooses a default granularity based on the existing cluster size,
5719 * but clamped between [4K, 64K]. Defaults to 64K in the case that there
5720 * is no cluster size information available.
5722 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState
*bs
)
5724 BlockDriverInfo bdi
;
5725 uint32_t granularity
;
5727 if (bdrv_get_info(bs
, &bdi
) >= 0 && bdi
.cluster_size
> 0) {
5728 granularity
= MAX(4096, bdi
.cluster_size
);
5729 granularity
= MIN(65536, granularity
);
5731 granularity
= 65536;
5737 uint32_t bdrv_dirty_bitmap_granularity(BdrvDirtyBitmap
*bitmap
)
5739 return BDRV_SECTOR_SIZE
<< hbitmap_granularity(bitmap
->bitmap
);
5742 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5743 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5745 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5748 void bdrv_set_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5749 int64_t cur_sector
, int nr_sectors
)
5751 assert(bdrv_dirty_bitmap_enabled(bitmap
));
5752 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5755 void bdrv_reset_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5756 int64_t cur_sector
, int nr_sectors
)
5758 assert(bdrv_dirty_bitmap_enabled(bitmap
));
5759 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5762 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5765 BdrvDirtyBitmap
*bitmap
;
5766 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5767 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
5770 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5774 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5777 BdrvDirtyBitmap
*bitmap
;
5778 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5779 if (!bdrv_dirty_bitmap_enabled(bitmap
)) {
5782 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5787 * Advance an HBitmapIter to an arbitrary offset.
5789 void bdrv_set_dirty_iter(HBitmapIter
*hbi
, int64_t offset
)
5792 hbitmap_iter_init(hbi
, hbi
->hb
, offset
);
5795 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5797 return hbitmap_count(bitmap
->bitmap
);
5800 /* Get a reference to bs */
5801 void bdrv_ref(BlockDriverState
*bs
)
5806 /* Release a previously grabbed reference to bs.
5807 * If after releasing, reference count is zero, the BlockDriverState is
5809 void bdrv_unref(BlockDriverState
*bs
)
5814 assert(bs
->refcnt
> 0);
5815 if (--bs
->refcnt
== 0) {
5820 struct BdrvOpBlocker
{
5822 QLIST_ENTRY(BdrvOpBlocker
) list
;
5825 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
5827 BdrvOpBlocker
*blocker
;
5828 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5829 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
5830 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
5832 error_setg(errp
, "Node '%s' is busy: %s",
5833 bdrv_get_device_or_node_name(bs
),
5834 error_get_pretty(blocker
->reason
));
5841 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5843 BdrvOpBlocker
*blocker
;
5844 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5846 blocker
= g_new0(BdrvOpBlocker
, 1);
5847 blocker
->reason
= reason
;
5848 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
5851 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5853 BdrvOpBlocker
*blocker
, *next
;
5854 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5855 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
5856 if (blocker
->reason
== reason
) {
5857 QLIST_REMOVE(blocker
, list
);
5863 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
5866 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5867 bdrv_op_block(bs
, i
, reason
);
5871 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
5874 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5875 bdrv_op_unblock(bs
, i
, reason
);
5879 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
5883 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5884 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
5891 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5893 bs
->iostatus_enabled
= true;
5894 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5897 /* The I/O status is only enabled if the drive explicitly
5898 * enables it _and_ the VM is configured to stop on errors */
5899 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5901 return (bs
->iostatus_enabled
&&
5902 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5903 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5904 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5907 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5909 bs
->iostatus_enabled
= false;
5912 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5914 if (bdrv_iostatus_is_enabled(bs
)) {
5915 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5917 block_job_iostatus_reset(bs
->job
);
5922 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5924 assert(bdrv_iostatus_is_enabled(bs
));
5925 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5926 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5927 BLOCK_DEVICE_IO_STATUS_FAILED
;
5931 void bdrv_img_create(const char *filename
, const char *fmt
,
5932 const char *base_filename
, const char *base_fmt
,
5933 char *options
, uint64_t img_size
, int flags
,
5934 Error
**errp
, bool quiet
)
5936 QemuOptsList
*create_opts
= NULL
;
5937 QemuOpts
*opts
= NULL
;
5938 const char *backing_fmt
, *backing_file
;
5940 BlockDriver
*drv
, *proto_drv
;
5941 BlockDriver
*backing_drv
= NULL
;
5942 Error
*local_err
= NULL
;
5945 /* Find driver and parse its options */
5946 drv
= bdrv_find_format(fmt
);
5948 error_setg(errp
, "Unknown file format '%s'", fmt
);
5952 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
5957 if (!drv
->create_opts
) {
5958 error_setg(errp
, "Format driver '%s' does not support image creation",
5963 if (!proto_drv
->create_opts
) {
5964 error_setg(errp
, "Protocol driver '%s' does not support image creation",
5965 proto_drv
->format_name
);
5969 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5970 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5972 /* Create parameter list with default values */
5973 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5974 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
5976 /* Parse -o options */
5978 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
5980 error_report_err(local_err
);
5982 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
5987 if (base_filename
) {
5988 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
5990 error_setg(errp
, "Backing file not supported for file format '%s'",
5997 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
5999 error_setg(errp
, "Backing file format not supported for file "
6000 "format '%s'", fmt
);
6005 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
6007 if (!strcmp(filename
, backing_file
)) {
6008 error_setg(errp
, "Error: Trying to create an image with the "
6009 "same filename as the backing file");
6014 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
6016 backing_drv
= bdrv_find_format(backing_fmt
);
6018 error_setg(errp
, "Unknown backing file format '%s'",
6024 // The size for the image must always be specified, with one exception:
6025 // If we are using a backing file, we can obtain the size from there
6026 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
6029 BlockDriverState
*bs
;
6030 char *full_backing
= g_new0(char, PATH_MAX
);
6034 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
6035 full_backing
, PATH_MAX
,
6038 g_free(full_backing
);
6042 /* backing files always opened read-only */
6044 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
6047 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
6048 backing_drv
, &local_err
);
6049 g_free(full_backing
);
6053 size
= bdrv_getlength(bs
);
6055 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
6061 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
6065 error_setg(errp
, "Image creation needs a size parameter");
6071 printf("Formatting '%s', fmt=%s", filename
, fmt
);
6072 qemu_opts_print(opts
, " ");
6076 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
6078 if (ret
== -EFBIG
) {
6079 /* This is generally a better message than whatever the driver would
6080 * deliver (especially because of the cluster_size_hint), since that
6081 * is most probably not much different from "image too large". */
6082 const char *cluster_size_hint
= "";
6083 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
6084 cluster_size_hint
= " (try using a larger cluster size)";
6086 error_setg(errp
, "The image size is too large for file format '%s'"
6087 "%s", fmt
, cluster_size_hint
);
6088 error_free(local_err
);
6093 qemu_opts_del(opts
);
6094 qemu_opts_free(create_opts
);
6096 error_propagate(errp
, local_err
);
6100 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
6102 return bs
->aio_context
;
6105 void bdrv_detach_aio_context(BlockDriverState
*bs
)
6107 BdrvAioNotifier
*baf
;
6113 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
6114 baf
->detach_aio_context(baf
->opaque
);
6117 if (bs
->io_limits_enabled
) {
6118 throttle_detach_aio_context(&bs
->throttle_state
);
6120 if (bs
->drv
->bdrv_detach_aio_context
) {
6121 bs
->drv
->bdrv_detach_aio_context(bs
);
6124 bdrv_detach_aio_context(bs
->file
);
6126 if (bs
->backing_hd
) {
6127 bdrv_detach_aio_context(bs
->backing_hd
);
6130 bs
->aio_context
= NULL
;
6133 void bdrv_attach_aio_context(BlockDriverState
*bs
,
6134 AioContext
*new_context
)
6136 BdrvAioNotifier
*ban
;
6142 bs
->aio_context
= new_context
;
6144 if (bs
->backing_hd
) {
6145 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
6148 bdrv_attach_aio_context(bs
->file
, new_context
);
6150 if (bs
->drv
->bdrv_attach_aio_context
) {
6151 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
6153 if (bs
->io_limits_enabled
) {
6154 throttle_attach_aio_context(&bs
->throttle_state
, new_context
);
6157 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
6158 ban
->attached_aio_context(new_context
, ban
->opaque
);
6162 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
6164 bdrv_drain_all(); /* ensure there are no in-flight requests */
6166 bdrv_detach_aio_context(bs
);
6168 /* This function executes in the old AioContext so acquire the new one in
6169 * case it runs in a different thread.
6171 aio_context_acquire(new_context
);
6172 bdrv_attach_aio_context(bs
, new_context
);
6173 aio_context_release(new_context
);
6176 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
6177 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
6178 void (*detach_aio_context
)(void *opaque
), void *opaque
)
6180 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
6181 *ban
= (BdrvAioNotifier
){
6182 .attached_aio_context
= attached_aio_context
,
6183 .detach_aio_context
= detach_aio_context
,
6187 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
6190 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
6191 void (*attached_aio_context
)(AioContext
*,
6193 void (*detach_aio_context
)(void *),
6196 BdrvAioNotifier
*ban
, *ban_next
;
6198 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
6199 if (ban
->attached_aio_context
== attached_aio_context
&&
6200 ban
->detach_aio_context
== detach_aio_context
&&
6201 ban
->opaque
== opaque
)
6203 QLIST_REMOVE(ban
, list
);
6213 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
6214 NotifierWithReturn
*notifier
)
6216 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
6219 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
6220 BlockDriverAmendStatusCB
*status_cb
)
6222 if (!bs
->drv
->bdrv_amend_options
) {
6225 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
6228 /* This function will be called by the bdrv_recurse_is_first_non_filter method
6229 * of block filter and by bdrv_is_first_non_filter.
6230 * It is used to test if the given bs is the candidate or recurse more in the
6233 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
6234 BlockDriverState
*candidate
)
6236 /* return false if basic checks fails */
6237 if (!bs
|| !bs
->drv
) {
6241 /* the code reached a non block filter driver -> check if the bs is
6242 * the same as the candidate. It's the recursion termination condition.
6244 if (!bs
->drv
->is_filter
) {
6245 return bs
== candidate
;
6247 /* Down this path the driver is a block filter driver */
6249 /* If the block filter recursion method is defined use it to recurse down
6252 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
6253 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
6256 /* the driver is a block filter but don't allow to recurse -> return false
6261 /* This function checks if the candidate is the first non filter bs down it's
6262 * bs chain. Since we don't have pointers to parents it explore all bs chains
6263 * from the top. Some filters can choose not to pass down the recursion.
6265 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
6267 BlockDriverState
*bs
;
6269 /* walk down the bs forest recursively */
6270 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
6273 /* try to recurse in this top level bs */
6274 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
6276 /* candidate is the first non filter */
6285 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
6287 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
6288 AioContext
*aio_context
;
6290 if (!to_replace_bs
) {
6291 error_setg(errp
, "Node name '%s' not found", node_name
);
6295 aio_context
= bdrv_get_aio_context(to_replace_bs
);
6296 aio_context_acquire(aio_context
);
6298 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
6299 to_replace_bs
= NULL
;
6303 /* We don't want arbitrary node of the BDS chain to be replaced only the top
6304 * most non filter in order to prevent data corruption.
6305 * Another benefit is that this tests exclude backing files which are
6306 * blocked by the backing blockers.
6308 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
6309 error_setg(errp
, "Only top most non filter can be replaced");
6310 to_replace_bs
= NULL
;
6315 aio_context_release(aio_context
);
6316 return to_replace_bs
;
6319 void bdrv_io_plug(BlockDriverState
*bs
)
6321 BlockDriver
*drv
= bs
->drv
;
6322 if (drv
&& drv
->bdrv_io_plug
) {
6323 drv
->bdrv_io_plug(bs
);
6324 } else if (bs
->file
) {
6325 bdrv_io_plug(bs
->file
);
6329 void bdrv_io_unplug(BlockDriverState
*bs
)
6331 BlockDriver
*drv
= bs
->drv
;
6332 if (drv
&& drv
->bdrv_io_unplug
) {
6333 drv
->bdrv_io_unplug(bs
);
6334 } else if (bs
->file
) {
6335 bdrv_io_unplug(bs
->file
);
6339 void bdrv_flush_io_queue(BlockDriverState
*bs
)
6341 BlockDriver
*drv
= bs
->drv
;
6342 if (drv
&& drv
->bdrv_flush_io_queue
) {
6343 drv
->bdrv_flush_io_queue(bs
);
6344 } else if (bs
->file
) {
6345 bdrv_flush_io_queue(bs
->file
);
6349 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
6351 const QDictEntry
*entry
;
6352 bool found_any
= false;
6354 for (entry
= qdict_first(bs
->options
); entry
;
6355 entry
= qdict_next(bs
->options
, entry
))
6357 /* Only take options for this level and exclude all non-driver-specific
6359 if (!strchr(qdict_entry_key(entry
), '.') &&
6360 strcmp(qdict_entry_key(entry
), "node-name"))
6362 qobject_incref(qdict_entry_value(entry
));
6363 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
6371 /* Updates the following BDS fields:
6372 * - exact_filename: A filename which may be used for opening a block device
6373 * which (mostly) equals the given BDS (even without any
6374 * other options; so reading and writing must return the same
6375 * results, but caching etc. may be different)
6376 * - full_open_options: Options which, when given when opening a block device
6377 * (without a filename), result in a BDS (mostly)
6378 * equalling the given one
6379 * - filename: If exact_filename is set, it is copied here. Otherwise,
6380 * full_open_options is converted to a JSON object, prefixed with
6381 * "json:" (for use through the JSON pseudo protocol) and put here.
6383 void bdrv_refresh_filename(BlockDriverState
*bs
)
6385 BlockDriver
*drv
= bs
->drv
;
6392 /* This BDS's file name will most probably depend on its file's name, so
6393 * refresh that first */
6395 bdrv_refresh_filename(bs
->file
);
6398 if (drv
->bdrv_refresh_filename
) {
6399 /* Obsolete information is of no use here, so drop the old file name
6400 * information before refreshing it */
6401 bs
->exact_filename
[0] = '\0';
6402 if (bs
->full_open_options
) {
6403 QDECREF(bs
->full_open_options
);
6404 bs
->full_open_options
= NULL
;
6407 drv
->bdrv_refresh_filename(bs
);
6408 } else if (bs
->file
) {
6409 /* Try to reconstruct valid information from the underlying file */
6410 bool has_open_options
;
6412 bs
->exact_filename
[0] = '\0';
6413 if (bs
->full_open_options
) {
6414 QDECREF(bs
->full_open_options
);
6415 bs
->full_open_options
= NULL
;
6419 has_open_options
= append_open_options(opts
, bs
);
6421 /* If no specific options have been given for this BDS, the filename of
6422 * the underlying file should suffice for this one as well */
6423 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
6424 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
6426 /* Reconstructing the full options QDict is simple for most format block
6427 * drivers, as long as the full options are known for the underlying
6428 * file BDS. The full options QDict of that file BDS should somehow
6429 * contain a representation of the filename, therefore the following
6430 * suffices without querying the (exact_)filename of this BDS. */
6431 if (bs
->file
->full_open_options
) {
6432 qdict_put_obj(opts
, "driver",
6433 QOBJECT(qstring_from_str(drv
->format_name
)));
6434 QINCREF(bs
->file
->full_open_options
);
6435 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
6437 bs
->full_open_options
= opts
;
6441 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
6442 /* There is no underlying file BDS (at least referenced by BDS.file),
6443 * so the full options QDict should be equal to the options given
6444 * specifically for this block device when it was opened (plus the
6445 * driver specification).
6446 * Because those options don't change, there is no need to update
6447 * full_open_options when it's already set. */
6450 append_open_options(opts
, bs
);
6451 qdict_put_obj(opts
, "driver",
6452 QOBJECT(qstring_from_str(drv
->format_name
)));
6454 if (bs
->exact_filename
[0]) {
6455 /* This may not work for all block protocol drivers (some may
6456 * require this filename to be parsed), but we have to find some
6457 * default solution here, so just include it. If some block driver
6458 * does not support pure options without any filename at all or
6459 * needs some special format of the options QDict, it needs to
6460 * implement the driver-specific bdrv_refresh_filename() function.
6462 qdict_put_obj(opts
, "filename",
6463 QOBJECT(qstring_from_str(bs
->exact_filename
)));
6466 bs
->full_open_options
= opts
;
6469 if (bs
->exact_filename
[0]) {
6470 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
6471 } else if (bs
->full_open_options
) {
6472 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
6473 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
6474 qstring_get_str(json
));
6479 /* This accessor function purpose is to allow the device models to access the
6480 * BlockAcctStats structure embedded inside a BlockDriverState without being
6481 * aware of the BlockDriverState structure layout.
6482 * It will go away when the BlockAcctStats structure will be moved inside
6483 * the device models.
6485 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)