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>
55 struct BdrvDirtyBitmap
{
57 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
60 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
62 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
63 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
64 BlockCompletionFunc
*cb
, void *opaque
);
65 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
66 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
67 BlockCompletionFunc
*cb
, void *opaque
);
68 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
69 int64_t sector_num
, int nb_sectors
,
71 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
72 int64_t sector_num
, int nb_sectors
,
74 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
75 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
76 BdrvRequestFlags flags
);
77 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
78 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
79 BdrvRequestFlags flags
);
80 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
84 BdrvRequestFlags flags
,
85 BlockCompletionFunc
*cb
,
88 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
89 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
90 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
92 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
93 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
95 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
96 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
98 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
99 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
101 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
103 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
105 /* If non-zero, use only whitelisted block drivers */
106 static int use_bdrv_whitelist
;
109 static int is_windows_drive_prefix(const char *filename
)
111 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
112 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
116 int is_windows_drive(const char *filename
)
118 if (is_windows_drive_prefix(filename
) &&
121 if (strstart(filename
, "\\\\.\\", NULL
) ||
122 strstart(filename
, "//./", NULL
))
128 /* throttling disk I/O limits */
129 void bdrv_set_io_limits(BlockDriverState
*bs
,
134 throttle_config(&bs
->throttle_state
, cfg
);
136 for (i
= 0; i
< 2; i
++) {
137 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
141 /* this function drain all the throttled IOs */
142 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
144 bool drained
= false;
145 bool enabled
= bs
->io_limits_enabled
;
148 bs
->io_limits_enabled
= false;
150 for (i
= 0; i
< 2; i
++) {
151 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
156 bs
->io_limits_enabled
= enabled
;
161 void bdrv_io_limits_disable(BlockDriverState
*bs
)
163 bs
->io_limits_enabled
= false;
165 bdrv_start_throttled_reqs(bs
);
167 throttle_destroy(&bs
->throttle_state
);
170 static void bdrv_throttle_read_timer_cb(void *opaque
)
172 BlockDriverState
*bs
= opaque
;
173 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
176 static void bdrv_throttle_write_timer_cb(void *opaque
)
178 BlockDriverState
*bs
= opaque
;
179 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
182 /* should be called before bdrv_set_io_limits if a limit is set */
183 void bdrv_io_limits_enable(BlockDriverState
*bs
)
185 int clock_type
= QEMU_CLOCK_REALTIME
;
187 if (qtest_enabled()) {
188 /* For testing block IO throttling only */
189 clock_type
= QEMU_CLOCK_VIRTUAL
;
191 assert(!bs
->io_limits_enabled
);
192 throttle_init(&bs
->throttle_state
,
193 bdrv_get_aio_context(bs
),
195 bdrv_throttle_read_timer_cb
,
196 bdrv_throttle_write_timer_cb
,
198 bs
->io_limits_enabled
= true;
201 /* This function makes an IO wait if needed
203 * @nb_sectors: the number of sectors of the IO
204 * @is_write: is the IO a write
206 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
210 /* does this io must wait */
211 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
213 /* if must wait or any request of this type throttled queue the IO */
215 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
216 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
219 /* the IO will be executed, do the accounting */
220 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
223 /* if the next request must wait -> do nothing */
224 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
228 /* else queue next request for execution */
229 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
232 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
234 if (!bs
|| !bs
->drv
) {
235 /* 4k should be on the safe side */
239 return bs
->bl
.opt_mem_alignment
;
242 /* check if the path starts with "<protocol>:" */
243 int path_has_protocol(const char *path
)
248 if (is_windows_drive(path
) ||
249 is_windows_drive_prefix(path
)) {
252 p
= path
+ strcspn(path
, ":/\\");
254 p
= path
+ strcspn(path
, ":/");
260 int path_is_absolute(const char *path
)
263 /* specific case for names like: "\\.\d:" */
264 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
267 return (*path
== '/' || *path
== '\\');
269 return (*path
== '/');
273 /* if filename is absolute, just copy it to dest. Otherwise, build a
274 path to it by considering it is relative to base_path. URL are
276 void path_combine(char *dest
, int dest_size
,
277 const char *base_path
,
278 const char *filename
)
285 if (path_is_absolute(filename
)) {
286 pstrcpy(dest
, dest_size
, filename
);
288 p
= strchr(base_path
, ':');
293 p1
= strrchr(base_path
, '/');
297 p2
= strrchr(base_path
, '\\');
309 if (len
> dest_size
- 1)
311 memcpy(dest
, base_path
, len
);
313 pstrcat(dest
, dest_size
, filename
);
317 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
319 char *dest
, size_t sz
,
322 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
323 path_is_absolute(backing
))
325 pstrcpy(dest
, sz
, backing
);
326 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
327 error_setg(errp
, "Cannot use relative backing file names for '%s'",
330 path_combine(dest
, sz
, backed
, backing
);
334 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
337 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
339 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
343 void bdrv_register(BlockDriver
*bdrv
)
345 /* Block drivers without coroutine functions need emulation */
346 if (!bdrv
->bdrv_co_readv
) {
347 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
348 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
350 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
351 * the block driver lacks aio we need to emulate that too.
353 if (!bdrv
->bdrv_aio_readv
) {
354 /* add AIO emulation layer */
355 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
356 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
360 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
363 BlockDriverState
*bdrv_new_root(void)
365 BlockDriverState
*bs
= bdrv_new();
367 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
371 BlockDriverState
*bdrv_new(void)
373 BlockDriverState
*bs
;
376 bs
= g_new0(BlockDriverState
, 1);
377 QLIST_INIT(&bs
->dirty_bitmaps
);
378 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
379 QLIST_INIT(&bs
->op_blockers
[i
]);
381 bdrv_iostatus_disable(bs
);
382 notifier_list_init(&bs
->close_notifiers
);
383 notifier_with_return_list_init(&bs
->before_write_notifiers
);
384 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
385 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
387 bs
->aio_context
= qemu_get_aio_context();
392 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
394 notifier_list_add(&bs
->close_notifiers
, notify
);
397 BlockDriver
*bdrv_find_format(const char *format_name
)
400 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
401 if (!strcmp(drv1
->format_name
, format_name
)) {
408 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
410 static const char *whitelist_rw
[] = {
411 CONFIG_BDRV_RW_WHITELIST
413 static const char *whitelist_ro
[] = {
414 CONFIG_BDRV_RO_WHITELIST
418 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
419 return 1; /* no whitelist, anything goes */
422 for (p
= whitelist_rw
; *p
; p
++) {
423 if (!strcmp(drv
->format_name
, *p
)) {
428 for (p
= whitelist_ro
; *p
; p
++) {
429 if (!strcmp(drv
->format_name
, *p
)) {
437 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
440 BlockDriver
*drv
= bdrv_find_format(format_name
);
441 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
444 typedef struct CreateCo
{
452 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
454 Error
*local_err
= NULL
;
457 CreateCo
*cco
= opaque
;
460 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
462 error_propagate(&cco
->err
, local_err
);
467 int bdrv_create(BlockDriver
*drv
, const char* filename
,
468 QemuOpts
*opts
, Error
**errp
)
475 .filename
= g_strdup(filename
),
481 if (!drv
->bdrv_create
) {
482 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
487 if (qemu_in_coroutine()) {
488 /* Fast-path if already in coroutine context */
489 bdrv_create_co_entry(&cco
);
491 co
= qemu_coroutine_create(bdrv_create_co_entry
);
492 qemu_coroutine_enter(co
, &cco
);
493 while (cco
.ret
== NOT_DONE
) {
494 aio_poll(qemu_get_aio_context(), true);
501 error_propagate(errp
, cco
.err
);
503 error_setg_errno(errp
, -ret
, "Could not create image");
508 g_free(cco
.filename
);
512 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
515 Error
*local_err
= NULL
;
518 drv
= bdrv_find_protocol(filename
, true, errp
);
523 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
525 error_propagate(errp
, local_err
);
530 void bdrv_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
532 BlockDriver
*drv
= bs
->drv
;
533 Error
*local_err
= NULL
;
535 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
541 /* Take some limits from the children as a default */
543 bdrv_refresh_limits(bs
->file
, &local_err
);
545 error_propagate(errp
, local_err
);
548 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
549 bs
->bl
.max_transfer_length
= bs
->file
->bl
.max_transfer_length
;
550 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
552 bs
->bl
.opt_mem_alignment
= 512;
555 if (bs
->backing_hd
) {
556 bdrv_refresh_limits(bs
->backing_hd
, &local_err
);
558 error_propagate(errp
, local_err
);
561 bs
->bl
.opt_transfer_length
=
562 MAX(bs
->bl
.opt_transfer_length
,
563 bs
->backing_hd
->bl
.opt_transfer_length
);
564 bs
->bl
.max_transfer_length
=
565 MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
566 bs
->backing_hd
->bl
.max_transfer_length
);
567 bs
->bl
.opt_mem_alignment
=
568 MAX(bs
->bl
.opt_mem_alignment
,
569 bs
->backing_hd
->bl
.opt_mem_alignment
);
572 /* Then let the driver override it */
573 if (drv
->bdrv_refresh_limits
) {
574 drv
->bdrv_refresh_limits(bs
, errp
);
579 * Try to get @bs's logical and physical block size.
580 * On success, store them in @bsz struct and return 0.
581 * On failure return -errno.
582 * @bs must not be empty.
584 int bdrv_probe_blocksizes(BlockDriverState
*bs
, BlockSizes
*bsz
)
586 BlockDriver
*drv
= bs
->drv
;
588 if (drv
&& drv
->bdrv_probe_blocksizes
) {
589 return drv
->bdrv_probe_blocksizes(bs
, bsz
);
596 * Try to get @bs's geometry (cyls, heads, sectors).
597 * On success, store them in @geo struct and return 0.
598 * On failure return -errno.
599 * @bs must not be empty.
601 int bdrv_probe_geometry(BlockDriverState
*bs
, HDGeometry
*geo
)
603 BlockDriver
*drv
= bs
->drv
;
605 if (drv
&& drv
->bdrv_probe_geometry
) {
606 return drv
->bdrv_probe_geometry(bs
, geo
);
613 * Create a uniquely-named empty temporary file.
614 * Return 0 upon success, otherwise a negative errno value.
616 int get_tmp_filename(char *filename
, int size
)
619 char temp_dir
[MAX_PATH
];
620 /* GetTempFileName requires that its output buffer (4th param)
621 have length MAX_PATH or greater. */
622 assert(size
>= MAX_PATH
);
623 return (GetTempPath(MAX_PATH
, temp_dir
)
624 && GetTempFileName(temp_dir
, "qem", 0, filename
)
625 ? 0 : -GetLastError());
629 tmpdir
= getenv("TMPDIR");
633 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
636 fd
= mkstemp(filename
);
640 if (close(fd
) != 0) {
649 * Detect host devices. By convention, /dev/cdrom[N] is always
650 * recognized as a host CDROM.
652 static BlockDriver
*find_hdev_driver(const char *filename
)
654 int score_max
= 0, score
;
655 BlockDriver
*drv
= NULL
, *d
;
657 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
658 if (d
->bdrv_probe_device
) {
659 score
= d
->bdrv_probe_device(filename
);
660 if (score
> score_max
) {
670 BlockDriver
*bdrv_find_protocol(const char *filename
,
671 bool allow_protocol_prefix
,
679 /* TODO Drivers without bdrv_file_open must be specified explicitly */
682 * XXX(hch): we really should not let host device detection
683 * override an explicit protocol specification, but moving this
684 * later breaks access to device names with colons in them.
685 * Thanks to the brain-dead persistent naming schemes on udev-
686 * based Linux systems those actually are quite common.
688 drv1
= find_hdev_driver(filename
);
693 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
697 p
= strchr(filename
, ':');
700 if (len
> sizeof(protocol
) - 1)
701 len
= sizeof(protocol
) - 1;
702 memcpy(protocol
, filename
, len
);
703 protocol
[len
] = '\0';
704 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
705 if (drv1
->protocol_name
&&
706 !strcmp(drv1
->protocol_name
, protocol
)) {
711 error_setg(errp
, "Unknown protocol '%s'", protocol
);
716 * Guess image format by probing its contents.
717 * This is not a good idea when your image is raw (CVE-2008-2004), but
718 * we do it anyway for backward compatibility.
720 * @buf contains the image's first @buf_size bytes.
721 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
722 * but can be smaller if the image file is smaller)
723 * @filename is its filename.
725 * For all block drivers, call the bdrv_probe() method to get its
727 * Return the first block driver with the highest probing score.
729 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
730 const char *filename
)
732 int score_max
= 0, score
;
733 BlockDriver
*drv
= NULL
, *d
;
735 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
737 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
738 if (score
> score_max
) {
748 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
749 BlockDriver
**pdrv
, Error
**errp
)
752 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
755 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
756 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
761 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
763 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
769 drv
= bdrv_probe_all(buf
, ret
, filename
);
771 error_setg(errp
, "Could not determine image format: No compatible "
780 * Set the current 'total_sectors' value
781 * Return 0 on success, -errno on error.
783 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
785 BlockDriver
*drv
= bs
->drv
;
787 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
791 /* query actual device if possible, otherwise just trust the hint */
792 if (drv
->bdrv_getlength
) {
793 int64_t length
= drv
->bdrv_getlength(bs
);
797 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
800 bs
->total_sectors
= hint
;
805 * Set open flags for a given discard mode
807 * Return 0 on success, -1 if the discard mode was invalid.
809 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
811 *flags
&= ~BDRV_O_UNMAP
;
813 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
815 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
816 *flags
|= BDRV_O_UNMAP
;
825 * Set open flags for a given cache mode
827 * Return 0 on success, -1 if the cache mode was invalid.
829 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
831 *flags
&= ~BDRV_O_CACHE_MASK
;
833 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
834 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
835 } else if (!strcmp(mode
, "directsync")) {
836 *flags
|= BDRV_O_NOCACHE
;
837 } else if (!strcmp(mode
, "writeback")) {
838 *flags
|= BDRV_O_CACHE_WB
;
839 } else if (!strcmp(mode
, "unsafe")) {
840 *flags
|= BDRV_O_CACHE_WB
;
841 *flags
|= BDRV_O_NO_FLUSH
;
842 } else if (!strcmp(mode
, "writethrough")) {
843 /* this is the default */
852 * The copy-on-read flag is actually a reference count so multiple users may
853 * use the feature without worrying about clobbering its previous state.
854 * Copy-on-read stays enabled until all users have called to disable it.
856 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
861 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
863 assert(bs
->copy_on_read
> 0);
868 * Returns the flags that a temporary snapshot should get, based on the
869 * originally requested flags (the originally requested image will have flags
870 * like a backing file)
872 static int bdrv_temp_snapshot_flags(int flags
)
874 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
878 * Returns the flags that bs->file should get, based on the given flags for
881 static int bdrv_inherited_flags(int flags
)
883 /* Enable protocol handling, disable format probing for bs->file */
884 flags
|= BDRV_O_PROTOCOL
;
886 /* Our block drivers take care to send flushes and respect unmap policy,
887 * so we can enable both unconditionally on lower layers. */
888 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
890 /* Clear flags that only apply to the top layer */
891 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
897 * Returns the flags that bs->backing_hd should get, based on the given flags
900 static int bdrv_backing_flags(int flags
)
902 /* backing files always opened read-only */
903 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
905 /* snapshot=on is handled on the top layer */
906 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
911 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
913 int open_flags
= flags
| BDRV_O_CACHE_WB
;
916 * Clear flags that are internal to the block layer before opening the
919 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
922 * Snapshots should be writable.
924 if (flags
& BDRV_O_TEMPORARY
) {
925 open_flags
|= BDRV_O_RDWR
;
931 static void bdrv_assign_node_name(BlockDriverState
*bs
,
932 const char *node_name
,
939 /* Check for empty string or invalid characters */
940 if (!id_wellformed(node_name
)) {
941 error_setg(errp
, "Invalid node name");
945 /* takes care of avoiding namespaces collisions */
946 if (blk_by_name(node_name
)) {
947 error_setg(errp
, "node-name=%s is conflicting with a device id",
952 /* takes care of avoiding duplicates node names */
953 if (bdrv_find_node(node_name
)) {
954 error_setg(errp
, "Duplicate node name");
958 /* copy node name into the bs and insert it into the graph list */
959 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
960 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
964 * Common part for opening disk images and files
966 * Removes all processed options from *options.
968 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
969 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
972 const char *filename
;
973 const char *node_name
= NULL
;
974 Error
*local_err
= NULL
;
977 assert(bs
->file
== NULL
);
978 assert(options
!= NULL
&& bs
->options
!= options
);
981 filename
= file
->filename
;
983 filename
= qdict_get_try_str(options
, "filename");
986 if (drv
->bdrv_needs_filename
&& !filename
) {
987 error_setg(errp
, "The '%s' block driver requires a file name",
992 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
994 node_name
= qdict_get_try_str(options
, "node-name");
995 bdrv_assign_node_name(bs
, node_name
, &local_err
);
997 error_propagate(errp
, local_err
);
1000 qdict_del(options
, "node-name");
1002 /* bdrv_open() with directly using a protocol as drv. This layer is already
1003 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
1004 * and return immediately. */
1005 if (file
!= NULL
&& drv
->bdrv_file_open
) {
1006 bdrv_swap(file
, bs
);
1010 bs
->open_flags
= flags
;
1011 bs
->guest_block_size
= 512;
1012 bs
->request_alignment
= 512;
1013 bs
->zero_beyond_eof
= true;
1014 open_flags
= bdrv_open_flags(bs
, flags
);
1015 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
1017 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
1019 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
1020 ? "Driver '%s' can only be used for read-only devices"
1021 : "Driver '%s' is not whitelisted",
1026 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
1027 if (flags
& BDRV_O_COPY_ON_READ
) {
1028 if (!bs
->read_only
) {
1029 bdrv_enable_copy_on_read(bs
);
1031 error_setg(errp
, "Can't use copy-on-read on read-only device");
1036 if (filename
!= NULL
) {
1037 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
1039 bs
->filename
[0] = '\0';
1041 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
1044 bs
->opaque
= g_malloc0(drv
->instance_size
);
1046 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
1048 /* Open the image, either directly or using a protocol */
1049 if (drv
->bdrv_file_open
) {
1050 assert(file
== NULL
);
1051 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
1052 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
1055 error_setg(errp
, "Can't use '%s' as a block driver for the "
1056 "protocol level", drv
->format_name
);
1061 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1066 error_propagate(errp
, local_err
);
1067 } else if (bs
->filename
[0]) {
1068 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1070 error_setg_errno(errp
, -ret
, "Could not open image");
1075 if (bs
->encrypted
) {
1076 error_report("Encrypted images are deprecated");
1077 error_printf("Support for them will be removed in a future release.\n"
1078 "You can use 'qemu-img convert' to convert your image"
1079 " to an unencrypted one.\n");
1082 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1084 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1088 bdrv_refresh_limits(bs
, &local_err
);
1090 error_propagate(errp
, local_err
);
1095 assert(bdrv_opt_mem_align(bs
) != 0);
1096 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1107 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1109 QObject
*options_obj
;
1113 ret
= strstart(filename
, "json:", &filename
);
1116 options_obj
= qobject_from_json(filename
);
1118 error_setg(errp
, "Could not parse the JSON options");
1122 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1123 qobject_decref(options_obj
);
1124 error_setg(errp
, "Invalid JSON object given");
1128 options
= qobject_to_qdict(options_obj
);
1129 qdict_flatten(options
);
1135 * Fills in default options for opening images and converts the legacy
1136 * filename/flags pair to option QDict entries.
1138 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
1139 BlockDriver
*drv
, Error
**errp
)
1141 const char *filename
= *pfilename
;
1142 const char *drvname
;
1143 bool protocol
= flags
& BDRV_O_PROTOCOL
;
1144 bool parse_filename
= false;
1145 Error
*local_err
= NULL
;
1147 /* Parse json: pseudo-protocol */
1148 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1149 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1151 error_propagate(errp
, local_err
);
1155 /* Options given in the filename have lower priority than options
1156 * specified directly */
1157 qdict_join(*options
, json_options
, false);
1158 QDECREF(json_options
);
1159 *pfilename
= filename
= NULL
;
1162 /* Fetch the file name from the options QDict if necessary */
1163 if (protocol
&& filename
) {
1164 if (!qdict_haskey(*options
, "filename")) {
1165 qdict_put(*options
, "filename", qstring_from_str(filename
));
1166 parse_filename
= true;
1168 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1174 /* Find the right block driver */
1175 filename
= qdict_get_try_str(*options
, "filename");
1176 drvname
= qdict_get_try_str(*options
, "driver");
1180 error_setg(errp
, "Driver specified twice");
1183 drvname
= drv
->format_name
;
1184 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1186 if (!drvname
&& protocol
) {
1188 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1193 drvname
= drv
->format_name
;
1194 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1196 error_setg(errp
, "Must specify either driver or file");
1199 } else if (drvname
) {
1200 drv
= bdrv_find_format(drvname
);
1202 error_setg(errp
, "Unknown driver '%s'", drvname
);
1208 assert(drv
|| !protocol
);
1210 /* Driver-specific filename parsing */
1211 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1212 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1214 error_propagate(errp
, local_err
);
1218 if (!drv
->bdrv_needs_filename
) {
1219 qdict_del(*options
, "filename");
1226 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1229 if (bs
->backing_hd
) {
1230 assert(bs
->backing_blocker
);
1231 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1232 } else if (backing_hd
) {
1233 error_setg(&bs
->backing_blocker
,
1234 "node is used as backing hd of '%s'",
1235 bdrv_get_device_or_node_name(bs
));
1238 bs
->backing_hd
= backing_hd
;
1240 error_free(bs
->backing_blocker
);
1241 bs
->backing_blocker
= NULL
;
1244 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1245 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1246 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1247 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1249 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1250 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1251 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1252 bs
->backing_blocker
);
1254 bdrv_refresh_limits(bs
, NULL
);
1258 * Opens the backing file for a BlockDriverState if not yet open
1260 * options is a QDict of options to pass to the block drivers, or NULL for an
1261 * empty set of options. The reference to the QDict is transferred to this
1262 * function (even on failure), so if the caller intends to reuse the dictionary,
1263 * it needs to use QINCREF() before calling bdrv_file_open.
1265 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1267 char *backing_filename
= g_malloc0(PATH_MAX
);
1269 BlockDriverState
*backing_hd
;
1270 Error
*local_err
= NULL
;
1272 if (bs
->backing_hd
!= NULL
) {
1277 /* NULL means an empty set of options */
1278 if (options
== NULL
) {
1279 options
= qdict_new();
1282 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1283 if (qdict_haskey(options
, "file.filename")) {
1284 backing_filename
[0] = '\0';
1285 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1289 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1293 error_propagate(errp
, local_err
);
1299 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1301 error_setg(errp
, "Driver doesn't support backing files");
1306 backing_hd
= bdrv_new();
1308 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1309 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1312 assert(bs
->backing_hd
== NULL
);
1313 ret
= bdrv_open(&backing_hd
,
1314 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1315 bdrv_backing_flags(bs
->open_flags
), NULL
, &local_err
);
1317 bdrv_unref(backing_hd
);
1319 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1320 error_setg(errp
, "Could not open backing file: %s",
1321 error_get_pretty(local_err
));
1322 error_free(local_err
);
1325 bdrv_set_backing_hd(bs
, backing_hd
);
1328 g_free(backing_filename
);
1333 * Opens a disk image whose options are given as BlockdevRef in another block
1336 * If allow_none is true, no image will be opened if filename is false and no
1337 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1339 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1340 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1341 * itself, all options starting with "${bdref_key}." are considered part of the
1344 * The BlockdevRef will be removed from the options QDict.
1346 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1348 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1349 QDict
*options
, const char *bdref_key
, int flags
,
1350 bool allow_none
, Error
**errp
)
1352 QDict
*image_options
;
1354 char *bdref_key_dot
;
1355 const char *reference
;
1358 assert(*pbs
== NULL
);
1360 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1361 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1362 g_free(bdref_key_dot
);
1364 reference
= qdict_get_try_str(options
, bdref_key
);
1365 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1369 error_setg(errp
, "A block device must be specified for \"%s\"",
1373 QDECREF(image_options
);
1377 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1380 qdict_del(options
, bdref_key
);
1384 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1386 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1387 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1389 QemuOpts
*opts
= NULL
;
1390 QDict
*snapshot_options
;
1391 BlockDriverState
*bs_snapshot
;
1395 /* if snapshot, we create a temporary backing file and open it
1396 instead of opening 'filename' directly */
1398 /* Get the required size from the image */
1399 total_size
= bdrv_getlength(bs
);
1400 if (total_size
< 0) {
1402 error_setg_errno(errp
, -total_size
, "Could not get image size");
1406 /* Create the temporary image */
1407 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1409 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1413 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1415 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
, &error_abort
);
1416 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1417 qemu_opts_del(opts
);
1419 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1420 "'%s': %s", tmp_filename
,
1421 error_get_pretty(local_err
));
1422 error_free(local_err
);
1426 /* Prepare a new options QDict for the temporary file */
1427 snapshot_options
= qdict_new();
1428 qdict_put(snapshot_options
, "file.driver",
1429 qstring_from_str("file"));
1430 qdict_put(snapshot_options
, "file.filename",
1431 qstring_from_str(tmp_filename
));
1433 bs_snapshot
= bdrv_new();
1435 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1436 flags
, &bdrv_qcow2
, &local_err
);
1438 error_propagate(errp
, local_err
);
1442 bdrv_append(bs_snapshot
, bs
);
1445 g_free(tmp_filename
);
1450 * Opens a disk image (raw, qcow2, vmdk, ...)
1452 * options is a QDict of options to pass to the block drivers, or NULL for an
1453 * empty set of options. The reference to the QDict belongs to the block layer
1454 * after the call (even on failure), so if the caller intends to reuse the
1455 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1457 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1458 * If it is not NULL, the referenced BDS will be reused.
1460 * The reference parameter may be used to specify an existing block device which
1461 * should be opened. If specified, neither options nor a filename may be given,
1462 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1464 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1465 const char *reference
, QDict
*options
, int flags
,
1466 BlockDriver
*drv
, Error
**errp
)
1469 BlockDriverState
*file
= NULL
, *bs
;
1470 const char *drvname
;
1471 Error
*local_err
= NULL
;
1472 int snapshot_flags
= 0;
1477 bool options_non_empty
= options
? qdict_size(options
) : false;
1481 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1482 "another block device");
1486 if (filename
|| options_non_empty
) {
1487 error_setg(errp
, "Cannot reference an existing block device with "
1488 "additional options or a new filename");
1492 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1507 /* NULL means an empty set of options */
1508 if (options
== NULL
) {
1509 options
= qdict_new();
1512 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1517 /* Find the right image format driver */
1519 drvname
= qdict_get_try_str(options
, "driver");
1521 drv
= bdrv_find_format(drvname
);
1522 qdict_del(options
, "driver");
1524 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1530 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1531 if (drv
&& !drv
->bdrv_file_open
) {
1532 /* If the user explicitly wants a format driver here, we'll need to add
1533 * another layer for the protocol in bs->file */
1534 flags
&= ~BDRV_O_PROTOCOL
;
1537 bs
->options
= options
;
1538 options
= qdict_clone_shallow(options
);
1540 /* Open image file without format layer */
1541 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1542 if (flags
& BDRV_O_RDWR
) {
1543 flags
|= BDRV_O_ALLOW_RDWR
;
1545 if (flags
& BDRV_O_SNAPSHOT
) {
1546 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1547 flags
= bdrv_backing_flags(flags
);
1550 assert(file
== NULL
);
1551 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1552 bdrv_inherited_flags(flags
),
1559 /* Image format probing */
1562 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1567 error_setg(errp
, "Must specify either driver or file");
1572 /* Open the image */
1573 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1578 if (file
&& (bs
->file
!= file
)) {
1583 /* If there is a backing file, use it */
1584 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1585 QDict
*backing_options
;
1587 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1588 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1590 goto close_and_fail
;
1594 bdrv_refresh_filename(bs
);
1596 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1597 * temporary snapshot afterwards. */
1598 if (snapshot_flags
) {
1599 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1601 goto close_and_fail
;
1605 /* Check if any unknown options were used */
1606 if (options
&& (qdict_size(options
) != 0)) {
1607 const QDictEntry
*entry
= qdict_first(options
);
1608 if (flags
& BDRV_O_PROTOCOL
) {
1609 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1610 "'%s'", drv
->format_name
, entry
->key
);
1612 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1613 "support the option '%s'", drv
->format_name
,
1614 bdrv_get_device_name(bs
), entry
->key
);
1618 goto close_and_fail
;
1621 if (!bdrv_key_required(bs
)) {
1623 blk_dev_change_media_cb(bs
->blk
, true);
1625 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1626 && !runstate_check(RUN_STATE_INMIGRATE
)
1627 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1629 "Guest must be stopped for opening of encrypted image");
1631 goto close_and_fail
;
1642 QDECREF(bs
->options
);
1646 /* If *pbs is NULL, a new BDS has been created in this function and
1647 needs to be freed now. Otherwise, it does not need to be closed,
1648 since it has not really been opened yet. */
1652 error_propagate(errp
, local_err
);
1657 /* See fail path, but now the BDS has to be always closed */
1665 error_propagate(errp
, local_err
);
1670 typedef struct BlockReopenQueueEntry
{
1672 BDRVReopenState state
;
1673 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1674 } BlockReopenQueueEntry
;
1677 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1678 * reopen of multiple devices.
1680 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1681 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1682 * be created and initialized. This newly created BlockReopenQueue should be
1683 * passed back in for subsequent calls that are intended to be of the same
1686 * bs is the BlockDriverState to add to the reopen queue.
1688 * flags contains the open flags for the associated bs
1690 * returns a pointer to bs_queue, which is either the newly allocated
1691 * bs_queue, or the existing bs_queue being used.
1694 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1695 BlockDriverState
*bs
, int flags
)
1699 BlockReopenQueueEntry
*bs_entry
;
1700 if (bs_queue
== NULL
) {
1701 bs_queue
= g_new0(BlockReopenQueue
, 1);
1702 QSIMPLEQ_INIT(bs_queue
);
1705 /* bdrv_open() masks this flag out */
1706 flags
&= ~BDRV_O_PROTOCOL
;
1709 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1712 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1713 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1715 bs_entry
->state
.bs
= bs
;
1716 bs_entry
->state
.flags
= flags
;
1722 * Reopen multiple BlockDriverStates atomically & transactionally.
1724 * The queue passed in (bs_queue) must have been built up previous
1725 * via bdrv_reopen_queue().
1727 * Reopens all BDS specified in the queue, with the appropriate
1728 * flags. All devices are prepared for reopen, and failure of any
1729 * device will cause all device changes to be abandonded, and intermediate
1732 * If all devices prepare successfully, then the changes are committed
1736 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1739 BlockReopenQueueEntry
*bs_entry
, *next
;
1740 Error
*local_err
= NULL
;
1742 assert(bs_queue
!= NULL
);
1746 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1747 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1748 error_propagate(errp
, local_err
);
1751 bs_entry
->prepared
= true;
1754 /* If we reach this point, we have success and just need to apply the
1757 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1758 bdrv_reopen_commit(&bs_entry
->state
);
1764 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1765 if (ret
&& bs_entry
->prepared
) {
1766 bdrv_reopen_abort(&bs_entry
->state
);
1775 /* Reopen a single BlockDriverState with the specified flags. */
1776 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1779 Error
*local_err
= NULL
;
1780 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1782 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1783 if (local_err
!= NULL
) {
1784 error_propagate(errp
, local_err
);
1791 * Prepares a BlockDriverState for reopen. All changes are staged in the
1792 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1793 * the block driver layer .bdrv_reopen_prepare()
1795 * bs is the BlockDriverState to reopen
1796 * flags are the new open flags
1797 * queue is the reopen queue
1799 * Returns 0 on success, non-zero on error. On error errp will be set
1802 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1803 * It is the responsibility of the caller to then call the abort() or
1804 * commit() for any other BDS that have been left in a prepare() state
1807 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1811 Error
*local_err
= NULL
;
1814 assert(reopen_state
!= NULL
);
1815 assert(reopen_state
->bs
->drv
!= NULL
);
1816 drv
= reopen_state
->bs
->drv
;
1818 /* if we are to stay read-only, do not allow permission change
1820 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1821 reopen_state
->flags
& BDRV_O_RDWR
) {
1822 error_setg(errp
, "Node '%s' is read only",
1823 bdrv_get_device_or_node_name(reopen_state
->bs
));
1828 ret
= bdrv_flush(reopen_state
->bs
);
1830 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1835 if (drv
->bdrv_reopen_prepare
) {
1836 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1838 if (local_err
!= NULL
) {
1839 error_propagate(errp
, local_err
);
1841 error_setg(errp
, "failed while preparing to reopen image '%s'",
1842 reopen_state
->bs
->filename
);
1847 /* It is currently mandatory to have a bdrv_reopen_prepare()
1848 * handler for each supported drv. */
1849 error_setg(errp
, "Block format '%s' used by node '%s' "
1850 "does not support reopening files", drv
->format_name
,
1851 bdrv_get_device_or_node_name(reopen_state
->bs
));
1863 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1864 * makes them final by swapping the staging BlockDriverState contents into
1865 * the active BlockDriverState contents.
1867 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1871 assert(reopen_state
!= NULL
);
1872 drv
= reopen_state
->bs
->drv
;
1873 assert(drv
!= NULL
);
1875 /* If there are any driver level actions to take */
1876 if (drv
->bdrv_reopen_commit
) {
1877 drv
->bdrv_reopen_commit(reopen_state
);
1880 /* set BDS specific flags now */
1881 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1882 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1884 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1886 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1890 * Abort the reopen, and delete and free the staged changes in
1893 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1897 assert(reopen_state
!= NULL
);
1898 drv
= reopen_state
->bs
->drv
;
1899 assert(drv
!= NULL
);
1901 if (drv
->bdrv_reopen_abort
) {
1902 drv
->bdrv_reopen_abort(reopen_state
);
1907 void bdrv_close(BlockDriverState
*bs
)
1909 BdrvAioNotifier
*ban
, *ban_next
;
1912 block_job_cancel_sync(bs
->job
);
1914 bdrv_drain_all(); /* complete I/O */
1916 bdrv_drain_all(); /* in case flush left pending I/O */
1917 notifier_list_notify(&bs
->close_notifiers
, bs
);
1920 if (bs
->backing_hd
) {
1921 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1922 bdrv_set_backing_hd(bs
, NULL
);
1923 bdrv_unref(backing_hd
);
1925 bs
->drv
->bdrv_close(bs
);
1929 bs
->copy_on_read
= 0;
1930 bs
->backing_file
[0] = '\0';
1931 bs
->backing_format
[0] = '\0';
1932 bs
->total_sectors
= 0;
1936 bs
->zero_beyond_eof
= false;
1937 QDECREF(bs
->options
);
1939 QDECREF(bs
->full_open_options
);
1940 bs
->full_open_options
= NULL
;
1942 if (bs
->file
!= NULL
) {
1943 bdrv_unref(bs
->file
);
1949 blk_dev_change_media_cb(bs
->blk
, false);
1952 /*throttling disk I/O limits*/
1953 if (bs
->io_limits_enabled
) {
1954 bdrv_io_limits_disable(bs
);
1957 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1960 QLIST_INIT(&bs
->aio_notifiers
);
1963 void bdrv_close_all(void)
1965 BlockDriverState
*bs
;
1967 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1968 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1970 aio_context_acquire(aio_context
);
1972 aio_context_release(aio_context
);
1976 /* Check if any requests are in-flight (including throttled requests) */
1977 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1979 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1982 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1985 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1988 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1991 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1997 static bool bdrv_drain_one(BlockDriverState
*bs
)
2001 bdrv_flush_io_queue(bs
);
2002 bdrv_start_throttled_reqs(bs
);
2003 bs_busy
= bdrv_requests_pending(bs
);
2004 bs_busy
|= aio_poll(bdrv_get_aio_context(bs
), bs_busy
);
2009 * Wait for pending requests to complete on a single BlockDriverState subtree
2011 * See the warning in bdrv_drain_all(). This function can only be called if
2012 * you are sure nothing can generate I/O because you have op blockers
2015 * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
2018 void bdrv_drain(BlockDriverState
*bs
)
2020 while (bdrv_drain_one(bs
)) {
2021 /* Keep iterating */
2026 * Wait for pending requests to complete across all BlockDriverStates
2028 * This function does not flush data to disk, use bdrv_flush_all() for that
2029 * after calling this function.
2031 * Note that completion of an asynchronous I/O operation can trigger any
2032 * number of other I/O operations on other devices---for example a coroutine
2033 * can be arbitrarily complex and a constant flow of I/O can come until the
2034 * coroutine is complete. Because of this, it is not possible to have a
2035 * function to drain a single device's I/O queue.
2037 void bdrv_drain_all(void)
2039 /* Always run first iteration so any pending completion BHs run */
2041 BlockDriverState
*bs
;
2043 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2044 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2046 aio_context_acquire(aio_context
);
2048 block_job_pause(bs
->job
);
2050 aio_context_release(aio_context
);
2056 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2057 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2059 aio_context_acquire(aio_context
);
2060 busy
|= bdrv_drain_one(bs
);
2061 aio_context_release(aio_context
);
2065 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2066 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2068 aio_context_acquire(aio_context
);
2070 block_job_resume(bs
->job
);
2072 aio_context_release(aio_context
);
2076 /* make a BlockDriverState anonymous by removing from bdrv_state and
2077 * graph_bdrv_state list.
2078 Also, NULL terminate the device_name to prevent double remove */
2079 void bdrv_make_anon(BlockDriverState
*bs
)
2082 * Take care to remove bs from bdrv_states only when it's actually
2083 * in it. Note that bs->device_list.tqe_prev is initially null,
2084 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2085 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2086 * resetting it to null on remove.
2088 if (bs
->device_list
.tqe_prev
) {
2089 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
2090 bs
->device_list
.tqe_prev
= NULL
;
2092 if (bs
->node_name
[0] != '\0') {
2093 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2095 bs
->node_name
[0] = '\0';
2098 static void bdrv_rebind(BlockDriverState
*bs
)
2100 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
2101 bs
->drv
->bdrv_rebind(bs
);
2105 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2106 BlockDriverState
*bs_src
)
2108 /* move some fields that need to stay attached to the device */
2111 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
2112 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2114 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2116 /* i/o throttled req */
2117 memcpy(&bs_dest
->throttle_state
,
2118 &bs_src
->throttle_state
,
2119 sizeof(ThrottleState
));
2120 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2121 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2122 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
2125 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2126 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2129 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2130 bs_dest
->iostatus
= bs_src
->iostatus
;
2133 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2135 /* reference count */
2136 bs_dest
->refcnt
= bs_src
->refcnt
;
2139 bs_dest
->job
= bs_src
->job
;
2141 /* keep the same entry in bdrv_states */
2142 bs_dest
->device_list
= bs_src
->device_list
;
2143 bs_dest
->blk
= bs_src
->blk
;
2145 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2146 sizeof(bs_dest
->op_blockers
));
2150 * Swap bs contents for two image chains while they are live,
2151 * while keeping required fields on the BlockDriverState that is
2152 * actually attached to a device.
2154 * This will modify the BlockDriverState fields, and swap contents
2155 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2157 * bs_new must not be attached to a BlockBackend.
2159 * This function does not create any image files.
2161 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2163 BlockDriverState tmp
;
2165 /* The code needs to swap the node_name but simply swapping node_list won't
2166 * work so first remove the nodes from the graph list, do the swap then
2167 * insert them back if needed.
2169 if (bs_new
->node_name
[0] != '\0') {
2170 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2172 if (bs_old
->node_name
[0] != '\0') {
2173 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2176 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2177 assert(!bs_new
->blk
);
2178 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2179 assert(bs_new
->job
== NULL
);
2180 assert(bs_new
->io_limits_enabled
== false);
2181 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2187 /* there are some fields that should not be swapped, move them back */
2188 bdrv_move_feature_fields(&tmp
, bs_old
);
2189 bdrv_move_feature_fields(bs_old
, bs_new
);
2190 bdrv_move_feature_fields(bs_new
, &tmp
);
2192 /* bs_new must remain unattached */
2193 assert(!bs_new
->blk
);
2195 /* Check a few fields that should remain attached to the device */
2196 assert(bs_new
->job
== NULL
);
2197 assert(bs_new
->io_limits_enabled
== false);
2198 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2200 /* insert the nodes back into the graph node list if needed */
2201 if (bs_new
->node_name
[0] != '\0') {
2202 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2204 if (bs_old
->node_name
[0] != '\0') {
2205 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2208 bdrv_rebind(bs_new
);
2209 bdrv_rebind(bs_old
);
2213 * Add new bs contents at the top of an image chain while the chain is
2214 * live, while keeping required fields on the top layer.
2216 * This will modify the BlockDriverState fields, and swap contents
2217 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2219 * bs_new must not be attached to a BlockBackend.
2221 * This function does not create any image files.
2223 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2225 bdrv_swap(bs_new
, bs_top
);
2227 /* The contents of 'tmp' will become bs_top, as we are
2228 * swapping bs_new and bs_top contents. */
2229 bdrv_set_backing_hd(bs_top
, bs_new
);
2232 static void bdrv_delete(BlockDriverState
*bs
)
2235 assert(bdrv_op_blocker_is_empty(bs
));
2236 assert(!bs
->refcnt
);
2237 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2241 /* remove from list, if necessary */
2248 * Run consistency checks on an image
2250 * Returns 0 if the check could be completed (it doesn't mean that the image is
2251 * free of errors) or -errno when an internal error occurred. The results of the
2252 * check are stored in res.
2254 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2256 if (bs
->drv
== NULL
) {
2259 if (bs
->drv
->bdrv_check
== NULL
) {
2263 memset(res
, 0, sizeof(*res
));
2264 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2267 #define COMMIT_BUF_SECTORS 2048
2269 /* commit COW file into the raw image */
2270 int bdrv_commit(BlockDriverState
*bs
)
2272 BlockDriver
*drv
= bs
->drv
;
2273 int64_t sector
, total_sectors
, length
, backing_length
;
2274 int n
, ro
, open_flags
;
2276 uint8_t *buf
= NULL
;
2281 if (!bs
->backing_hd
) {
2285 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2286 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2290 ro
= bs
->backing_hd
->read_only
;
2291 open_flags
= bs
->backing_hd
->open_flags
;
2294 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2299 length
= bdrv_getlength(bs
);
2305 backing_length
= bdrv_getlength(bs
->backing_hd
);
2306 if (backing_length
< 0) {
2307 ret
= backing_length
;
2311 /* If our top snapshot is larger than the backing file image,
2312 * grow the backing file image if possible. If not possible,
2313 * we must return an error */
2314 if (length
> backing_length
) {
2315 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2321 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2323 /* qemu_try_blockalign() for bs will choose an alignment that works for
2324 * bs->backing_hd as well, so no need to compare the alignment manually. */
2325 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2331 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2332 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2337 ret
= bdrv_read(bs
, sector
, buf
, n
);
2342 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2349 if (drv
->bdrv_make_empty
) {
2350 ret
= drv
->bdrv_make_empty(bs
);
2358 * Make sure all data we wrote to the backing device is actually
2361 if (bs
->backing_hd
) {
2362 bdrv_flush(bs
->backing_hd
);
2370 /* ignoring error return here */
2371 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2377 int bdrv_commit_all(void)
2379 BlockDriverState
*bs
;
2381 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2382 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2384 aio_context_acquire(aio_context
);
2385 if (bs
->drv
&& bs
->backing_hd
) {
2386 int ret
= bdrv_commit(bs
);
2388 aio_context_release(aio_context
);
2392 aio_context_release(aio_context
);
2398 * Remove an active request from the tracked requests list
2400 * This function should be called when a tracked request is completing.
2402 static void tracked_request_end(BdrvTrackedRequest
*req
)
2404 if (req
->serialising
) {
2405 req
->bs
->serialising_in_flight
--;
2408 QLIST_REMOVE(req
, list
);
2409 qemu_co_queue_restart_all(&req
->wait_queue
);
2413 * Add an active request to the tracked requests list
2415 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2416 BlockDriverState
*bs
,
2418 unsigned int bytes
, bool is_write
)
2420 *req
= (BdrvTrackedRequest
){
2424 .is_write
= is_write
,
2425 .co
= qemu_coroutine_self(),
2426 .serialising
= false,
2427 .overlap_offset
= offset
,
2428 .overlap_bytes
= bytes
,
2431 qemu_co_queue_init(&req
->wait_queue
);
2433 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2436 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2438 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2439 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2442 if (!req
->serialising
) {
2443 req
->bs
->serialising_in_flight
++;
2444 req
->serialising
= true;
2447 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2448 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2452 * Round a region to cluster boundaries
2454 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2455 int64_t sector_num
, int nb_sectors
,
2456 int64_t *cluster_sector_num
,
2457 int *cluster_nb_sectors
)
2459 BlockDriverInfo bdi
;
2461 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2462 *cluster_sector_num
= sector_num
;
2463 *cluster_nb_sectors
= nb_sectors
;
2465 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2466 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2467 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2472 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2474 BlockDriverInfo bdi
;
2477 ret
= bdrv_get_info(bs
, &bdi
);
2478 if (ret
< 0 || bdi
.cluster_size
== 0) {
2479 return bs
->request_alignment
;
2481 return bdi
.cluster_size
;
2485 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2486 int64_t offset
, unsigned int bytes
)
2489 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2493 if (req
->overlap_offset
>= offset
+ bytes
) {
2499 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2501 BlockDriverState
*bs
= self
->bs
;
2502 BdrvTrackedRequest
*req
;
2504 bool waited
= false;
2506 if (!bs
->serialising_in_flight
) {
2512 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2513 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2516 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2517 self
->overlap_bytes
))
2519 /* Hitting this means there was a reentrant request, for
2520 * example, a block driver issuing nested requests. This must
2521 * never happen since it means deadlock.
2523 assert(qemu_coroutine_self() != req
->co
);
2525 /* If the request is already (indirectly) waiting for us, or
2526 * will wait for us as soon as it wakes up, then just go on
2527 * (instead of producing a deadlock in the former case). */
2528 if (!req
->waiting_for
) {
2529 self
->waiting_for
= req
;
2530 qemu_co_queue_wait(&req
->wait_queue
);
2531 self
->waiting_for
= NULL
;
2546 * -EINVAL - backing format specified, but no file
2547 * -ENOSPC - can't update the backing file because no space is left in the
2549 * -ENOTSUP - format driver doesn't support changing the backing file
2551 int bdrv_change_backing_file(BlockDriverState
*bs
,
2552 const char *backing_file
, const char *backing_fmt
)
2554 BlockDriver
*drv
= bs
->drv
;
2557 /* Backing file format doesn't make sense without a backing file */
2558 if (backing_fmt
&& !backing_file
) {
2562 if (drv
->bdrv_change_backing_file
!= NULL
) {
2563 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2569 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2570 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2576 * Finds the image layer in the chain that has 'bs' as its backing file.
2578 * active is the current topmost image.
2580 * Returns NULL if bs is not found in active's image chain,
2581 * or if active == bs.
2583 * Returns the bottommost base image if bs == NULL.
2585 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2586 BlockDriverState
*bs
)
2588 while (active
&& bs
!= active
->backing_hd
) {
2589 active
= active
->backing_hd
;
2595 /* Given a BDS, searches for the base layer. */
2596 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2598 return bdrv_find_overlay(bs
, NULL
);
2601 typedef struct BlkIntermediateStates
{
2602 BlockDriverState
*bs
;
2603 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2604 } BlkIntermediateStates
;
2608 * Drops images above 'base' up to and including 'top', and sets the image
2609 * above 'top' to have base as its backing file.
2611 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2612 * information in 'bs' can be properly updated.
2614 * E.g., this will convert the following chain:
2615 * bottom <- base <- intermediate <- top <- active
2619 * bottom <- base <- active
2621 * It is allowed for bottom==base, in which case it converts:
2623 * base <- intermediate <- top <- active
2629 * If backing_file_str is non-NULL, it will be used when modifying top's
2630 * overlay image metadata.
2633 * if active == top, that is considered an error
2636 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2637 BlockDriverState
*base
, const char *backing_file_str
)
2639 BlockDriverState
*intermediate
;
2640 BlockDriverState
*base_bs
= NULL
;
2641 BlockDriverState
*new_top_bs
= NULL
;
2642 BlkIntermediateStates
*intermediate_state
, *next
;
2645 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2646 QSIMPLEQ_INIT(&states_to_delete
);
2648 if (!top
->drv
|| !base
->drv
) {
2652 new_top_bs
= bdrv_find_overlay(active
, top
);
2654 if (new_top_bs
== NULL
) {
2655 /* we could not find the image above 'top', this is an error */
2659 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2660 * to do, no intermediate images */
2661 if (new_top_bs
->backing_hd
== base
) {
2668 /* now we will go down through the list, and add each BDS we find
2669 * into our deletion queue, until we hit the 'base'
2671 while (intermediate
) {
2672 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2673 intermediate_state
->bs
= intermediate
;
2674 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2676 if (intermediate
->backing_hd
== base
) {
2677 base_bs
= intermediate
->backing_hd
;
2680 intermediate
= intermediate
->backing_hd
;
2682 if (base_bs
== NULL
) {
2683 /* something went wrong, we did not end at the base. safely
2684 * unravel everything, and exit with error */
2688 /* success - we can delete the intermediate states, and link top->base */
2689 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2690 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2691 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2695 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2697 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2698 /* so that bdrv_close() does not recursively close the chain */
2699 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2700 bdrv_unref(intermediate_state
->bs
);
2705 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2706 g_free(intermediate_state
);
2712 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2715 if (size
> BDRV_REQUEST_MAX_SECTORS
<< BDRV_SECTOR_BITS
) {
2719 if (!bdrv_is_inserted(bs
)) {
2730 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2733 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2737 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2738 nb_sectors
* BDRV_SECTOR_SIZE
);
2741 typedef struct RwCo
{
2742 BlockDriverState
*bs
;
2747 BdrvRequestFlags flags
;
2750 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2752 RwCo
*rwco
= opaque
;
2754 if (!rwco
->is_write
) {
2755 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2756 rwco
->qiov
->size
, rwco
->qiov
,
2759 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2760 rwco
->qiov
->size
, rwco
->qiov
,
2766 * Process a vectored synchronous request using coroutines
2768 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2769 QEMUIOVector
*qiov
, bool is_write
,
2770 BdrvRequestFlags flags
)
2777 .is_write
= is_write
,
2783 * In sync call context, when the vcpu is blocked, this throttling timer
2784 * will not fire; so the I/O throttling function has to be disabled here
2785 * if it has been enabled.
2787 if (bs
->io_limits_enabled
) {
2788 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2789 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2790 bdrv_io_limits_disable(bs
);
2793 if (qemu_in_coroutine()) {
2794 /* Fast-path if already in coroutine context */
2795 bdrv_rw_co_entry(&rwco
);
2797 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2799 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2800 qemu_coroutine_enter(co
, &rwco
);
2801 while (rwco
.ret
== NOT_DONE
) {
2802 aio_poll(aio_context
, true);
2809 * Process a synchronous request using coroutines
2811 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2812 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2815 struct iovec iov
= {
2816 .iov_base
= (void *)buf
,
2817 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2820 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2824 qemu_iovec_init_external(&qiov
, &iov
, 1);
2825 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2826 &qiov
, is_write
, flags
);
2829 /* return < 0 if error. See bdrv_write() for the return codes */
2830 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2831 uint8_t *buf
, int nb_sectors
)
2833 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2836 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2837 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2838 uint8_t *buf
, int nb_sectors
)
2843 enabled
= bs
->io_limits_enabled
;
2844 bs
->io_limits_enabled
= false;
2845 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2846 bs
->io_limits_enabled
= enabled
;
2850 /* Return < 0 if error. Important errors are:
2851 -EIO generic I/O error (may happen for all errors)
2852 -ENOMEDIUM No media inserted.
2853 -EINVAL Invalid sector number or nb_sectors
2854 -EACCES Trying to write a read-only device
2856 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2857 const uint8_t *buf
, int nb_sectors
)
2859 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2862 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2863 int nb_sectors
, BdrvRequestFlags flags
)
2865 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2866 BDRV_REQ_ZERO_WRITE
| flags
);
2870 * Completely zero out a block device with the help of bdrv_write_zeroes.
2871 * The operation is sped up by checking the block status and only writing
2872 * zeroes to the device if they currently do not return zeroes. Optional
2873 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2875 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2877 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2879 int64_t target_sectors
, ret
, nb_sectors
, sector_num
= 0;
2882 target_sectors
= bdrv_nb_sectors(bs
);
2883 if (target_sectors
< 0) {
2884 return target_sectors
;
2888 nb_sectors
= MIN(target_sectors
- sector_num
, BDRV_REQUEST_MAX_SECTORS
);
2889 if (nb_sectors
<= 0) {
2892 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2894 error_report("error getting block status at sector %" PRId64
": %s",
2895 sector_num
, strerror(-ret
));
2898 if (ret
& BDRV_BLOCK_ZERO
) {
2902 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2904 error_report("error writing zeroes at sector %" PRId64
": %s",
2905 sector_num
, strerror(-ret
));
2912 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2915 struct iovec iov
= {
2916 .iov_base
= (void *)buf
,
2925 qemu_iovec_init_external(&qiov
, &iov
, 1);
2926 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2934 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2938 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2946 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2947 const void *buf
, int bytes
)
2950 struct iovec iov
= {
2951 .iov_base
= (void *) buf
,
2959 qemu_iovec_init_external(&qiov
, &iov
, 1);
2960 return bdrv_pwritev(bs
, offset
, &qiov
);
2964 * Writes to the file and ensures that no writes are reordered across this
2965 * request (acts as a barrier)
2967 * Returns 0 on success, -errno in error cases.
2969 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2970 const void *buf
, int count
)
2974 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2979 /* No flush needed for cache modes that already do it */
2980 if (bs
->enable_write_cache
) {
2987 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2988 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2990 /* Perform I/O through a temporary buffer so that users who scribble over
2991 * their read buffer while the operation is in progress do not end up
2992 * modifying the image file. This is critical for zero-copy guest I/O
2993 * where anything might happen inside guest memory.
2995 void *bounce_buffer
;
2997 BlockDriver
*drv
= bs
->drv
;
2999 QEMUIOVector bounce_qiov
;
3000 int64_t cluster_sector_num
;
3001 int cluster_nb_sectors
;
3005 /* Cover entire cluster so no additional backing file I/O is required when
3006 * allocating cluster in the image file.
3008 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
3009 &cluster_sector_num
, &cluster_nb_sectors
);
3011 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
3012 cluster_sector_num
, cluster_nb_sectors
);
3014 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
3015 iov
.iov_base
= bounce_buffer
= qemu_try_blockalign(bs
, iov
.iov_len
);
3016 if (bounce_buffer
== NULL
) {
3021 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
3023 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
3029 if (drv
->bdrv_co_write_zeroes
&&
3030 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
3031 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
3032 cluster_nb_sectors
, 0);
3034 /* This does not change the data on the disk, it is not necessary
3035 * to flush even in cache=writethrough mode.
3037 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
3042 /* It might be okay to ignore write errors for guest requests. If this
3043 * is a deliberate copy-on-read then we don't want to ignore the error.
3044 * Simply report it in all cases.
3049 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
3050 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
3051 nb_sectors
* BDRV_SECTOR_SIZE
);
3054 qemu_vfree(bounce_buffer
);
3059 * Forwards an already correctly aligned request to the BlockDriver. This
3060 * handles copy on read and zeroing after EOF; any other features must be
3061 * implemented by the caller.
3063 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
3064 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3065 int64_t align
, QEMUIOVector
*qiov
, int flags
)
3067 BlockDriver
*drv
= bs
->drv
;
3070 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3071 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3073 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3074 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3075 assert(!qiov
|| bytes
== qiov
->size
);
3077 /* Handle Copy on Read and associated serialisation */
3078 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3079 /* If we touch the same cluster it counts as an overlap. This
3080 * guarantees that allocating writes will be serialized and not race
3081 * with each other for the same cluster. For example, in copy-on-read
3082 * it ensures that the CoR read and write operations are atomic and
3083 * guest writes cannot interleave between them. */
3084 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3087 wait_serialising_requests(req
);
3089 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3092 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3097 if (!ret
|| pnum
!= nb_sectors
) {
3098 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3103 /* Forward the request to the BlockDriver */
3104 if (!bs
->zero_beyond_eof
) {
3105 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3107 /* Read zeros after EOF */
3108 int64_t total_sectors
, max_nb_sectors
;
3110 total_sectors
= bdrv_nb_sectors(bs
);
3111 if (total_sectors
< 0) {
3112 ret
= total_sectors
;
3116 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3117 align
>> BDRV_SECTOR_BITS
);
3118 if (nb_sectors
< max_nb_sectors
) {
3119 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3120 } else if (max_nb_sectors
> 0) {
3121 QEMUIOVector local_qiov
;
3123 qemu_iovec_init(&local_qiov
, qiov
->niov
);
3124 qemu_iovec_concat(&local_qiov
, qiov
, 0,
3125 max_nb_sectors
* BDRV_SECTOR_SIZE
);
3127 ret
= drv
->bdrv_co_readv(bs
, sector_num
, max_nb_sectors
,
3130 qemu_iovec_destroy(&local_qiov
);
3135 /* Reading beyond end of file is supposed to produce zeroes */
3136 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3137 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3138 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3140 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3148 static inline uint64_t bdrv_get_align(BlockDriverState
*bs
)
3150 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3151 return MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3154 static inline bool bdrv_req_is_aligned(BlockDriverState
*bs
,
3155 int64_t offset
, size_t bytes
)
3157 int64_t align
= bdrv_get_align(bs
);
3158 return !(offset
& (align
- 1) || (bytes
& (align
- 1)));
3162 * Handle a read request in coroutine context
3164 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3165 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3166 BdrvRequestFlags flags
)
3168 BlockDriver
*drv
= bs
->drv
;
3169 BdrvTrackedRequest req
;
3171 uint64_t align
= bdrv_get_align(bs
);
3172 uint8_t *head_buf
= NULL
;
3173 uint8_t *tail_buf
= NULL
;
3174 QEMUIOVector local_qiov
;
3175 bool use_local_qiov
= false;
3182 ret
= bdrv_check_byte_request(bs
, offset
, bytes
);
3187 if (bs
->copy_on_read
) {
3188 flags
|= BDRV_REQ_COPY_ON_READ
;
3191 /* throttling disk I/O */
3192 if (bs
->io_limits_enabled
) {
3193 bdrv_io_limits_intercept(bs
, bytes
, false);
3196 /* Align read if necessary by padding qiov */
3197 if (offset
& (align
- 1)) {
3198 head_buf
= qemu_blockalign(bs
, align
);
3199 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3200 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3201 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3202 use_local_qiov
= true;
3204 bytes
+= offset
& (align
- 1);
3205 offset
= offset
& ~(align
- 1);
3208 if ((offset
+ bytes
) & (align
- 1)) {
3209 if (!use_local_qiov
) {
3210 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3211 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3212 use_local_qiov
= true;
3214 tail_buf
= qemu_blockalign(bs
, align
);
3215 qemu_iovec_add(&local_qiov
, tail_buf
,
3216 align
- ((offset
+ bytes
) & (align
- 1)));
3218 bytes
= ROUND_UP(bytes
, align
);
3221 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3222 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3223 use_local_qiov
? &local_qiov
: qiov
,
3225 tracked_request_end(&req
);
3227 if (use_local_qiov
) {
3228 qemu_iovec_destroy(&local_qiov
);
3229 qemu_vfree(head_buf
);
3230 qemu_vfree(tail_buf
);
3236 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3237 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3238 BdrvRequestFlags flags
)
3240 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3244 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3245 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3248 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3249 int nb_sectors
, QEMUIOVector
*qiov
)
3251 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3253 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3256 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3257 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3259 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3261 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3262 BDRV_REQ_COPY_ON_READ
);
3265 #define MAX_WRITE_ZEROES_BOUNCE_BUFFER 32768
3267 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3268 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3270 BlockDriver
*drv
= bs
->drv
;
3272 struct iovec iov
= {0};
3275 int max_write_zeroes
= MIN_NON_ZERO(bs
->bl
.max_write_zeroes
,
3276 BDRV_REQUEST_MAX_SECTORS
);
3278 while (nb_sectors
> 0 && !ret
) {
3279 int num
= nb_sectors
;
3281 /* Align request. Block drivers can expect the "bulk" of the request
3284 if (bs
->bl
.write_zeroes_alignment
3285 && num
> bs
->bl
.write_zeroes_alignment
) {
3286 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3287 /* Make a small request up to the first aligned sector. */
3288 num
= bs
->bl
.write_zeroes_alignment
;
3289 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3290 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3291 /* Shorten the request to the last aligned sector. num cannot
3292 * underflow because num > bs->bl.write_zeroes_alignment.
3294 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3298 /* limit request size */
3299 if (num
> max_write_zeroes
) {
3300 num
= max_write_zeroes
;
3304 /* First try the efficient write zeroes operation */
3305 if (drv
->bdrv_co_write_zeroes
) {
3306 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3309 if (ret
== -ENOTSUP
) {
3310 /* Fall back to bounce buffer if write zeroes is unsupported */
3311 int max_xfer_len
= MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
3312 MAX_WRITE_ZEROES_BOUNCE_BUFFER
);
3313 num
= MIN(num
, max_xfer_len
);
3314 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3315 if (iov
.iov_base
== NULL
) {
3316 iov
.iov_base
= qemu_try_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3317 if (iov
.iov_base
== NULL
) {
3321 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3323 qemu_iovec_init_external(&qiov
, &iov
, 1);
3325 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3327 /* Keep bounce buffer around if it is big enough for all
3328 * all future requests.
3330 if (num
< max_xfer_len
) {
3331 qemu_vfree(iov
.iov_base
);
3332 iov
.iov_base
= NULL
;
3341 qemu_vfree(iov
.iov_base
);
3346 * Forwards an already correctly aligned write request to the BlockDriver.
3348 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3349 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3350 QEMUIOVector
*qiov
, int flags
)
3352 BlockDriver
*drv
= bs
->drv
;
3356 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3357 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3359 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3360 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3361 assert(!qiov
|| bytes
== qiov
->size
);
3363 waited
= wait_serialising_requests(req
);
3364 assert(!waited
|| !req
->serialising
);
3365 assert(req
->overlap_offset
<= offset
);
3366 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3368 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3370 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3371 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3372 qemu_iovec_is_zero(qiov
)) {
3373 flags
|= BDRV_REQ_ZERO_WRITE
;
3374 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3375 flags
|= BDRV_REQ_MAY_UNMAP
;
3380 /* Do nothing, write notifier decided to fail this request */
3381 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3382 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3383 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3385 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3386 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3388 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3390 if (ret
== 0 && !bs
->enable_write_cache
) {
3391 ret
= bdrv_co_flush(bs
);
3394 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3396 block_acct_highest_sector(&bs
->stats
, sector_num
, nb_sectors
);
3399 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3406 * Handle a write request in coroutine context
3408 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3409 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3410 BdrvRequestFlags flags
)
3412 BdrvTrackedRequest req
;
3413 uint64_t align
= bdrv_get_align(bs
);
3414 uint8_t *head_buf
= NULL
;
3415 uint8_t *tail_buf
= NULL
;
3416 QEMUIOVector local_qiov
;
3417 bool use_local_qiov
= false;
3423 if (bs
->read_only
) {
3427 ret
= bdrv_check_byte_request(bs
, offset
, bytes
);
3432 /* throttling disk I/O */
3433 if (bs
->io_limits_enabled
) {
3434 bdrv_io_limits_intercept(bs
, bytes
, true);
3438 * Align write if necessary by performing a read-modify-write cycle.
3439 * Pad qiov with the read parts and be sure to have a tracked request not
3440 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3442 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3444 if (offset
& (align
- 1)) {
3445 QEMUIOVector head_qiov
;
3446 struct iovec head_iov
;
3448 mark_request_serialising(&req
, align
);
3449 wait_serialising_requests(&req
);
3451 head_buf
= qemu_blockalign(bs
, align
);
3452 head_iov
= (struct iovec
) {
3453 .iov_base
= head_buf
,
3456 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3458 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3459 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3460 align
, &head_qiov
, 0);
3464 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3466 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3467 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3468 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3469 use_local_qiov
= true;
3471 bytes
+= offset
& (align
- 1);
3472 offset
= offset
& ~(align
- 1);
3475 if ((offset
+ bytes
) & (align
- 1)) {
3476 QEMUIOVector tail_qiov
;
3477 struct iovec tail_iov
;
3481 mark_request_serialising(&req
, align
);
3482 waited
= wait_serialising_requests(&req
);
3483 assert(!waited
|| !use_local_qiov
);
3485 tail_buf
= qemu_blockalign(bs
, align
);
3486 tail_iov
= (struct iovec
) {
3487 .iov_base
= tail_buf
,
3490 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3492 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3493 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3494 align
, &tail_qiov
, 0);
3498 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3500 if (!use_local_qiov
) {
3501 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3502 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3503 use_local_qiov
= true;
3506 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3507 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3509 bytes
= ROUND_UP(bytes
, align
);
3512 if (use_local_qiov
) {
3513 /* Local buffer may have non-zero data. */
3514 flags
&= ~BDRV_REQ_ZERO_WRITE
;
3516 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3517 use_local_qiov
? &local_qiov
: qiov
,
3521 tracked_request_end(&req
);
3523 if (use_local_qiov
) {
3524 qemu_iovec_destroy(&local_qiov
);
3526 qemu_vfree(head_buf
);
3527 qemu_vfree(tail_buf
);
3532 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3533 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3534 BdrvRequestFlags flags
)
3536 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3540 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3541 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3544 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3545 int nb_sectors
, QEMUIOVector
*qiov
)
3547 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3549 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3552 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3553 int64_t sector_num
, int nb_sectors
,
3554 BdrvRequestFlags flags
)
3558 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3560 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3561 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3563 if (bdrv_req_is_aligned(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3564 nb_sectors
<< BDRV_SECTOR_BITS
)) {
3565 ret
= bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3566 BDRV_REQ_ZERO_WRITE
| flags
);
3569 QEMUIOVector local_qiov
;
3570 size_t bytes
= nb_sectors
<< BDRV_SECTOR_BITS
;
3572 buf
= qemu_memalign(bdrv_opt_mem_align(bs
), bytes
);
3573 memset(buf
, 0, bytes
);
3574 qemu_iovec_init(&local_qiov
, 1);
3575 qemu_iovec_add(&local_qiov
, buf
, bytes
);
3577 ret
= bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, &local_qiov
,
3578 BDRV_REQ_ZERO_WRITE
| flags
);
3585 * Truncate file to 'offset' bytes (needed only for file protocols)
3587 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3589 BlockDriver
*drv
= bs
->drv
;
3593 if (!drv
->bdrv_truncate
)
3598 ret
= drv
->bdrv_truncate(bs
, offset
);
3600 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3602 blk_dev_resize_cb(bs
->blk
);
3609 * Length of a allocated file in bytes. Sparse files are counted by actual
3610 * allocated space. Return < 0 if error or unknown.
3612 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3614 BlockDriver
*drv
= bs
->drv
;
3618 if (drv
->bdrv_get_allocated_file_size
) {
3619 return drv
->bdrv_get_allocated_file_size(bs
);
3622 return bdrv_get_allocated_file_size(bs
->file
);
3628 * Return number of sectors on success, -errno on error.
3630 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
3632 BlockDriver
*drv
= bs
->drv
;
3637 if (drv
->has_variable_length
) {
3638 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3643 return bs
->total_sectors
;
3647 * Return length in bytes on success, -errno on error.
3648 * The length is always a multiple of BDRV_SECTOR_SIZE.
3650 int64_t bdrv_getlength(BlockDriverState
*bs
)
3652 int64_t ret
= bdrv_nb_sectors(bs
);
3654 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
3657 /* return 0 as number of sectors if no device present or error */
3658 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3660 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
3662 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
3665 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3666 BlockdevOnError on_write_error
)
3668 bs
->on_read_error
= on_read_error
;
3669 bs
->on_write_error
= on_write_error
;
3672 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3674 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3677 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3679 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3682 case BLOCKDEV_ON_ERROR_ENOSPC
:
3683 return (error
== ENOSPC
) ?
3684 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
3685 case BLOCKDEV_ON_ERROR_STOP
:
3686 return BLOCK_ERROR_ACTION_STOP
;
3687 case BLOCKDEV_ON_ERROR_REPORT
:
3688 return BLOCK_ERROR_ACTION_REPORT
;
3689 case BLOCKDEV_ON_ERROR_IGNORE
:
3690 return BLOCK_ERROR_ACTION_IGNORE
;
3696 static void send_qmp_error_event(BlockDriverState
*bs
,
3697 BlockErrorAction action
,
3698 bool is_read
, int error
)
3700 IoOperationType optype
;
3702 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
3703 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
3704 bdrv_iostatus_is_enabled(bs
),
3705 error
== ENOSPC
, strerror(error
),
3709 /* This is done by device models because, while the block layer knows
3710 * about the error, it does not know whether an operation comes from
3711 * the device or the block layer (from a job, for example).
3713 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3714 bool is_read
, int error
)
3718 if (action
== BLOCK_ERROR_ACTION_STOP
) {
3719 /* First set the iostatus, so that "info block" returns an iostatus
3720 * that matches the events raised so far (an additional error iostatus
3721 * is fine, but not a lost one).
3723 bdrv_iostatus_set_err(bs
, error
);
3725 /* Then raise the request to stop the VM and the event.
3726 * qemu_system_vmstop_request_prepare has two effects. First,
3727 * it ensures that the STOP event always comes after the
3728 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3729 * can observe the STOP event and do a "cont" before the STOP
3730 * event is issued, the VM will not stop. In this case, vm_start()
3731 * also ensures that the STOP/RESUME pair of events is emitted.
3733 qemu_system_vmstop_request_prepare();
3734 send_qmp_error_event(bs
, action
, is_read
, error
);
3735 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
3737 send_qmp_error_event(bs
, action
, is_read
, error
);
3741 int bdrv_is_read_only(BlockDriverState
*bs
)
3743 return bs
->read_only
;
3746 int bdrv_is_sg(BlockDriverState
*bs
)
3751 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3753 return bs
->enable_write_cache
;
3756 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3758 bs
->enable_write_cache
= wce
;
3760 /* so a reopen() will preserve wce */
3762 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3764 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3768 int bdrv_is_encrypted(BlockDriverState
*bs
)
3770 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3772 return bs
->encrypted
;
3775 int bdrv_key_required(BlockDriverState
*bs
)
3777 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3779 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3781 return (bs
->encrypted
&& !bs
->valid_key
);
3784 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3787 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3788 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3794 if (!bs
->encrypted
) {
3796 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3799 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3802 } else if (!bs
->valid_key
) {
3805 /* call the change callback now, we skipped it on open */
3806 blk_dev_change_media_cb(bs
->blk
, true);
3813 * Provide an encryption key for @bs.
3814 * If @key is non-null:
3815 * If @bs is not encrypted, fail.
3816 * Else if the key is invalid, fail.
3817 * Else set @bs's key to @key, replacing the existing key, if any.
3819 * If @bs is encrypted and still lacks a key, fail.
3821 * On failure, store an error object through @errp if non-null.
3823 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
3826 if (!bdrv_is_encrypted(bs
)) {
3827 error_setg(errp
, "Node '%s' is not encrypted",
3828 bdrv_get_device_or_node_name(bs
));
3829 } else if (bdrv_set_key(bs
, key
) < 0) {
3830 error_set(errp
, QERR_INVALID_PASSWORD
);
3833 if (bdrv_key_required(bs
)) {
3834 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
3835 "'%s' (%s) is encrypted",
3836 bdrv_get_device_or_node_name(bs
),
3837 bdrv_get_encrypted_filename(bs
));
3842 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3844 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3847 static int qsort_strcmp(const void *a
, const void *b
)
3849 return strcmp(a
, b
);
3852 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3858 const char **formats
= NULL
;
3860 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3861 if (drv
->format_name
) {
3864 while (formats
&& i
&& !found
) {
3865 found
= !strcmp(formats
[--i
], drv
->format_name
);
3869 formats
= g_renew(const char *, formats
, count
+ 1);
3870 formats
[count
++] = drv
->format_name
;
3875 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
3877 for (i
= 0; i
< count
; i
++) {
3878 it(opaque
, formats
[i
]);
3884 /* This function is to find a node in the bs graph */
3885 BlockDriverState
*bdrv_find_node(const char *node_name
)
3887 BlockDriverState
*bs
;
3891 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3892 if (!strcmp(node_name
, bs
->node_name
)) {
3899 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3900 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3902 BlockDeviceInfoList
*list
, *entry
;
3903 BlockDriverState
*bs
;
3906 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3907 entry
= g_malloc0(sizeof(*entry
));
3908 entry
->value
= bdrv_block_device_info(bs
);
3916 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3917 const char *node_name
,
3921 BlockDriverState
*bs
;
3924 blk
= blk_by_name(device
);
3932 bs
= bdrv_find_node(node_name
);
3939 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3940 device
? device
: "",
3941 node_name
? node_name
: "");
3945 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3946 * return false. If either argument is NULL, return false. */
3947 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
3949 while (top
&& top
!= base
) {
3950 top
= top
->backing_hd
;
3956 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
3959 return QTAILQ_FIRST(&graph_bdrv_states
);
3961 return QTAILQ_NEXT(bs
, node_list
);
3964 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3967 return QTAILQ_FIRST(&bdrv_states
);
3969 return QTAILQ_NEXT(bs
, device_list
);
3972 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
3974 return bs
->node_name
;
3977 /* TODO check what callers really want: bs->node_name or blk_name() */
3978 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
3980 return bs
->blk
? blk_name(bs
->blk
) : "";
3983 /* This can be used to identify nodes that might not have a device
3984 * name associated. Since node and device names live in the same
3985 * namespace, the result is unambiguous. The exception is if both are
3986 * absent, then this returns an empty (non-null) string. */
3987 const char *bdrv_get_device_or_node_name(const BlockDriverState
*bs
)
3989 return bs
->blk
? blk_name(bs
->blk
) : bs
->node_name
;
3992 int bdrv_get_flags(BlockDriverState
*bs
)
3994 return bs
->open_flags
;
3997 int bdrv_flush_all(void)
3999 BlockDriverState
*bs
;
4002 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4003 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4006 aio_context_acquire(aio_context
);
4007 ret
= bdrv_flush(bs
);
4008 if (ret
< 0 && !result
) {
4011 aio_context_release(aio_context
);
4017 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
4022 int bdrv_has_zero_init(BlockDriverState
*bs
)
4026 /* If BS is a copy on write image, it is initialized to
4027 the contents of the base image, which may not be zeroes. */
4028 if (bs
->backing_hd
) {
4031 if (bs
->drv
->bdrv_has_zero_init
) {
4032 return bs
->drv
->bdrv_has_zero_init(bs
);
4039 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
4041 BlockDriverInfo bdi
;
4043 if (bs
->backing_hd
) {
4047 if (bdrv_get_info(bs
, &bdi
) == 0) {
4048 return bdi
.unallocated_blocks_are_zero
;
4054 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
4056 BlockDriverInfo bdi
;
4058 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
4062 if (bdrv_get_info(bs
, &bdi
) == 0) {
4063 return bdi
.can_write_zeroes_with_unmap
;
4069 typedef struct BdrvCoGetBlockStatusData
{
4070 BlockDriverState
*bs
;
4071 BlockDriverState
*base
;
4077 } BdrvCoGetBlockStatusData
;
4080 * Returns the allocation status of the specified sectors.
4081 * Drivers not implementing the functionality are assumed to not support
4082 * backing files, hence all their sectors are reported as allocated.
4084 * If 'sector_num' is beyond the end of the disk image the return value is 0
4085 * and 'pnum' is set to 0.
4087 * 'pnum' is set to the number of sectors (including and immediately following
4088 * the specified sector) that are known to be in the same
4089 * allocated/unallocated state.
4091 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
4092 * beyond the end of the disk image it will be clamped.
4094 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
4096 int nb_sectors
, int *pnum
)
4098 int64_t total_sectors
;
4102 total_sectors
= bdrv_nb_sectors(bs
);
4103 if (total_sectors
< 0) {
4104 return total_sectors
;
4107 if (sector_num
>= total_sectors
) {
4112 n
= total_sectors
- sector_num
;
4113 if (n
< nb_sectors
) {
4117 if (!bs
->drv
->bdrv_co_get_block_status
) {
4119 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
;
4120 if (bs
->drv
->protocol_name
) {
4121 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
4126 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4132 if (ret
& BDRV_BLOCK_RAW
) {
4133 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
4134 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4138 if (ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ZERO
)) {
4139 ret
|= BDRV_BLOCK_ALLOCATED
;
4142 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
4143 if (bdrv_unallocated_blocks_are_zero(bs
)) {
4144 ret
|= BDRV_BLOCK_ZERO
;
4145 } else if (bs
->backing_hd
) {
4146 BlockDriverState
*bs2
= bs
->backing_hd
;
4147 int64_t nb_sectors2
= bdrv_nb_sectors(bs2
);
4148 if (nb_sectors2
>= 0 && sector_num
>= nb_sectors2
) {
4149 ret
|= BDRV_BLOCK_ZERO
;
4155 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
4156 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
4159 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4162 /* Ignore errors. This is just providing extra information, it
4163 * is useful but not necessary.
4166 /* !file_pnum indicates an offset at or beyond the EOF; it is
4167 * perfectly valid for the format block driver to point to such
4168 * offsets, so catch it and mark everything as zero */
4169 ret
|= BDRV_BLOCK_ZERO
;
4171 /* Limit request to the range reported by the protocol driver */
4173 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
4181 /* Coroutine wrapper for bdrv_get_block_status() */
4182 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
4184 BdrvCoGetBlockStatusData
*data
= opaque
;
4185 BlockDriverState
*bs
= data
->bs
;
4187 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
4193 * Synchronous wrapper around bdrv_co_get_block_status().
4195 * See bdrv_co_get_block_status() for details.
4197 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
4198 int nb_sectors
, int *pnum
)
4201 BdrvCoGetBlockStatusData data
= {
4203 .sector_num
= sector_num
,
4204 .nb_sectors
= nb_sectors
,
4209 if (qemu_in_coroutine()) {
4210 /* Fast-path if already in coroutine context */
4211 bdrv_get_block_status_co_entry(&data
);
4213 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4215 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
4216 qemu_coroutine_enter(co
, &data
);
4217 while (!data
.done
) {
4218 aio_poll(aio_context
, true);
4224 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
4225 int nb_sectors
, int *pnum
)
4227 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4231 return !!(ret
& BDRV_BLOCK_ALLOCATED
);
4235 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4237 * Return true if the given sector is allocated in any image between
4238 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4239 * sector is allocated in any image of the chain. Return false otherwise.
4241 * 'pnum' is set to the number of sectors (including and immediately following
4242 * the specified sector) that are known to be in the same
4243 * allocated/unallocated state.
4246 int bdrv_is_allocated_above(BlockDriverState
*top
,
4247 BlockDriverState
*base
,
4249 int nb_sectors
, int *pnum
)
4251 BlockDriverState
*intermediate
;
4252 int ret
, n
= nb_sectors
;
4255 while (intermediate
&& intermediate
!= base
) {
4257 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
4267 * [sector_num, nb_sectors] is unallocated on top but intermediate
4270 * [sector_num+x, nr_sectors] allocated.
4272 if (n
> pnum_inter
&&
4273 (intermediate
== top
||
4274 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
4278 intermediate
= intermediate
->backing_hd
;
4285 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
4287 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
4288 return bs
->backing_file
;
4289 else if (bs
->encrypted
)
4290 return bs
->filename
;
4295 void bdrv_get_backing_filename(BlockDriverState
*bs
,
4296 char *filename
, int filename_size
)
4298 pstrcpy(filename
, filename_size
, bs
->backing_file
);
4301 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
4302 const uint8_t *buf
, int nb_sectors
)
4304 BlockDriver
*drv
= bs
->drv
;
4310 if (!drv
->bdrv_write_compressed
) {
4313 ret
= bdrv_check_request(bs
, sector_num
, nb_sectors
);
4318 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
4320 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
4323 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4325 BlockDriver
*drv
= bs
->drv
;
4328 if (!drv
->bdrv_get_info
)
4330 memset(bdi
, 0, sizeof(*bdi
));
4331 return drv
->bdrv_get_info(bs
, bdi
);
4334 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
4336 BlockDriver
*drv
= bs
->drv
;
4337 if (drv
&& drv
->bdrv_get_specific_info
) {
4338 return drv
->bdrv_get_specific_info(bs
);
4343 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4344 int64_t pos
, int size
)
4347 struct iovec iov
= {
4348 .iov_base
= (void *) buf
,
4352 qemu_iovec_init_external(&qiov
, &iov
, 1);
4353 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4356 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4358 BlockDriver
*drv
= bs
->drv
;
4362 } else if (drv
->bdrv_save_vmstate
) {
4363 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4364 } else if (bs
->file
) {
4365 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4371 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4372 int64_t pos
, int size
)
4374 BlockDriver
*drv
= bs
->drv
;
4377 if (drv
->bdrv_load_vmstate
)
4378 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4380 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4384 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4386 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4390 bs
->drv
->bdrv_debug_event(bs
, event
);
4393 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4396 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4400 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4401 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4407 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4409 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4413 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4414 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4420 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4422 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
4426 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4427 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4433 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4435 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4439 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4440 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4446 int bdrv_is_snapshot(BlockDriverState
*bs
)
4448 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4451 /* backing_file can either be relative, or absolute, or a protocol. If it is
4452 * relative, it must be relative to the chain. So, passing in bs->filename
4453 * from a BDS as backing_file should not be done, as that may be relative to
4454 * the CWD rather than the chain. */
4455 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4456 const char *backing_file
)
4458 char *filename_full
= NULL
;
4459 char *backing_file_full
= NULL
;
4460 char *filename_tmp
= NULL
;
4461 int is_protocol
= 0;
4462 BlockDriverState
*curr_bs
= NULL
;
4463 BlockDriverState
*retval
= NULL
;
4465 if (!bs
|| !bs
->drv
|| !backing_file
) {
4469 filename_full
= g_malloc(PATH_MAX
);
4470 backing_file_full
= g_malloc(PATH_MAX
);
4471 filename_tmp
= g_malloc(PATH_MAX
);
4473 is_protocol
= path_has_protocol(backing_file
);
4475 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4477 /* If either of the filename paths is actually a protocol, then
4478 * compare unmodified paths; otherwise make paths relative */
4479 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4480 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4481 retval
= curr_bs
->backing_hd
;
4485 /* If not an absolute filename path, make it relative to the current
4486 * image's filename path */
4487 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4490 /* We are going to compare absolute pathnames */
4491 if (!realpath(filename_tmp
, filename_full
)) {
4495 /* We need to make sure the backing filename we are comparing against
4496 * is relative to the current image filename (or absolute) */
4497 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4498 curr_bs
->backing_file
);
4500 if (!realpath(filename_tmp
, backing_file_full
)) {
4504 if (strcmp(backing_file_full
, filename_full
) == 0) {
4505 retval
= curr_bs
->backing_hd
;
4511 g_free(filename_full
);
4512 g_free(backing_file_full
);
4513 g_free(filename_tmp
);
4517 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4523 if (!bs
->backing_hd
) {
4527 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4530 /**************************************************************/
4533 BlockAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4534 QEMUIOVector
*qiov
, int nb_sectors
,
4535 BlockCompletionFunc
*cb
, void *opaque
)
4537 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4539 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4543 BlockAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4544 QEMUIOVector
*qiov
, int nb_sectors
,
4545 BlockCompletionFunc
*cb
, void *opaque
)
4547 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4549 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4553 BlockAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4554 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4555 BlockCompletionFunc
*cb
, void *opaque
)
4557 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4559 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4560 BDRV_REQ_ZERO_WRITE
| flags
,
4565 typedef struct MultiwriteCB
{
4570 BlockCompletionFunc
*cb
;
4572 QEMUIOVector
*free_qiov
;
4576 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4580 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4581 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4582 if (mcb
->callbacks
[i
].free_qiov
) {
4583 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4585 g_free(mcb
->callbacks
[i
].free_qiov
);
4589 static void multiwrite_cb(void *opaque
, int ret
)
4591 MultiwriteCB
*mcb
= opaque
;
4593 trace_multiwrite_cb(mcb
, ret
);
4595 if (ret
< 0 && !mcb
->error
) {
4599 mcb
->num_requests
--;
4600 if (mcb
->num_requests
== 0) {
4601 multiwrite_user_cb(mcb
);
4606 static int multiwrite_req_compare(const void *a
, const void *b
)
4608 const BlockRequest
*req1
= a
, *req2
= b
;
4611 * Note that we can't simply subtract req2->sector from req1->sector
4612 * here as that could overflow the return value.
4614 if (req1
->sector
> req2
->sector
) {
4616 } else if (req1
->sector
< req2
->sector
) {
4624 * Takes a bunch of requests and tries to merge them. Returns the number of
4625 * requests that remain after merging.
4627 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4628 int num_reqs
, MultiwriteCB
*mcb
)
4632 // Sort requests by start sector
4633 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4635 // Check if adjacent requests touch the same clusters. If so, combine them,
4636 // filling up gaps with zero sectors.
4638 for (i
= 1; i
< num_reqs
; i
++) {
4640 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4642 // Handle exactly sequential writes and overlapping writes.
4643 if (reqs
[i
].sector
<= oldreq_last
) {
4647 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4651 if (bs
->bl
.max_transfer_length
&& reqs
[outidx
].nb_sectors
+
4652 reqs
[i
].nb_sectors
> bs
->bl
.max_transfer_length
) {
4658 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4659 qemu_iovec_init(qiov
,
4660 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4662 // Add the first request to the merged one. If the requests are
4663 // overlapping, drop the last sectors of the first request.
4664 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4665 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4667 // We should need to add any zeros between the two requests
4668 assert (reqs
[i
].sector
<= oldreq_last
);
4670 // Add the second request
4671 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4673 // Add tail of first request, if necessary
4674 if (qiov
->size
< reqs
[outidx
].qiov
->size
) {
4675 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, qiov
->size
,
4676 reqs
[outidx
].qiov
->size
- qiov
->size
);
4679 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4680 reqs
[outidx
].qiov
= qiov
;
4682 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4685 reqs
[outidx
].sector
= reqs
[i
].sector
;
4686 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4687 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4691 block_acct_merge_done(&bs
->stats
, BLOCK_ACCT_WRITE
, num_reqs
- outidx
- 1);
4697 * Submit multiple AIO write requests at once.
4699 * On success, the function returns 0 and all requests in the reqs array have
4700 * been submitted. In error case this function returns -1, and any of the
4701 * requests may or may not be submitted yet. In particular, this means that the
4702 * callback will be called for some of the requests, for others it won't. The
4703 * caller must check the error field of the BlockRequest to wait for the right
4704 * callbacks (if error != 0, no callback will be called).
4706 * The implementation may modify the contents of the reqs array, e.g. to merge
4707 * requests. However, the fields opaque and error are left unmodified as they
4708 * are used to signal failure for a single request to the caller.
4710 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4715 /* don't submit writes if we don't have a medium */
4716 if (bs
->drv
== NULL
) {
4717 for (i
= 0; i
< num_reqs
; i
++) {
4718 reqs
[i
].error
= -ENOMEDIUM
;
4723 if (num_reqs
== 0) {
4727 // Create MultiwriteCB structure
4728 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4729 mcb
->num_requests
= 0;
4730 mcb
->num_callbacks
= num_reqs
;
4732 for (i
= 0; i
< num_reqs
; i
++) {
4733 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4734 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4737 // Check for mergable requests
4738 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4740 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4742 /* Run the aio requests. */
4743 mcb
->num_requests
= num_reqs
;
4744 for (i
= 0; i
< num_reqs
; i
++) {
4745 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4746 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4754 void bdrv_aio_cancel(BlockAIOCB
*acb
)
4757 bdrv_aio_cancel_async(acb
);
4758 while (acb
->refcnt
> 1) {
4759 if (acb
->aiocb_info
->get_aio_context
) {
4760 aio_poll(acb
->aiocb_info
->get_aio_context(acb
), true);
4761 } else if (acb
->bs
) {
4762 aio_poll(bdrv_get_aio_context(acb
->bs
), true);
4767 qemu_aio_unref(acb
);
4770 /* Async version of aio cancel. The caller is not blocked if the acb implements
4771 * cancel_async, otherwise we do nothing and let the request normally complete.
4772 * In either case the completion callback must be called. */
4773 void bdrv_aio_cancel_async(BlockAIOCB
*acb
)
4775 if (acb
->aiocb_info
->cancel_async
) {
4776 acb
->aiocb_info
->cancel_async(acb
);
4780 /**************************************************************/
4781 /* async block device emulation */
4783 typedef struct BlockAIOCBSync
{
4787 /* vector translation state */
4793 static const AIOCBInfo bdrv_em_aiocb_info
= {
4794 .aiocb_size
= sizeof(BlockAIOCBSync
),
4797 static void bdrv_aio_bh_cb(void *opaque
)
4799 BlockAIOCBSync
*acb
= opaque
;
4801 if (!acb
->is_write
&& acb
->ret
>= 0) {
4802 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4804 qemu_vfree(acb
->bounce
);
4805 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4806 qemu_bh_delete(acb
->bh
);
4808 qemu_aio_unref(acb
);
4811 static BlockAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4815 BlockCompletionFunc
*cb
,
4820 BlockAIOCBSync
*acb
;
4822 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4823 acb
->is_write
= is_write
;
4825 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
4826 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_aio_bh_cb
, acb
);
4828 if (acb
->bounce
== NULL
) {
4830 } else if (is_write
) {
4831 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4832 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4834 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4837 qemu_bh_schedule(acb
->bh
);
4839 return &acb
->common
;
4842 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4843 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4844 BlockCompletionFunc
*cb
, void *opaque
)
4846 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4849 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4850 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4851 BlockCompletionFunc
*cb
, void *opaque
)
4853 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4857 typedef struct BlockAIOCBCoroutine
{
4864 } BlockAIOCBCoroutine
;
4866 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4867 .aiocb_size
= sizeof(BlockAIOCBCoroutine
),
4870 static void bdrv_co_complete(BlockAIOCBCoroutine
*acb
)
4872 if (!acb
->need_bh
) {
4873 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4874 qemu_aio_unref(acb
);
4878 static void bdrv_co_em_bh(void *opaque
)
4880 BlockAIOCBCoroutine
*acb
= opaque
;
4882 assert(!acb
->need_bh
);
4883 qemu_bh_delete(acb
->bh
);
4884 bdrv_co_complete(acb
);
4887 static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine
*acb
)
4889 acb
->need_bh
= false;
4890 if (acb
->req
.error
!= -EINPROGRESS
) {
4891 BlockDriverState
*bs
= acb
->common
.bs
;
4893 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4894 qemu_bh_schedule(acb
->bh
);
4898 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4899 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4901 BlockAIOCBCoroutine
*acb
= opaque
;
4902 BlockDriverState
*bs
= acb
->common
.bs
;
4904 if (!acb
->is_write
) {
4905 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4906 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4908 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4909 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4912 bdrv_co_complete(acb
);
4915 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4919 BdrvRequestFlags flags
,
4920 BlockCompletionFunc
*cb
,
4925 BlockAIOCBCoroutine
*acb
;
4927 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4928 acb
->need_bh
= true;
4929 acb
->req
.error
= -EINPROGRESS
;
4930 acb
->req
.sector
= sector_num
;
4931 acb
->req
.nb_sectors
= nb_sectors
;
4932 acb
->req
.qiov
= qiov
;
4933 acb
->req
.flags
= flags
;
4934 acb
->is_write
= is_write
;
4936 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4937 qemu_coroutine_enter(co
, acb
);
4939 bdrv_co_maybe_schedule_bh(acb
);
4940 return &acb
->common
;
4943 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4945 BlockAIOCBCoroutine
*acb
= opaque
;
4946 BlockDriverState
*bs
= acb
->common
.bs
;
4948 acb
->req
.error
= bdrv_co_flush(bs
);
4949 bdrv_co_complete(acb
);
4952 BlockAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4953 BlockCompletionFunc
*cb
, void *opaque
)
4955 trace_bdrv_aio_flush(bs
, opaque
);
4958 BlockAIOCBCoroutine
*acb
;
4960 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4961 acb
->need_bh
= true;
4962 acb
->req
.error
= -EINPROGRESS
;
4964 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4965 qemu_coroutine_enter(co
, acb
);
4967 bdrv_co_maybe_schedule_bh(acb
);
4968 return &acb
->common
;
4971 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4973 BlockAIOCBCoroutine
*acb
= opaque
;
4974 BlockDriverState
*bs
= acb
->common
.bs
;
4976 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4977 bdrv_co_complete(acb
);
4980 BlockAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4981 int64_t sector_num
, int nb_sectors
,
4982 BlockCompletionFunc
*cb
, void *opaque
)
4985 BlockAIOCBCoroutine
*acb
;
4987 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4989 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4990 acb
->need_bh
= true;
4991 acb
->req
.error
= -EINPROGRESS
;
4992 acb
->req
.sector
= sector_num
;
4993 acb
->req
.nb_sectors
= nb_sectors
;
4994 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4995 qemu_coroutine_enter(co
, acb
);
4997 bdrv_co_maybe_schedule_bh(acb
);
4998 return &acb
->common
;
5001 void bdrv_init(void)
5003 module_call_init(MODULE_INIT_BLOCK
);
5006 void bdrv_init_with_whitelist(void)
5008 use_bdrv_whitelist
= 1;
5012 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
5013 BlockCompletionFunc
*cb
, void *opaque
)
5017 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
5018 acb
->aiocb_info
= aiocb_info
;
5021 acb
->opaque
= opaque
;
5026 void qemu_aio_ref(void *p
)
5028 BlockAIOCB
*acb
= p
;
5032 void qemu_aio_unref(void *p
)
5034 BlockAIOCB
*acb
= p
;
5035 assert(acb
->refcnt
> 0);
5036 if (--acb
->refcnt
== 0) {
5037 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
5041 /**************************************************************/
5042 /* Coroutine block device emulation */
5044 typedef struct CoroutineIOCompletion
{
5045 Coroutine
*coroutine
;
5047 } CoroutineIOCompletion
;
5049 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
5051 CoroutineIOCompletion
*co
= opaque
;
5054 qemu_coroutine_enter(co
->coroutine
, NULL
);
5057 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
5058 int nb_sectors
, QEMUIOVector
*iov
,
5061 CoroutineIOCompletion co
= {
5062 .coroutine
= qemu_coroutine_self(),
5067 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
5068 bdrv_co_io_em_complete
, &co
);
5070 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
5071 bdrv_co_io_em_complete
, &co
);
5074 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
5078 qemu_coroutine_yield();
5083 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
5084 int64_t sector_num
, int nb_sectors
,
5087 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
5090 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
5091 int64_t sector_num
, int nb_sectors
,
5094 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
5097 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
5099 RwCo
*rwco
= opaque
;
5101 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
5104 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
5108 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
5112 /* Write back cached data to the OS even with cache=unsafe */
5113 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
5114 if (bs
->drv
->bdrv_co_flush_to_os
) {
5115 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
5121 /* But don't actually force it to the disk with cache=unsafe */
5122 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
5126 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
5127 if (bs
->drv
->bdrv_co_flush_to_disk
) {
5128 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
5129 } else if (bs
->drv
->bdrv_aio_flush
) {
5131 CoroutineIOCompletion co
= {
5132 .coroutine
= qemu_coroutine_self(),
5135 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
5139 qemu_coroutine_yield();
5144 * Some block drivers always operate in either writethrough or unsafe
5145 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
5146 * know how the server works (because the behaviour is hardcoded or
5147 * depends on server-side configuration), so we can't ensure that
5148 * everything is safe on disk. Returning an error doesn't work because
5149 * that would break guests even if the server operates in writethrough
5152 * Let's hope the user knows what he's doing.
5160 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
5161 * in the case of cache=unsafe, so there are no useless flushes.
5164 return bdrv_co_flush(bs
->file
);
5167 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
5169 Error
*local_err
= NULL
;
5176 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
5179 bs
->open_flags
&= ~BDRV_O_INCOMING
;
5181 if (bs
->drv
->bdrv_invalidate_cache
) {
5182 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
5183 } else if (bs
->file
) {
5184 bdrv_invalidate_cache(bs
->file
, &local_err
);
5187 error_propagate(errp
, local_err
);
5191 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
5193 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
5198 void bdrv_invalidate_cache_all(Error
**errp
)
5200 BlockDriverState
*bs
;
5201 Error
*local_err
= NULL
;
5203 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5204 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5206 aio_context_acquire(aio_context
);
5207 bdrv_invalidate_cache(bs
, &local_err
);
5208 aio_context_release(aio_context
);
5210 error_propagate(errp
, local_err
);
5216 int bdrv_flush(BlockDriverState
*bs
)
5224 if (qemu_in_coroutine()) {
5225 /* Fast-path if already in coroutine context */
5226 bdrv_flush_co_entry(&rwco
);
5228 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5230 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
5231 qemu_coroutine_enter(co
, &rwco
);
5232 while (rwco
.ret
== NOT_DONE
) {
5233 aio_poll(aio_context
, true);
5240 typedef struct DiscardCo
{
5241 BlockDriverState
*bs
;
5246 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
5248 DiscardCo
*rwco
= opaque
;
5250 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
5253 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
5256 int max_discard
, ret
;
5262 ret
= bdrv_check_request(bs
, sector_num
, nb_sectors
);
5265 } else if (bs
->read_only
) {
5269 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
5271 /* Do nothing if disabled. */
5272 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
5276 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
5280 max_discard
= MIN_NON_ZERO(bs
->bl
.max_discard
, BDRV_REQUEST_MAX_SECTORS
);
5281 while (nb_sectors
> 0) {
5283 int num
= nb_sectors
;
5286 if (bs
->bl
.discard_alignment
&&
5287 num
>= bs
->bl
.discard_alignment
&&
5288 sector_num
% bs
->bl
.discard_alignment
) {
5289 if (num
> bs
->bl
.discard_alignment
) {
5290 num
= bs
->bl
.discard_alignment
;
5292 num
-= sector_num
% bs
->bl
.discard_alignment
;
5295 /* limit request size */
5296 if (num
> max_discard
) {
5300 if (bs
->drv
->bdrv_co_discard
) {
5301 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
5304 CoroutineIOCompletion co
= {
5305 .coroutine
= qemu_coroutine_self(),
5308 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
5309 bdrv_co_io_em_complete
, &co
);
5313 qemu_coroutine_yield();
5317 if (ret
&& ret
!= -ENOTSUP
) {
5327 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
5332 .sector_num
= sector_num
,
5333 .nb_sectors
= nb_sectors
,
5337 if (qemu_in_coroutine()) {
5338 /* Fast-path if already in coroutine context */
5339 bdrv_discard_co_entry(&rwco
);
5341 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5343 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
5344 qemu_coroutine_enter(co
, &rwco
);
5345 while (rwco
.ret
== NOT_DONE
) {
5346 aio_poll(aio_context
, true);
5353 /**************************************************************/
5354 /* removable device support */
5357 * Return TRUE if the media is present
5359 int bdrv_is_inserted(BlockDriverState
*bs
)
5361 BlockDriver
*drv
= bs
->drv
;
5365 if (!drv
->bdrv_is_inserted
)
5367 return drv
->bdrv_is_inserted(bs
);
5371 * Return whether the media changed since the last call to this
5372 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5374 int bdrv_media_changed(BlockDriverState
*bs
)
5376 BlockDriver
*drv
= bs
->drv
;
5378 if (drv
&& drv
->bdrv_media_changed
) {
5379 return drv
->bdrv_media_changed(bs
);
5385 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5387 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
5389 BlockDriver
*drv
= bs
->drv
;
5390 const char *device_name
;
5392 if (drv
&& drv
->bdrv_eject
) {
5393 drv
->bdrv_eject(bs
, eject_flag
);
5396 device_name
= bdrv_get_device_name(bs
);
5397 if (device_name
[0] != '\0') {
5398 qapi_event_send_device_tray_moved(device_name
,
5399 eject_flag
, &error_abort
);
5404 * Lock or unlock the media (if it is locked, the user won't be able
5405 * to eject it manually).
5407 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5409 BlockDriver
*drv
= bs
->drv
;
5411 trace_bdrv_lock_medium(bs
, locked
);
5413 if (drv
&& drv
->bdrv_lock_medium
) {
5414 drv
->bdrv_lock_medium(bs
, locked
);
5418 /* needed for generic scsi interface */
5420 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5422 BlockDriver
*drv
= bs
->drv
;
5424 if (drv
&& drv
->bdrv_ioctl
)
5425 return drv
->bdrv_ioctl(bs
, req
, buf
);
5429 BlockAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5430 unsigned long int req
, void *buf
,
5431 BlockCompletionFunc
*cb
, void *opaque
)
5433 BlockDriver
*drv
= bs
->drv
;
5435 if (drv
&& drv
->bdrv_aio_ioctl
)
5436 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5440 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5442 bs
->guest_block_size
= align
;
5445 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5447 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5450 void *qemu_blockalign0(BlockDriverState
*bs
, size_t size
)
5452 return memset(qemu_blockalign(bs
, size
), 0, size
);
5455 void *qemu_try_blockalign(BlockDriverState
*bs
, size_t size
)
5457 size_t align
= bdrv_opt_mem_align(bs
);
5459 /* Ensure that NULL is never returned on success */
5465 return qemu_try_memalign(align
, size
);
5468 void *qemu_try_blockalign0(BlockDriverState
*bs
, size_t size
)
5470 void *mem
= qemu_try_blockalign(bs
, size
);
5473 memset(mem
, 0, size
);
5480 * Check if all memory in this vector is sector aligned.
5482 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5485 size_t alignment
= bdrv_opt_mem_align(bs
);
5487 for (i
= 0; i
< qiov
->niov
; i
++) {
5488 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5491 if (qiov
->iov
[i
].iov_len
% alignment
) {
5499 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
,
5502 int64_t bitmap_size
;
5503 BdrvDirtyBitmap
*bitmap
;
5505 assert((granularity
& (granularity
- 1)) == 0);
5507 granularity
>>= BDRV_SECTOR_BITS
;
5508 assert(granularity
);
5509 bitmap_size
= bdrv_nb_sectors(bs
);
5510 if (bitmap_size
< 0) {
5511 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
5512 errno
= -bitmap_size
;
5515 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
5516 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ctz32(granularity
));
5517 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5521 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5523 BdrvDirtyBitmap
*bm
, *next
;
5524 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5526 QLIST_REMOVE(bitmap
, list
);
5527 hbitmap_free(bitmap
->bitmap
);
5534 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5536 BdrvDirtyBitmap
*bm
;
5537 BlockDirtyInfoList
*list
= NULL
;
5538 BlockDirtyInfoList
**plist
= &list
;
5540 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5541 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
5542 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
5543 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5545 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5546 entry
->value
= info
;
5548 plist
= &entry
->next
;
5554 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5557 return hbitmap_get(bitmap
->bitmap
, sector
);
5563 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5564 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5566 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5569 void bdrv_set_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5570 int64_t cur_sector
, int nr_sectors
)
5572 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5575 void bdrv_reset_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5576 int64_t cur_sector
, int nr_sectors
)
5578 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5581 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5584 BdrvDirtyBitmap
*bitmap
;
5585 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5586 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5590 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5593 BdrvDirtyBitmap
*bitmap
;
5594 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5595 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5599 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5601 return hbitmap_count(bitmap
->bitmap
);
5604 /* Get a reference to bs */
5605 void bdrv_ref(BlockDriverState
*bs
)
5610 /* Release a previously grabbed reference to bs.
5611 * If after releasing, reference count is zero, the BlockDriverState is
5613 void bdrv_unref(BlockDriverState
*bs
)
5618 assert(bs
->refcnt
> 0);
5619 if (--bs
->refcnt
== 0) {
5624 struct BdrvOpBlocker
{
5626 QLIST_ENTRY(BdrvOpBlocker
) list
;
5629 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
5631 BdrvOpBlocker
*blocker
;
5632 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5633 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
5634 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
5636 error_setg(errp
, "Node '%s' is busy: %s",
5637 bdrv_get_device_or_node_name(bs
),
5638 error_get_pretty(blocker
->reason
));
5645 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5647 BdrvOpBlocker
*blocker
;
5648 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5650 blocker
= g_new0(BdrvOpBlocker
, 1);
5651 blocker
->reason
= reason
;
5652 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
5655 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5657 BdrvOpBlocker
*blocker
, *next
;
5658 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5659 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
5660 if (blocker
->reason
== reason
) {
5661 QLIST_REMOVE(blocker
, list
);
5667 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
5670 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5671 bdrv_op_block(bs
, i
, reason
);
5675 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
5678 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5679 bdrv_op_unblock(bs
, i
, reason
);
5683 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
5687 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5688 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
5695 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5697 bs
->iostatus_enabled
= true;
5698 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5701 /* The I/O status is only enabled if the drive explicitly
5702 * enables it _and_ the VM is configured to stop on errors */
5703 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5705 return (bs
->iostatus_enabled
&&
5706 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5707 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5708 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5711 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5713 bs
->iostatus_enabled
= false;
5716 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5718 if (bdrv_iostatus_is_enabled(bs
)) {
5719 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5721 block_job_iostatus_reset(bs
->job
);
5726 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5728 assert(bdrv_iostatus_is_enabled(bs
));
5729 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5730 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5731 BLOCK_DEVICE_IO_STATUS_FAILED
;
5735 void bdrv_img_create(const char *filename
, const char *fmt
,
5736 const char *base_filename
, const char *base_fmt
,
5737 char *options
, uint64_t img_size
, int flags
,
5738 Error
**errp
, bool quiet
)
5740 QemuOptsList
*create_opts
= NULL
;
5741 QemuOpts
*opts
= NULL
;
5742 const char *backing_fmt
, *backing_file
;
5744 BlockDriver
*drv
, *proto_drv
;
5745 BlockDriver
*backing_drv
= NULL
;
5746 Error
*local_err
= NULL
;
5749 /* Find driver and parse its options */
5750 drv
= bdrv_find_format(fmt
);
5752 error_setg(errp
, "Unknown file format '%s'", fmt
);
5756 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
5761 if (!drv
->create_opts
) {
5762 error_setg(errp
, "Format driver '%s' does not support image creation",
5767 if (!proto_drv
->create_opts
) {
5768 error_setg(errp
, "Protocol driver '%s' does not support image creation",
5769 proto_drv
->format_name
);
5773 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5774 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5776 /* Create parameter list with default values */
5777 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5778 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
, &error_abort
);
5780 /* Parse -o options */
5782 qemu_opts_do_parse(opts
, options
, NULL
, &local_err
);
5784 error_report_err(local_err
);
5786 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
5791 if (base_filename
) {
5792 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
, &local_err
);
5794 error_setg(errp
, "Backing file not supported for file format '%s'",
5801 qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
, &local_err
);
5803 error_setg(errp
, "Backing file format not supported for file "
5804 "format '%s'", fmt
);
5809 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5811 if (!strcmp(filename
, backing_file
)) {
5812 error_setg(errp
, "Error: Trying to create an image with the "
5813 "same filename as the backing file");
5818 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5820 backing_drv
= bdrv_find_format(backing_fmt
);
5822 error_setg(errp
, "Unknown backing file format '%s'",
5828 // The size for the image must always be specified, with one exception:
5829 // If we are using a backing file, we can obtain the size from there
5830 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5833 BlockDriverState
*bs
;
5834 char *full_backing
= g_new0(char, PATH_MAX
);
5838 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
5839 full_backing
, PATH_MAX
,
5842 g_free(full_backing
);
5846 /* backing files always opened read-only */
5848 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5851 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
5852 backing_drv
, &local_err
);
5853 g_free(full_backing
);
5857 size
= bdrv_getlength(bs
);
5859 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
5865 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
, &error_abort
);
5869 error_setg(errp
, "Image creation needs a size parameter");
5875 printf("Formatting '%s', fmt=%s", filename
, fmt
);
5876 qemu_opts_print(opts
, " ");
5880 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
5882 if (ret
== -EFBIG
) {
5883 /* This is generally a better message than whatever the driver would
5884 * deliver (especially because of the cluster_size_hint), since that
5885 * is most probably not much different from "image too large". */
5886 const char *cluster_size_hint
= "";
5887 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
5888 cluster_size_hint
= " (try using a larger cluster size)";
5890 error_setg(errp
, "The image size is too large for file format '%s'"
5891 "%s", fmt
, cluster_size_hint
);
5892 error_free(local_err
);
5897 qemu_opts_del(opts
);
5898 qemu_opts_free(create_opts
);
5900 error_propagate(errp
, local_err
);
5904 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5906 return bs
->aio_context
;
5909 void bdrv_detach_aio_context(BlockDriverState
*bs
)
5911 BdrvAioNotifier
*baf
;
5917 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
5918 baf
->detach_aio_context(baf
->opaque
);
5921 if (bs
->io_limits_enabled
) {
5922 throttle_detach_aio_context(&bs
->throttle_state
);
5924 if (bs
->drv
->bdrv_detach_aio_context
) {
5925 bs
->drv
->bdrv_detach_aio_context(bs
);
5928 bdrv_detach_aio_context(bs
->file
);
5930 if (bs
->backing_hd
) {
5931 bdrv_detach_aio_context(bs
->backing_hd
);
5934 bs
->aio_context
= NULL
;
5937 void bdrv_attach_aio_context(BlockDriverState
*bs
,
5938 AioContext
*new_context
)
5940 BdrvAioNotifier
*ban
;
5946 bs
->aio_context
= new_context
;
5948 if (bs
->backing_hd
) {
5949 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
5952 bdrv_attach_aio_context(bs
->file
, new_context
);
5954 if (bs
->drv
->bdrv_attach_aio_context
) {
5955 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
5957 if (bs
->io_limits_enabled
) {
5958 throttle_attach_aio_context(&bs
->throttle_state
, new_context
);
5961 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
5962 ban
->attached_aio_context(new_context
, ban
->opaque
);
5966 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
5968 bdrv_drain_all(); /* ensure there are no in-flight requests */
5970 bdrv_detach_aio_context(bs
);
5972 /* This function executes in the old AioContext so acquire the new one in
5973 * case it runs in a different thread.
5975 aio_context_acquire(new_context
);
5976 bdrv_attach_aio_context(bs
, new_context
);
5977 aio_context_release(new_context
);
5980 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
5981 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
5982 void (*detach_aio_context
)(void *opaque
), void *opaque
)
5984 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
5985 *ban
= (BdrvAioNotifier
){
5986 .attached_aio_context
= attached_aio_context
,
5987 .detach_aio_context
= detach_aio_context
,
5991 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
5994 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
5995 void (*attached_aio_context
)(AioContext
*,
5997 void (*detach_aio_context
)(void *),
6000 BdrvAioNotifier
*ban
, *ban_next
;
6002 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
6003 if (ban
->attached_aio_context
== attached_aio_context
&&
6004 ban
->detach_aio_context
== detach_aio_context
&&
6005 ban
->opaque
== opaque
)
6007 QLIST_REMOVE(ban
, list
);
6017 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
6018 NotifierWithReturn
*notifier
)
6020 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
6023 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
6024 BlockDriverAmendStatusCB
*status_cb
)
6026 if (!bs
->drv
->bdrv_amend_options
) {
6029 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
6032 /* This function will be called by the bdrv_recurse_is_first_non_filter method
6033 * of block filter and by bdrv_is_first_non_filter.
6034 * It is used to test if the given bs is the candidate or recurse more in the
6037 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
6038 BlockDriverState
*candidate
)
6040 /* return false if basic checks fails */
6041 if (!bs
|| !bs
->drv
) {
6045 /* the code reached a non block filter driver -> check if the bs is
6046 * the same as the candidate. It's the recursion termination condition.
6048 if (!bs
->drv
->is_filter
) {
6049 return bs
== candidate
;
6051 /* Down this path the driver is a block filter driver */
6053 /* If the block filter recursion method is defined use it to recurse down
6056 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
6057 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
6060 /* the driver is a block filter but don't allow to recurse -> return false
6065 /* This function checks if the candidate is the first non filter bs down it's
6066 * bs chain. Since we don't have pointers to parents it explore all bs chains
6067 * from the top. Some filters can choose not to pass down the recursion.
6069 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
6071 BlockDriverState
*bs
;
6073 /* walk down the bs forest recursively */
6074 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
6077 /* try to recurse in this top level bs */
6078 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
6080 /* candidate is the first non filter */
6089 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
6091 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
6092 AioContext
*aio_context
;
6094 if (!to_replace_bs
) {
6095 error_setg(errp
, "Node name '%s' not found", node_name
);
6099 aio_context
= bdrv_get_aio_context(to_replace_bs
);
6100 aio_context_acquire(aio_context
);
6102 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
6103 to_replace_bs
= NULL
;
6107 /* We don't want arbitrary node of the BDS chain to be replaced only the top
6108 * most non filter in order to prevent data corruption.
6109 * Another benefit is that this tests exclude backing files which are
6110 * blocked by the backing blockers.
6112 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
6113 error_setg(errp
, "Only top most non filter can be replaced");
6114 to_replace_bs
= NULL
;
6119 aio_context_release(aio_context
);
6120 return to_replace_bs
;
6123 void bdrv_io_plug(BlockDriverState
*bs
)
6125 BlockDriver
*drv
= bs
->drv
;
6126 if (drv
&& drv
->bdrv_io_plug
) {
6127 drv
->bdrv_io_plug(bs
);
6128 } else if (bs
->file
) {
6129 bdrv_io_plug(bs
->file
);
6133 void bdrv_io_unplug(BlockDriverState
*bs
)
6135 BlockDriver
*drv
= bs
->drv
;
6136 if (drv
&& drv
->bdrv_io_unplug
) {
6137 drv
->bdrv_io_unplug(bs
);
6138 } else if (bs
->file
) {
6139 bdrv_io_unplug(bs
->file
);
6143 void bdrv_flush_io_queue(BlockDriverState
*bs
)
6145 BlockDriver
*drv
= bs
->drv
;
6146 if (drv
&& drv
->bdrv_flush_io_queue
) {
6147 drv
->bdrv_flush_io_queue(bs
);
6148 } else if (bs
->file
) {
6149 bdrv_flush_io_queue(bs
->file
);
6153 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
6155 const QDictEntry
*entry
;
6156 bool found_any
= false;
6158 for (entry
= qdict_first(bs
->options
); entry
;
6159 entry
= qdict_next(bs
->options
, entry
))
6161 /* Only take options for this level and exclude all non-driver-specific
6163 if (!strchr(qdict_entry_key(entry
), '.') &&
6164 strcmp(qdict_entry_key(entry
), "node-name"))
6166 qobject_incref(qdict_entry_value(entry
));
6167 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
6175 /* Updates the following BDS fields:
6176 * - exact_filename: A filename which may be used for opening a block device
6177 * which (mostly) equals the given BDS (even without any
6178 * other options; so reading and writing must return the same
6179 * results, but caching etc. may be different)
6180 * - full_open_options: Options which, when given when opening a block device
6181 * (without a filename), result in a BDS (mostly)
6182 * equalling the given one
6183 * - filename: If exact_filename is set, it is copied here. Otherwise,
6184 * full_open_options is converted to a JSON object, prefixed with
6185 * "json:" (for use through the JSON pseudo protocol) and put here.
6187 void bdrv_refresh_filename(BlockDriverState
*bs
)
6189 BlockDriver
*drv
= bs
->drv
;
6196 /* This BDS's file name will most probably depend on its file's name, so
6197 * refresh that first */
6199 bdrv_refresh_filename(bs
->file
);
6202 if (drv
->bdrv_refresh_filename
) {
6203 /* Obsolete information is of no use here, so drop the old file name
6204 * information before refreshing it */
6205 bs
->exact_filename
[0] = '\0';
6206 if (bs
->full_open_options
) {
6207 QDECREF(bs
->full_open_options
);
6208 bs
->full_open_options
= NULL
;
6211 drv
->bdrv_refresh_filename(bs
);
6212 } else if (bs
->file
) {
6213 /* Try to reconstruct valid information from the underlying file */
6214 bool has_open_options
;
6216 bs
->exact_filename
[0] = '\0';
6217 if (bs
->full_open_options
) {
6218 QDECREF(bs
->full_open_options
);
6219 bs
->full_open_options
= NULL
;
6223 has_open_options
= append_open_options(opts
, bs
);
6225 /* If no specific options have been given for this BDS, the filename of
6226 * the underlying file should suffice for this one as well */
6227 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
6228 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
6230 /* Reconstructing the full options QDict is simple for most format block
6231 * drivers, as long as the full options are known for the underlying
6232 * file BDS. The full options QDict of that file BDS should somehow
6233 * contain a representation of the filename, therefore the following
6234 * suffices without querying the (exact_)filename of this BDS. */
6235 if (bs
->file
->full_open_options
) {
6236 qdict_put_obj(opts
, "driver",
6237 QOBJECT(qstring_from_str(drv
->format_name
)));
6238 QINCREF(bs
->file
->full_open_options
);
6239 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
6241 bs
->full_open_options
= opts
;
6245 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
6246 /* There is no underlying file BDS (at least referenced by BDS.file),
6247 * so the full options QDict should be equal to the options given
6248 * specifically for this block device when it was opened (plus the
6249 * driver specification).
6250 * Because those options don't change, there is no need to update
6251 * full_open_options when it's already set. */
6254 append_open_options(opts
, bs
);
6255 qdict_put_obj(opts
, "driver",
6256 QOBJECT(qstring_from_str(drv
->format_name
)));
6258 if (bs
->exact_filename
[0]) {
6259 /* This may not work for all block protocol drivers (some may
6260 * require this filename to be parsed), but we have to find some
6261 * default solution here, so just include it. If some block driver
6262 * does not support pure options without any filename at all or
6263 * needs some special format of the options QDict, it needs to
6264 * implement the driver-specific bdrv_refresh_filename() function.
6266 qdict_put_obj(opts
, "filename",
6267 QOBJECT(qstring_from_str(bs
->exact_filename
)));
6270 bs
->full_open_options
= opts
;
6273 if (bs
->exact_filename
[0]) {
6274 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
6275 } else if (bs
->full_open_options
) {
6276 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
6277 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
6278 qstring_get_str(json
));
6283 /* This accessor function purpose is to allow the device models to access the
6284 * BlockAcctStats structure embedded inside a BlockDriverState without being
6285 * aware of the BlockDriverState structure layout.
6286 * It will go away when the BlockAcctStats structure will be moved inside
6287 * the device models.
6289 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)