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/sysemu.h"
32 #include "qemu/notify.h"
33 #include "block/coroutine.h"
34 #include "block/qapi.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
37 #include "qapi-event.h"
40 #include <sys/types.h>
42 #include <sys/ioctl.h>
43 #include <sys/queue.h>
53 struct BdrvDirtyBitmap
{
55 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
60 #define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */
62 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
63 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
64 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
65 BlockDriverCompletionFunc
*cb
, void *opaque
);
66 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
67 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
68 BlockDriverCompletionFunc
*cb
, void *opaque
);
69 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
70 int64_t sector_num
, int nb_sectors
,
72 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
73 int64_t sector_num
, int nb_sectors
,
75 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
76 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
77 BdrvRequestFlags flags
);
78 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
79 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
80 BdrvRequestFlags flags
);
81 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
85 BdrvRequestFlags flags
,
86 BlockDriverCompletionFunc
*cb
,
89 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
90 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
91 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
93 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
94 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
96 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
97 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
99 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
100 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
102 /* If non-zero, use only whitelisted block drivers */
103 static int use_bdrv_whitelist
;
106 static int is_windows_drive_prefix(const char *filename
)
108 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
109 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
113 int is_windows_drive(const char *filename
)
115 if (is_windows_drive_prefix(filename
) &&
118 if (strstart(filename
, "\\\\.\\", NULL
) ||
119 strstart(filename
, "//./", NULL
))
125 /* throttling disk I/O limits */
126 void bdrv_set_io_limits(BlockDriverState
*bs
,
131 throttle_config(&bs
->throttle_state
, cfg
);
133 for (i
= 0; i
< 2; i
++) {
134 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
138 /* this function drain all the throttled IOs */
139 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
141 bool drained
= false;
142 bool enabled
= bs
->io_limits_enabled
;
145 bs
->io_limits_enabled
= false;
147 for (i
= 0; i
< 2; i
++) {
148 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
153 bs
->io_limits_enabled
= enabled
;
158 void bdrv_io_limits_disable(BlockDriverState
*bs
)
160 bs
->io_limits_enabled
= false;
162 bdrv_start_throttled_reqs(bs
);
164 throttle_destroy(&bs
->throttle_state
);
167 static void bdrv_throttle_read_timer_cb(void *opaque
)
169 BlockDriverState
*bs
= opaque
;
170 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
173 static void bdrv_throttle_write_timer_cb(void *opaque
)
175 BlockDriverState
*bs
= opaque
;
176 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
179 /* should be called before bdrv_set_io_limits if a limit is set */
180 void bdrv_io_limits_enable(BlockDriverState
*bs
)
182 assert(!bs
->io_limits_enabled
);
183 throttle_init(&bs
->throttle_state
,
184 bdrv_get_aio_context(bs
),
186 bdrv_throttle_read_timer_cb
,
187 bdrv_throttle_write_timer_cb
,
189 bs
->io_limits_enabled
= true;
192 /* This function makes an IO wait if needed
194 * @nb_sectors: the number of sectors of the IO
195 * @is_write: is the IO a write
197 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
201 /* does this io must wait */
202 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
204 /* if must wait or any request of this type throttled queue the IO */
206 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
207 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
210 /* the IO will be executed, do the accounting */
211 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
214 /* if the next request must wait -> do nothing */
215 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
219 /* else queue next request for execution */
220 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
223 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
225 if (!bs
|| !bs
->drv
) {
226 /* 4k should be on the safe side */
230 return bs
->bl
.opt_mem_alignment
;
233 /* check if the path starts with "<protocol>:" */
234 static int path_has_protocol(const char *path
)
239 if (is_windows_drive(path
) ||
240 is_windows_drive_prefix(path
)) {
243 p
= path
+ strcspn(path
, ":/\\");
245 p
= path
+ strcspn(path
, ":/");
251 int path_is_absolute(const char *path
)
254 /* specific case for names like: "\\.\d:" */
255 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
258 return (*path
== '/' || *path
== '\\');
260 return (*path
== '/');
264 /* if filename is absolute, just copy it to dest. Otherwise, build a
265 path to it by considering it is relative to base_path. URL are
267 void path_combine(char *dest
, int dest_size
,
268 const char *base_path
,
269 const char *filename
)
276 if (path_is_absolute(filename
)) {
277 pstrcpy(dest
, dest_size
, filename
);
279 p
= strchr(base_path
, ':');
284 p1
= strrchr(base_path
, '/');
288 p2
= strrchr(base_path
, '\\');
300 if (len
> dest_size
- 1)
302 memcpy(dest
, base_path
, len
);
304 pstrcat(dest
, dest_size
, filename
);
308 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
310 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
311 pstrcpy(dest
, sz
, bs
->backing_file
);
313 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
317 void bdrv_register(BlockDriver
*bdrv
)
319 /* Block drivers without coroutine functions need emulation */
320 if (!bdrv
->bdrv_co_readv
) {
321 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
322 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
324 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
325 * the block driver lacks aio we need to emulate that too.
327 if (!bdrv
->bdrv_aio_readv
) {
328 /* add AIO emulation layer */
329 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
330 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
334 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
337 /* create a new block device (by default it is empty) */
338 BlockDriverState
*bdrv_new_root(const char *device_name
, Error
**errp
)
340 BlockDriverState
*bs
;
342 assert(*device_name
);
344 if (*device_name
&& !id_wellformed(device_name
)) {
345 error_setg(errp
, "Invalid device name");
349 if (bdrv_find(device_name
)) {
350 error_setg(errp
, "Device with id '%s' already exists",
354 if (bdrv_find_node(device_name
)) {
356 "Device name '%s' conflicts with an existing node name",
363 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
364 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
369 BlockDriverState
*bdrv_new(void)
371 BlockDriverState
*bs
;
374 bs
= g_new0(BlockDriverState
, 1);
375 QLIST_INIT(&bs
->dirty_bitmaps
);
376 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
377 QLIST_INIT(&bs
->op_blockers
[i
]);
379 bdrv_iostatus_disable(bs
);
380 notifier_list_init(&bs
->close_notifiers
);
381 notifier_with_return_list_init(&bs
->before_write_notifiers
);
382 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
383 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
385 bs
->aio_context
= qemu_get_aio_context();
390 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
392 notifier_list_add(&bs
->close_notifiers
, notify
);
395 BlockDriver
*bdrv_find_format(const char *format_name
)
398 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
399 if (!strcmp(drv1
->format_name
, format_name
)) {
406 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
408 static const char *whitelist_rw
[] = {
409 CONFIG_BDRV_RW_WHITELIST
411 static const char *whitelist_ro
[] = {
412 CONFIG_BDRV_RO_WHITELIST
416 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
417 return 1; /* no whitelist, anything goes */
420 for (p
= whitelist_rw
; *p
; p
++) {
421 if (!strcmp(drv
->format_name
, *p
)) {
426 for (p
= whitelist_ro
; *p
; p
++) {
427 if (!strcmp(drv
->format_name
, *p
)) {
435 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
438 BlockDriver
*drv
= bdrv_find_format(format_name
);
439 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
442 typedef struct CreateCo
{
450 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
452 Error
*local_err
= NULL
;
455 CreateCo
*cco
= opaque
;
458 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
460 error_propagate(&cco
->err
, local_err
);
465 int bdrv_create(BlockDriver
*drv
, const char* filename
,
466 QemuOpts
*opts
, Error
**errp
)
473 .filename
= g_strdup(filename
),
479 if (!drv
->bdrv_create
) {
480 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
485 if (qemu_in_coroutine()) {
486 /* Fast-path if already in coroutine context */
487 bdrv_create_co_entry(&cco
);
489 co
= qemu_coroutine_create(bdrv_create_co_entry
);
490 qemu_coroutine_enter(co
, &cco
);
491 while (cco
.ret
== NOT_DONE
) {
492 aio_poll(qemu_get_aio_context(), true);
499 error_propagate(errp
, cco
.err
);
501 error_setg_errno(errp
, -ret
, "Could not create image");
506 g_free(cco
.filename
);
510 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
513 Error
*local_err
= NULL
;
516 drv
= bdrv_find_protocol(filename
, true);
518 error_setg(errp
, "Could not find protocol for file '%s'", filename
);
522 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
524 error_propagate(errp
, local_err
);
529 void bdrv_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
531 BlockDriver
*drv
= bs
->drv
;
532 Error
*local_err
= NULL
;
534 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
540 /* Take some limits from the children as a default */
542 bdrv_refresh_limits(bs
->file
, &local_err
);
544 error_propagate(errp
, local_err
);
547 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
548 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
550 bs
->bl
.opt_mem_alignment
= 512;
553 if (bs
->backing_hd
) {
554 bdrv_refresh_limits(bs
->backing_hd
, &local_err
);
556 error_propagate(errp
, local_err
);
559 bs
->bl
.opt_transfer_length
=
560 MAX(bs
->bl
.opt_transfer_length
,
561 bs
->backing_hd
->bl
.opt_transfer_length
);
562 bs
->bl
.opt_mem_alignment
=
563 MAX(bs
->bl
.opt_mem_alignment
,
564 bs
->backing_hd
->bl
.opt_mem_alignment
);
567 /* Then let the driver override it */
568 if (drv
->bdrv_refresh_limits
) {
569 drv
->bdrv_refresh_limits(bs
, errp
);
574 * Create a uniquely-named empty temporary file.
575 * Return 0 upon success, otherwise a negative errno value.
577 int get_tmp_filename(char *filename
, int size
)
580 char temp_dir
[MAX_PATH
];
581 /* GetTempFileName requires that its output buffer (4th param)
582 have length MAX_PATH or greater. */
583 assert(size
>= MAX_PATH
);
584 return (GetTempPath(MAX_PATH
, temp_dir
)
585 && GetTempFileName(temp_dir
, "qem", 0, filename
)
586 ? 0 : -GetLastError());
590 tmpdir
= getenv("TMPDIR");
594 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
597 fd
= mkstemp(filename
);
601 if (close(fd
) != 0) {
610 * Detect host devices. By convention, /dev/cdrom[N] is always
611 * recognized as a host CDROM.
613 static BlockDriver
*find_hdev_driver(const char *filename
)
615 int score_max
= 0, score
;
616 BlockDriver
*drv
= NULL
, *d
;
618 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
619 if (d
->bdrv_probe_device
) {
620 score
= d
->bdrv_probe_device(filename
);
621 if (score
> score_max
) {
631 BlockDriver
*bdrv_find_protocol(const char *filename
,
632 bool allow_protocol_prefix
)
639 /* TODO Drivers without bdrv_file_open must be specified explicitly */
642 * XXX(hch): we really should not let host device detection
643 * override an explicit protocol specification, but moving this
644 * later breaks access to device names with colons in them.
645 * Thanks to the brain-dead persistent naming schemes on udev-
646 * based Linux systems those actually are quite common.
648 drv1
= find_hdev_driver(filename
);
653 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
654 return bdrv_find_format("file");
657 p
= strchr(filename
, ':');
660 if (len
> sizeof(protocol
) - 1)
661 len
= sizeof(protocol
) - 1;
662 memcpy(protocol
, filename
, len
);
663 protocol
[len
] = '\0';
664 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
665 if (drv1
->protocol_name
&&
666 !strcmp(drv1
->protocol_name
, protocol
)) {
673 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
674 BlockDriver
**pdrv
, Error
**errp
)
676 int score
, score_max
;
677 BlockDriver
*drv1
, *drv
;
681 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
682 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
683 drv
= bdrv_find_format("raw");
685 error_setg(errp
, "Could not find raw image format");
692 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
694 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
702 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
703 if (drv1
->bdrv_probe
) {
704 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
705 if (score
> score_max
) {
712 error_setg(errp
, "Could not determine image format: No compatible "
721 * Set the current 'total_sectors' value
722 * Return 0 on success, -errno on error.
724 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
726 BlockDriver
*drv
= bs
->drv
;
728 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
732 /* query actual device if possible, otherwise just trust the hint */
733 if (drv
->bdrv_getlength
) {
734 int64_t length
= drv
->bdrv_getlength(bs
);
738 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
741 bs
->total_sectors
= hint
;
746 * Set open flags for a given discard mode
748 * Return 0 on success, -1 if the discard mode was invalid.
750 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
752 *flags
&= ~BDRV_O_UNMAP
;
754 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
756 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
757 *flags
|= BDRV_O_UNMAP
;
766 * Set open flags for a given cache mode
768 * Return 0 on success, -1 if the cache mode was invalid.
770 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
772 *flags
&= ~BDRV_O_CACHE_MASK
;
774 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
775 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
776 } else if (!strcmp(mode
, "directsync")) {
777 *flags
|= BDRV_O_NOCACHE
;
778 } else if (!strcmp(mode
, "writeback")) {
779 *flags
|= BDRV_O_CACHE_WB
;
780 } else if (!strcmp(mode
, "unsafe")) {
781 *flags
|= BDRV_O_CACHE_WB
;
782 *flags
|= BDRV_O_NO_FLUSH
;
783 } else if (!strcmp(mode
, "writethrough")) {
784 /* this is the default */
793 * The copy-on-read flag is actually a reference count so multiple users may
794 * use the feature without worrying about clobbering its previous state.
795 * Copy-on-read stays enabled until all users have called to disable it.
797 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
802 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
804 assert(bs
->copy_on_read
> 0);
809 * Returns the flags that a temporary snapshot should get, based on the
810 * originally requested flags (the originally requested image will have flags
811 * like a backing file)
813 static int bdrv_temp_snapshot_flags(int flags
)
815 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
819 * Returns the flags that bs->file should get, based on the given flags for
822 static int bdrv_inherited_flags(int flags
)
824 /* Enable protocol handling, disable format probing for bs->file */
825 flags
|= BDRV_O_PROTOCOL
;
827 /* Our block drivers take care to send flushes and respect unmap policy,
828 * so we can enable both unconditionally on lower layers. */
829 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
831 /* Clear flags that only apply to the top layer */
832 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
838 * Returns the flags that bs->backing_hd should get, based on the given flags
841 static int bdrv_backing_flags(int flags
)
843 /* backing files always opened read-only */
844 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
846 /* snapshot=on is handled on the top layer */
847 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
852 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
854 int open_flags
= flags
| BDRV_O_CACHE_WB
;
857 * Clear flags that are internal to the block layer before opening the
860 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
863 * Snapshots should be writable.
865 if (flags
& BDRV_O_TEMPORARY
) {
866 open_flags
|= BDRV_O_RDWR
;
872 static void bdrv_assign_node_name(BlockDriverState
*bs
,
873 const char *node_name
,
880 /* Check for empty string or invalid characters */
881 if (!id_wellformed(node_name
)) {
882 error_setg(errp
, "Invalid node name");
886 /* takes care of avoiding namespaces collisions */
887 if (bdrv_find(node_name
)) {
888 error_setg(errp
, "node-name=%s is conflicting with a device id",
893 /* takes care of avoiding duplicates node names */
894 if (bdrv_find_node(node_name
)) {
895 error_setg(errp
, "Duplicate node name");
899 /* copy node name into the bs and insert it into the graph list */
900 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
901 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
905 * Common part for opening disk images and files
907 * Removes all processed options from *options.
909 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
910 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
913 const char *filename
;
914 const char *node_name
= NULL
;
915 Error
*local_err
= NULL
;
918 assert(bs
->file
== NULL
);
919 assert(options
!= NULL
&& bs
->options
!= options
);
922 filename
= file
->filename
;
924 filename
= qdict_get_try_str(options
, "filename");
927 if (drv
->bdrv_needs_filename
&& !filename
) {
928 error_setg(errp
, "The '%s' block driver requires a file name",
933 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
935 node_name
= qdict_get_try_str(options
, "node-name");
936 bdrv_assign_node_name(bs
, node_name
, &local_err
);
938 error_propagate(errp
, local_err
);
941 qdict_del(options
, "node-name");
943 /* bdrv_open() with directly using a protocol as drv. This layer is already
944 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
945 * and return immediately. */
946 if (file
!= NULL
&& drv
->bdrv_file_open
) {
951 bs
->open_flags
= flags
;
952 bs
->guest_block_size
= 512;
953 bs
->request_alignment
= 512;
954 bs
->zero_beyond_eof
= true;
955 open_flags
= bdrv_open_flags(bs
, flags
);
956 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
957 bs
->growable
= !!(flags
& BDRV_O_PROTOCOL
);
959 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
961 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
962 ? "Driver '%s' can only be used for read-only devices"
963 : "Driver '%s' is not whitelisted",
968 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
969 if (flags
& BDRV_O_COPY_ON_READ
) {
970 if (!bs
->read_only
) {
971 bdrv_enable_copy_on_read(bs
);
973 error_setg(errp
, "Can't use copy-on-read on read-only device");
978 if (filename
!= NULL
) {
979 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
981 bs
->filename
[0] = '\0';
983 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
986 bs
->opaque
= g_malloc0(drv
->instance_size
);
988 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
990 /* Open the image, either directly or using a protocol */
991 if (drv
->bdrv_file_open
) {
992 assert(file
== NULL
);
993 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
994 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
997 error_setg(errp
, "Can't use '%s' as a block driver for the "
998 "protocol level", drv
->format_name
);
1003 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1008 error_propagate(errp
, local_err
);
1009 } else if (bs
->filename
[0]) {
1010 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1012 error_setg_errno(errp
, -ret
, "Could not open image");
1017 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1019 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1023 bdrv_refresh_limits(bs
, &local_err
);
1025 error_propagate(errp
, local_err
);
1030 assert(bdrv_opt_mem_align(bs
) != 0);
1031 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1042 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1044 QObject
*options_obj
;
1048 ret
= strstart(filename
, "json:", &filename
);
1051 options_obj
= qobject_from_json(filename
);
1053 error_setg(errp
, "Could not parse the JSON options");
1057 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1058 qobject_decref(options_obj
);
1059 error_setg(errp
, "Invalid JSON object given");
1063 options
= qobject_to_qdict(options_obj
);
1064 qdict_flatten(options
);
1070 * Fills in default options for opening images and converts the legacy
1071 * filename/flags pair to option QDict entries.
1073 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
1074 BlockDriver
*drv
, Error
**errp
)
1076 const char *filename
= *pfilename
;
1077 const char *drvname
;
1078 bool protocol
= flags
& BDRV_O_PROTOCOL
;
1079 bool parse_filename
= false;
1080 Error
*local_err
= NULL
;
1082 /* Parse json: pseudo-protocol */
1083 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1084 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1086 error_propagate(errp
, local_err
);
1090 /* Options given in the filename have lower priority than options
1091 * specified directly */
1092 qdict_join(*options
, json_options
, false);
1093 QDECREF(json_options
);
1094 *pfilename
= filename
= NULL
;
1097 /* Fetch the file name from the options QDict if necessary */
1098 if (protocol
&& filename
) {
1099 if (!qdict_haskey(*options
, "filename")) {
1100 qdict_put(*options
, "filename", qstring_from_str(filename
));
1101 parse_filename
= true;
1103 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1109 /* Find the right block driver */
1110 filename
= qdict_get_try_str(*options
, "filename");
1111 drvname
= qdict_get_try_str(*options
, "driver");
1115 error_setg(errp
, "Driver specified twice");
1118 drvname
= drv
->format_name
;
1119 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1121 if (!drvname
&& protocol
) {
1123 drv
= bdrv_find_protocol(filename
, parse_filename
);
1125 error_setg(errp
, "Unknown protocol");
1129 drvname
= drv
->format_name
;
1130 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1132 error_setg(errp
, "Must specify either driver or file");
1135 } else if (drvname
) {
1136 drv
= bdrv_find_format(drvname
);
1138 error_setg(errp
, "Unknown driver '%s'", drvname
);
1144 assert(drv
|| !protocol
);
1146 /* Driver-specific filename parsing */
1147 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1148 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1150 error_propagate(errp
, local_err
);
1154 if (!drv
->bdrv_needs_filename
) {
1155 qdict_del(*options
, "filename");
1162 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1165 if (bs
->backing_hd
) {
1166 assert(bs
->backing_blocker
);
1167 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1168 } else if (backing_hd
) {
1169 error_setg(&bs
->backing_blocker
,
1170 "device is used as backing hd of '%s'",
1174 bs
->backing_hd
= backing_hd
;
1176 error_free(bs
->backing_blocker
);
1177 bs
->backing_blocker
= NULL
;
1180 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1181 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1182 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1183 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1185 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1186 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1187 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
,
1188 bs
->backing_blocker
);
1190 bdrv_refresh_limits(bs
, NULL
);
1194 * Opens the backing file for a BlockDriverState if not yet open
1196 * options is a QDict of options to pass to the block drivers, or NULL for an
1197 * empty set of options. The reference to the QDict is transferred to this
1198 * function (even on failure), so if the caller intends to reuse the dictionary,
1199 * it needs to use QINCREF() before calling bdrv_file_open.
1201 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1203 char *backing_filename
= g_malloc0(PATH_MAX
);
1205 BlockDriver
*back_drv
= NULL
;
1206 BlockDriverState
*backing_hd
;
1207 Error
*local_err
= NULL
;
1209 if (bs
->backing_hd
!= NULL
) {
1214 /* NULL means an empty set of options */
1215 if (options
== NULL
) {
1216 options
= qdict_new();
1219 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1220 if (qdict_haskey(options
, "file.filename")) {
1221 backing_filename
[0] = '\0';
1222 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1226 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
);
1229 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1231 error_setg(errp
, "Driver doesn't support backing files");
1236 backing_hd
= bdrv_new();
1238 if (bs
->backing_format
[0] != '\0') {
1239 back_drv
= bdrv_find_format(bs
->backing_format
);
1242 assert(bs
->backing_hd
== NULL
);
1243 ret
= bdrv_open(&backing_hd
,
1244 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1245 bdrv_backing_flags(bs
->open_flags
), back_drv
, &local_err
);
1247 bdrv_unref(backing_hd
);
1249 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1250 error_setg(errp
, "Could not open backing file: %s",
1251 error_get_pretty(local_err
));
1252 error_free(local_err
);
1255 bdrv_set_backing_hd(bs
, backing_hd
);
1258 g_free(backing_filename
);
1263 * Opens a disk image whose options are given as BlockdevRef in another block
1266 * If allow_none is true, no image will be opened if filename is false and no
1267 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1269 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1270 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1271 * itself, all options starting with "${bdref_key}." are considered part of the
1274 * The BlockdevRef will be removed from the options QDict.
1276 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1278 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1279 QDict
*options
, const char *bdref_key
, int flags
,
1280 bool allow_none
, Error
**errp
)
1282 QDict
*image_options
;
1284 char *bdref_key_dot
;
1285 const char *reference
;
1288 assert(*pbs
== NULL
);
1290 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1291 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1292 g_free(bdref_key_dot
);
1294 reference
= qdict_get_try_str(options
, bdref_key
);
1295 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1299 error_setg(errp
, "A block device must be specified for \"%s\"",
1303 QDECREF(image_options
);
1307 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1310 qdict_del(options
, bdref_key
);
1314 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1316 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1317 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1319 BlockDriver
*bdrv_qcow2
;
1320 QemuOpts
*opts
= NULL
;
1321 QDict
*snapshot_options
;
1322 BlockDriverState
*bs_snapshot
;
1326 /* if snapshot, we create a temporary backing file and open it
1327 instead of opening 'filename' directly */
1329 /* Get the required size from the image */
1330 total_size
= bdrv_getlength(bs
);
1331 if (total_size
< 0) {
1333 error_setg_errno(errp
, -total_size
, "Could not get image size");
1337 /* Create the temporary image */
1338 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1340 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1344 bdrv_qcow2
= bdrv_find_format("qcow2");
1345 opts
= qemu_opts_create(bdrv_qcow2
->create_opts
, NULL
, 0,
1347 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
);
1348 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1349 qemu_opts_del(opts
);
1351 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1352 "'%s': %s", tmp_filename
,
1353 error_get_pretty(local_err
));
1354 error_free(local_err
);
1358 /* Prepare a new options QDict for the temporary file */
1359 snapshot_options
= qdict_new();
1360 qdict_put(snapshot_options
, "file.driver",
1361 qstring_from_str("file"));
1362 qdict_put(snapshot_options
, "file.filename",
1363 qstring_from_str(tmp_filename
));
1365 bs_snapshot
= bdrv_new();
1367 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1368 flags
, bdrv_qcow2
, &local_err
);
1370 error_propagate(errp
, local_err
);
1374 bdrv_append(bs_snapshot
, bs
);
1377 g_free(tmp_filename
);
1382 * Opens a disk image (raw, qcow2, vmdk, ...)
1384 * options is a QDict of options to pass to the block drivers, or NULL for an
1385 * empty set of options. The reference to the QDict belongs to the block layer
1386 * after the call (even on failure), so if the caller intends to reuse the
1387 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1389 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1390 * If it is not NULL, the referenced BDS will be reused.
1392 * The reference parameter may be used to specify an existing block device which
1393 * should be opened. If specified, neither options nor a filename may be given,
1394 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1396 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1397 const char *reference
, QDict
*options
, int flags
,
1398 BlockDriver
*drv
, Error
**errp
)
1401 BlockDriverState
*file
= NULL
, *bs
;
1402 const char *drvname
;
1403 Error
*local_err
= NULL
;
1404 int snapshot_flags
= 0;
1409 bool options_non_empty
= options
? qdict_size(options
) : false;
1413 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1414 "another block device");
1418 if (filename
|| options_non_empty
) {
1419 error_setg(errp
, "Cannot reference an existing block device with "
1420 "additional options or a new filename");
1424 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1439 /* NULL means an empty set of options */
1440 if (options
== NULL
) {
1441 options
= qdict_new();
1444 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1449 /* Find the right image format driver */
1451 drvname
= qdict_get_try_str(options
, "driver");
1453 drv
= bdrv_find_format(drvname
);
1454 qdict_del(options
, "driver");
1456 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1462 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1463 if (drv
&& !drv
->bdrv_file_open
) {
1464 /* If the user explicitly wants a format driver here, we'll need to add
1465 * another layer for the protocol in bs->file */
1466 flags
&= ~BDRV_O_PROTOCOL
;
1469 bs
->options
= options
;
1470 options
= qdict_clone_shallow(options
);
1472 /* Open image file without format layer */
1473 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1474 if (flags
& BDRV_O_RDWR
) {
1475 flags
|= BDRV_O_ALLOW_RDWR
;
1477 if (flags
& BDRV_O_SNAPSHOT
) {
1478 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1479 flags
= bdrv_backing_flags(flags
);
1482 assert(file
== NULL
);
1483 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1484 bdrv_inherited_flags(flags
),
1491 /* Image format probing */
1493 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1498 error_setg(errp
, "Must specify either driver or file");
1503 /* Open the image */
1504 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1509 if (file
&& (bs
->file
!= file
)) {
1514 /* If there is a backing file, use it */
1515 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1516 QDict
*backing_options
;
1518 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1519 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1521 goto close_and_fail
;
1525 bdrv_refresh_filename(bs
);
1527 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1528 * temporary snapshot afterwards. */
1529 if (snapshot_flags
) {
1530 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1532 goto close_and_fail
;
1536 /* Check if any unknown options were used */
1537 if (options
&& (qdict_size(options
) != 0)) {
1538 const QDictEntry
*entry
= qdict_first(options
);
1539 if (flags
& BDRV_O_PROTOCOL
) {
1540 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1541 "'%s'", drv
->format_name
, entry
->key
);
1543 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1544 "support the option '%s'", drv
->format_name
,
1545 bs
->device_name
, entry
->key
);
1549 goto close_and_fail
;
1552 if (!bdrv_key_required(bs
)) {
1553 bdrv_dev_change_media_cb(bs
, true);
1554 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1555 && !runstate_check(RUN_STATE_INMIGRATE
)
1556 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1558 "Guest must be stopped for opening of encrypted image");
1560 goto close_and_fail
;
1571 QDECREF(bs
->options
);
1575 /* If *pbs is NULL, a new BDS has been created in this function and
1576 needs to be freed now. Otherwise, it does not need to be closed,
1577 since it has not really been opened yet. */
1581 error_propagate(errp
, local_err
);
1586 /* See fail path, but now the BDS has to be always closed */
1594 error_propagate(errp
, local_err
);
1599 typedef struct BlockReopenQueueEntry
{
1601 BDRVReopenState state
;
1602 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1603 } BlockReopenQueueEntry
;
1606 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1607 * reopen of multiple devices.
1609 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1610 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1611 * be created and initialized. This newly created BlockReopenQueue should be
1612 * passed back in for subsequent calls that are intended to be of the same
1615 * bs is the BlockDriverState to add to the reopen queue.
1617 * flags contains the open flags for the associated bs
1619 * returns a pointer to bs_queue, which is either the newly allocated
1620 * bs_queue, or the existing bs_queue being used.
1623 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1624 BlockDriverState
*bs
, int flags
)
1628 BlockReopenQueueEntry
*bs_entry
;
1629 if (bs_queue
== NULL
) {
1630 bs_queue
= g_new0(BlockReopenQueue
, 1);
1631 QSIMPLEQ_INIT(bs_queue
);
1634 /* bdrv_open() masks this flag out */
1635 flags
&= ~BDRV_O_PROTOCOL
;
1638 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1641 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1642 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1644 bs_entry
->state
.bs
= bs
;
1645 bs_entry
->state
.flags
= flags
;
1651 * Reopen multiple BlockDriverStates atomically & transactionally.
1653 * The queue passed in (bs_queue) must have been built up previous
1654 * via bdrv_reopen_queue().
1656 * Reopens all BDS specified in the queue, with the appropriate
1657 * flags. All devices are prepared for reopen, and failure of any
1658 * device will cause all device changes to be abandonded, and intermediate
1661 * If all devices prepare successfully, then the changes are committed
1665 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1668 BlockReopenQueueEntry
*bs_entry
, *next
;
1669 Error
*local_err
= NULL
;
1671 assert(bs_queue
!= NULL
);
1675 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1676 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1677 error_propagate(errp
, local_err
);
1680 bs_entry
->prepared
= true;
1683 /* If we reach this point, we have success and just need to apply the
1686 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1687 bdrv_reopen_commit(&bs_entry
->state
);
1693 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1694 if (ret
&& bs_entry
->prepared
) {
1695 bdrv_reopen_abort(&bs_entry
->state
);
1704 /* Reopen a single BlockDriverState with the specified flags. */
1705 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1708 Error
*local_err
= NULL
;
1709 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1711 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1712 if (local_err
!= NULL
) {
1713 error_propagate(errp
, local_err
);
1720 * Prepares a BlockDriverState for reopen. All changes are staged in the
1721 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1722 * the block driver layer .bdrv_reopen_prepare()
1724 * bs is the BlockDriverState to reopen
1725 * flags are the new open flags
1726 * queue is the reopen queue
1728 * Returns 0 on success, non-zero on error. On error errp will be set
1731 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1732 * It is the responsibility of the caller to then call the abort() or
1733 * commit() for any other BDS that have been left in a prepare() state
1736 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1740 Error
*local_err
= NULL
;
1743 assert(reopen_state
!= NULL
);
1744 assert(reopen_state
->bs
->drv
!= NULL
);
1745 drv
= reopen_state
->bs
->drv
;
1747 /* if we are to stay read-only, do not allow permission change
1749 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1750 reopen_state
->flags
& BDRV_O_RDWR
) {
1751 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1752 reopen_state
->bs
->device_name
);
1757 ret
= bdrv_flush(reopen_state
->bs
);
1759 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1764 if (drv
->bdrv_reopen_prepare
) {
1765 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1767 if (local_err
!= NULL
) {
1768 error_propagate(errp
, local_err
);
1770 error_setg(errp
, "failed while preparing to reopen image '%s'",
1771 reopen_state
->bs
->filename
);
1776 /* It is currently mandatory to have a bdrv_reopen_prepare()
1777 * handler for each supported drv. */
1778 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1779 drv
->format_name
, reopen_state
->bs
->device_name
,
1780 "reopening of file");
1792 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1793 * makes them final by swapping the staging BlockDriverState contents into
1794 * the active BlockDriverState contents.
1796 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1800 assert(reopen_state
!= NULL
);
1801 drv
= reopen_state
->bs
->drv
;
1802 assert(drv
!= NULL
);
1804 /* If there are any driver level actions to take */
1805 if (drv
->bdrv_reopen_commit
) {
1806 drv
->bdrv_reopen_commit(reopen_state
);
1809 /* set BDS specific flags now */
1810 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1811 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1813 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1815 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1819 * Abort the reopen, and delete and free the staged changes in
1822 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1826 assert(reopen_state
!= NULL
);
1827 drv
= reopen_state
->bs
->drv
;
1828 assert(drv
!= NULL
);
1830 if (drv
->bdrv_reopen_abort
) {
1831 drv
->bdrv_reopen_abort(reopen_state
);
1836 void bdrv_close(BlockDriverState
*bs
)
1838 BdrvAioNotifier
*ban
, *ban_next
;
1841 block_job_cancel_sync(bs
->job
);
1843 bdrv_drain_all(); /* complete I/O */
1845 bdrv_drain_all(); /* in case flush left pending I/O */
1846 notifier_list_notify(&bs
->close_notifiers
, bs
);
1849 if (bs
->backing_hd
) {
1850 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1851 bdrv_set_backing_hd(bs
, NULL
);
1852 bdrv_unref(backing_hd
);
1854 bs
->drv
->bdrv_close(bs
);
1858 bs
->copy_on_read
= 0;
1859 bs
->backing_file
[0] = '\0';
1860 bs
->backing_format
[0] = '\0';
1861 bs
->total_sectors
= 0;
1866 bs
->zero_beyond_eof
= false;
1867 QDECREF(bs
->options
);
1869 QDECREF(bs
->full_open_options
);
1870 bs
->full_open_options
= NULL
;
1872 if (bs
->file
!= NULL
) {
1873 bdrv_unref(bs
->file
);
1878 bdrv_dev_change_media_cb(bs
, false);
1880 /*throttling disk I/O limits*/
1881 if (bs
->io_limits_enabled
) {
1882 bdrv_io_limits_disable(bs
);
1885 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1888 QLIST_INIT(&bs
->aio_notifiers
);
1891 void bdrv_close_all(void)
1893 BlockDriverState
*bs
;
1895 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1896 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1898 aio_context_acquire(aio_context
);
1900 aio_context_release(aio_context
);
1904 /* Check if any requests are in-flight (including throttled requests) */
1905 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1907 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1910 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1913 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1916 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1919 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1926 * Wait for pending requests to complete across all BlockDriverStates
1928 * This function does not flush data to disk, use bdrv_flush_all() for that
1929 * after calling this function.
1931 * Note that completion of an asynchronous I/O operation can trigger any
1932 * number of other I/O operations on other devices---for example a coroutine
1933 * can be arbitrarily complex and a constant flow of I/O can come until the
1934 * coroutine is complete. Because of this, it is not possible to have a
1935 * function to drain a single device's I/O queue.
1937 void bdrv_drain_all(void)
1939 /* Always run first iteration so any pending completion BHs run */
1941 BlockDriverState
*bs
;
1946 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1947 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1950 aio_context_acquire(aio_context
);
1951 bdrv_flush_io_queue(bs
);
1952 bdrv_start_throttled_reqs(bs
);
1953 bs_busy
= bdrv_requests_pending(bs
);
1954 bs_busy
|= aio_poll(aio_context
, bs_busy
);
1955 aio_context_release(aio_context
);
1962 /* make a BlockDriverState anonymous by removing from bdrv_state and
1963 * graph_bdrv_state list.
1964 Also, NULL terminate the device_name to prevent double remove */
1965 void bdrv_make_anon(BlockDriverState
*bs
)
1967 if (bs
->device_name
[0] != '\0') {
1968 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1970 bs
->device_name
[0] = '\0';
1971 if (bs
->node_name
[0] != '\0') {
1972 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1974 bs
->node_name
[0] = '\0';
1977 static void bdrv_rebind(BlockDriverState
*bs
)
1979 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1980 bs
->drv
->bdrv_rebind(bs
);
1984 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1985 BlockDriverState
*bs_src
)
1987 /* move some fields that need to stay attached to the device */
1990 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1991 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1992 bs_dest
->dev
= bs_src
->dev
;
1993 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1994 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1996 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1998 /* i/o throttled req */
1999 memcpy(&bs_dest
->throttle_state
,
2000 &bs_src
->throttle_state
,
2001 sizeof(ThrottleState
));
2002 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2003 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2004 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
2007 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2008 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2011 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2012 bs_dest
->iostatus
= bs_src
->iostatus
;
2015 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2017 /* reference count */
2018 bs_dest
->refcnt
= bs_src
->refcnt
;
2021 bs_dest
->job
= bs_src
->job
;
2023 /* keep the same entry in bdrv_states */
2024 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
2025 bs_src
->device_name
);
2026 bs_dest
->device_list
= bs_src
->device_list
;
2027 bs_dest
->blk
= bs_src
->blk
;
2029 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2030 sizeof(bs_dest
->op_blockers
));
2034 * Swap bs contents for two image chains while they are live,
2035 * while keeping required fields on the BlockDriverState that is
2036 * actually attached to a device.
2038 * This will modify the BlockDriverState fields, and swap contents
2039 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2041 * bs_new must be nameless and not attached to a BlockBackend.
2043 * This function does not create any image files.
2045 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2047 BlockDriverState tmp
;
2049 /* The code needs to swap the node_name but simply swapping node_list won't
2050 * work so first remove the nodes from the graph list, do the swap then
2051 * insert them back if needed.
2053 if (bs_new
->node_name
[0] != '\0') {
2054 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2056 if (bs_old
->node_name
[0] != '\0') {
2057 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2060 /* bs_new must be nameless and shouldn't have anything fancy enabled */
2061 assert(bs_new
->device_name
[0] == '\0');
2062 assert(!bs_new
->blk
);
2063 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2064 assert(bs_new
->job
== NULL
);
2065 assert(bs_new
->dev
== NULL
);
2066 assert(bs_new
->io_limits_enabled
== false);
2067 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2073 /* there are some fields that should not be swapped, move them back */
2074 bdrv_move_feature_fields(&tmp
, bs_old
);
2075 bdrv_move_feature_fields(bs_old
, bs_new
);
2076 bdrv_move_feature_fields(bs_new
, &tmp
);
2078 /* bs_new must remain nameless and unattached */
2079 assert(bs_new
->device_name
[0] == '\0');
2080 assert(!bs_new
->blk
);
2082 /* Check a few fields that should remain attached to the device */
2083 assert(bs_new
->dev
== NULL
);
2084 assert(bs_new
->job
== NULL
);
2085 assert(bs_new
->io_limits_enabled
== false);
2086 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2088 /* insert the nodes back into the graph node list if needed */
2089 if (bs_new
->node_name
[0] != '\0') {
2090 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2092 if (bs_old
->node_name
[0] != '\0') {
2093 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2096 bdrv_rebind(bs_new
);
2097 bdrv_rebind(bs_old
);
2101 * Add new bs contents at the top of an image chain while the chain is
2102 * live, while keeping required fields on the top layer.
2104 * This will modify the BlockDriverState fields, and swap contents
2105 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2107 * bs_new must be nameless and not attached to a BlockBackend.
2109 * This function does not create any image files.
2111 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2113 bdrv_swap(bs_new
, bs_top
);
2115 /* The contents of 'tmp' will become bs_top, as we are
2116 * swapping bs_new and bs_top contents. */
2117 bdrv_set_backing_hd(bs_top
, bs_new
);
2120 static void bdrv_delete(BlockDriverState
*bs
)
2124 assert(bdrv_op_blocker_is_empty(bs
));
2125 assert(!bs
->refcnt
);
2126 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2130 /* remove from list, if necessary */
2136 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
2137 /* TODO change to DeviceState *dev when all users are qdevified */
2143 bdrv_iostatus_reset(bs
);
2145 /* We're expecting I/O from the device so bump up coroutine pool size */
2146 qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION
);
2150 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2151 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
2153 if (bdrv_attach_dev(bs
, dev
) < 0) {
2158 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
2159 /* TODO change to DeviceState *dev when all users are qdevified */
2161 assert(bs
->dev
== dev
);
2164 bs
->dev_opaque
= NULL
;
2165 bs
->guest_block_size
= 512;
2166 qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION
);
2169 /* TODO change to return DeviceState * when all users are qdevified */
2170 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
2175 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
2179 bs
->dev_opaque
= opaque
;
2182 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
2184 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
2185 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
2186 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
2187 if (tray_was_closed
) {
2189 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2190 true, &error_abort
);
2194 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2195 false, &error_abort
);
2200 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
2202 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
2205 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
2207 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
2208 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
2212 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
2214 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
2215 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
2220 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
2222 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
2223 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
2227 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
2229 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
2230 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
2236 * Run consistency checks on an image
2238 * Returns 0 if the check could be completed (it doesn't mean that the image is
2239 * free of errors) or -errno when an internal error occurred. The results of the
2240 * check are stored in res.
2242 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2244 if (bs
->drv
== NULL
) {
2247 if (bs
->drv
->bdrv_check
== NULL
) {
2251 memset(res
, 0, sizeof(*res
));
2252 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2255 #define COMMIT_BUF_SECTORS 2048
2257 /* commit COW file into the raw image */
2258 int bdrv_commit(BlockDriverState
*bs
)
2260 BlockDriver
*drv
= bs
->drv
;
2261 int64_t sector
, total_sectors
, length
, backing_length
;
2262 int n
, ro
, open_flags
;
2264 uint8_t *buf
= NULL
;
2265 char filename
[PATH_MAX
];
2270 if (!bs
->backing_hd
) {
2274 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT
, NULL
) ||
2275 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
, NULL
)) {
2279 ro
= bs
->backing_hd
->read_only
;
2280 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2281 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
2282 open_flags
= bs
->backing_hd
->open_flags
;
2285 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2290 length
= bdrv_getlength(bs
);
2296 backing_length
= bdrv_getlength(bs
->backing_hd
);
2297 if (backing_length
< 0) {
2298 ret
= backing_length
;
2302 /* If our top snapshot is larger than the backing file image,
2303 * grow the backing file image if possible. If not possible,
2304 * we must return an error */
2305 if (length
> backing_length
) {
2306 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2312 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2314 /* qemu_try_blockalign() for bs will choose an alignment that works for
2315 * bs->backing_hd as well, so no need to compare the alignment manually. */
2316 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2322 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2323 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2328 ret
= bdrv_read(bs
, sector
, buf
, n
);
2333 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2340 if (drv
->bdrv_make_empty
) {
2341 ret
= drv
->bdrv_make_empty(bs
);
2349 * Make sure all data we wrote to the backing device is actually
2352 if (bs
->backing_hd
) {
2353 bdrv_flush(bs
->backing_hd
);
2361 /* ignoring error return here */
2362 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2368 int bdrv_commit_all(void)
2370 BlockDriverState
*bs
;
2372 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2373 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2375 aio_context_acquire(aio_context
);
2376 if (bs
->drv
&& bs
->backing_hd
) {
2377 int ret
= bdrv_commit(bs
);
2379 aio_context_release(aio_context
);
2383 aio_context_release(aio_context
);
2389 * Remove an active request from the tracked requests list
2391 * This function should be called when a tracked request is completing.
2393 static void tracked_request_end(BdrvTrackedRequest
*req
)
2395 if (req
->serialising
) {
2396 req
->bs
->serialising_in_flight
--;
2399 QLIST_REMOVE(req
, list
);
2400 qemu_co_queue_restart_all(&req
->wait_queue
);
2404 * Add an active request to the tracked requests list
2406 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2407 BlockDriverState
*bs
,
2409 unsigned int bytes
, bool is_write
)
2411 *req
= (BdrvTrackedRequest
){
2415 .is_write
= is_write
,
2416 .co
= qemu_coroutine_self(),
2417 .serialising
= false,
2418 .overlap_offset
= offset
,
2419 .overlap_bytes
= bytes
,
2422 qemu_co_queue_init(&req
->wait_queue
);
2424 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2427 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2429 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2430 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2433 if (!req
->serialising
) {
2434 req
->bs
->serialising_in_flight
++;
2435 req
->serialising
= true;
2438 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2439 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2443 * Round a region to cluster boundaries
2445 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2446 int64_t sector_num
, int nb_sectors
,
2447 int64_t *cluster_sector_num
,
2448 int *cluster_nb_sectors
)
2450 BlockDriverInfo bdi
;
2452 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2453 *cluster_sector_num
= sector_num
;
2454 *cluster_nb_sectors
= nb_sectors
;
2456 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2457 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2458 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2463 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2465 BlockDriverInfo bdi
;
2468 ret
= bdrv_get_info(bs
, &bdi
);
2469 if (ret
< 0 || bdi
.cluster_size
== 0) {
2470 return bs
->request_alignment
;
2472 return bdi
.cluster_size
;
2476 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2477 int64_t offset
, unsigned int bytes
)
2480 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2484 if (req
->overlap_offset
>= offset
+ bytes
) {
2490 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2492 BlockDriverState
*bs
= self
->bs
;
2493 BdrvTrackedRequest
*req
;
2495 bool waited
= false;
2497 if (!bs
->serialising_in_flight
) {
2503 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2504 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2507 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2508 self
->overlap_bytes
))
2510 /* Hitting this means there was a reentrant request, for
2511 * example, a block driver issuing nested requests. This must
2512 * never happen since it means deadlock.
2514 assert(qemu_coroutine_self() != req
->co
);
2516 /* If the request is already (indirectly) waiting for us, or
2517 * will wait for us as soon as it wakes up, then just go on
2518 * (instead of producing a deadlock in the former case). */
2519 if (!req
->waiting_for
) {
2520 self
->waiting_for
= req
;
2521 qemu_co_queue_wait(&req
->wait_queue
);
2522 self
->waiting_for
= NULL
;
2537 * -EINVAL - backing format specified, but no file
2538 * -ENOSPC - can't update the backing file because no space is left in the
2540 * -ENOTSUP - format driver doesn't support changing the backing file
2542 int bdrv_change_backing_file(BlockDriverState
*bs
,
2543 const char *backing_file
, const char *backing_fmt
)
2545 BlockDriver
*drv
= bs
->drv
;
2548 /* Backing file format doesn't make sense without a backing file */
2549 if (backing_fmt
&& !backing_file
) {
2553 if (drv
->bdrv_change_backing_file
!= NULL
) {
2554 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2560 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2561 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2567 * Finds the image layer in the chain that has 'bs' as its backing file.
2569 * active is the current topmost image.
2571 * Returns NULL if bs is not found in active's image chain,
2572 * or if active == bs.
2574 * Returns the bottommost base image if bs == NULL.
2576 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2577 BlockDriverState
*bs
)
2579 while (active
&& bs
!= active
->backing_hd
) {
2580 active
= active
->backing_hd
;
2586 /* Given a BDS, searches for the base layer. */
2587 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2589 return bdrv_find_overlay(bs
, NULL
);
2592 typedef struct BlkIntermediateStates
{
2593 BlockDriverState
*bs
;
2594 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2595 } BlkIntermediateStates
;
2599 * Drops images above 'base' up to and including 'top', and sets the image
2600 * above 'top' to have base as its backing file.
2602 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2603 * information in 'bs' can be properly updated.
2605 * E.g., this will convert the following chain:
2606 * bottom <- base <- intermediate <- top <- active
2610 * bottom <- base <- active
2612 * It is allowed for bottom==base, in which case it converts:
2614 * base <- intermediate <- top <- active
2620 * If backing_file_str is non-NULL, it will be used when modifying top's
2621 * overlay image metadata.
2624 * if active == top, that is considered an error
2627 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2628 BlockDriverState
*base
, const char *backing_file_str
)
2630 BlockDriverState
*intermediate
;
2631 BlockDriverState
*base_bs
= NULL
;
2632 BlockDriverState
*new_top_bs
= NULL
;
2633 BlkIntermediateStates
*intermediate_state
, *next
;
2636 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2637 QSIMPLEQ_INIT(&states_to_delete
);
2639 if (!top
->drv
|| !base
->drv
) {
2643 new_top_bs
= bdrv_find_overlay(active
, top
);
2645 if (new_top_bs
== NULL
) {
2646 /* we could not find the image above 'top', this is an error */
2650 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2651 * to do, no intermediate images */
2652 if (new_top_bs
->backing_hd
== base
) {
2659 /* now we will go down through the list, and add each BDS we find
2660 * into our deletion queue, until we hit the 'base'
2662 while (intermediate
) {
2663 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2664 intermediate_state
->bs
= intermediate
;
2665 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2667 if (intermediate
->backing_hd
== base
) {
2668 base_bs
= intermediate
->backing_hd
;
2671 intermediate
= intermediate
->backing_hd
;
2673 if (base_bs
== NULL
) {
2674 /* something went wrong, we did not end at the base. safely
2675 * unravel everything, and exit with error */
2679 /* success - we can delete the intermediate states, and link top->base */
2680 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2681 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2682 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2686 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2688 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2689 /* so that bdrv_close() does not recursively close the chain */
2690 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2691 bdrv_unref(intermediate_state
->bs
);
2696 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2697 g_free(intermediate_state
);
2703 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2708 if (size
> INT_MAX
) {
2712 if (!bdrv_is_inserted(bs
))
2718 len
= bdrv_getlength(bs
);
2723 if ((offset
> len
) || (len
- offset
< size
))
2729 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2732 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2736 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2737 nb_sectors
* BDRV_SECTOR_SIZE
);
2740 typedef struct RwCo
{
2741 BlockDriverState
*bs
;
2746 BdrvRequestFlags flags
;
2749 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2751 RwCo
*rwco
= opaque
;
2753 if (!rwco
->is_write
) {
2754 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2755 rwco
->qiov
->size
, rwco
->qiov
,
2758 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2759 rwco
->qiov
->size
, rwco
->qiov
,
2765 * Process a vectored synchronous request using coroutines
2767 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2768 QEMUIOVector
*qiov
, bool is_write
,
2769 BdrvRequestFlags flags
)
2776 .is_write
= is_write
,
2782 * In sync call context, when the vcpu is blocked, this throttling timer
2783 * will not fire; so the I/O throttling function has to be disabled here
2784 * if it has been enabled.
2786 if (bs
->io_limits_enabled
) {
2787 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2788 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2789 bdrv_io_limits_disable(bs
);
2792 if (qemu_in_coroutine()) {
2793 /* Fast-path if already in coroutine context */
2794 bdrv_rw_co_entry(&rwco
);
2796 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2798 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2799 qemu_coroutine_enter(co
, &rwco
);
2800 while (rwco
.ret
== NOT_DONE
) {
2801 aio_poll(aio_context
, true);
2808 * Process a synchronous request using coroutines
2810 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2811 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2814 struct iovec iov
= {
2815 .iov_base
= (void *)buf
,
2816 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2819 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2823 qemu_iovec_init_external(&qiov
, &iov
, 1);
2824 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2825 &qiov
, is_write
, flags
);
2828 /* return < 0 if error. See bdrv_write() for the return codes */
2829 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2830 uint8_t *buf
, int nb_sectors
)
2832 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2835 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2836 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2837 uint8_t *buf
, int nb_sectors
)
2842 enabled
= bs
->io_limits_enabled
;
2843 bs
->io_limits_enabled
= false;
2844 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2845 bs
->io_limits_enabled
= enabled
;
2849 /* Return < 0 if error. Important errors are:
2850 -EIO generic I/O error (may happen for all errors)
2851 -ENOMEDIUM No media inserted.
2852 -EINVAL Invalid sector number or nb_sectors
2853 -EACCES Trying to write a read-only device
2855 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2856 const uint8_t *buf
, int nb_sectors
)
2858 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2861 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2862 int nb_sectors
, BdrvRequestFlags flags
)
2864 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2865 BDRV_REQ_ZERO_WRITE
| flags
);
2869 * Completely zero out a block device with the help of bdrv_write_zeroes.
2870 * The operation is sped up by checking the block status and only writing
2871 * zeroes to the device if they currently do not return zeroes. Optional
2872 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2874 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2876 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2878 int64_t target_sectors
, ret
, nb_sectors
, sector_num
= 0;
2881 target_sectors
= bdrv_nb_sectors(bs
);
2882 if (target_sectors
< 0) {
2883 return target_sectors
;
2887 nb_sectors
= target_sectors
- sector_num
;
2888 if (nb_sectors
<= 0) {
2891 if (nb_sectors
> INT_MAX
) {
2892 nb_sectors
= INT_MAX
;
2894 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2896 error_report("error getting block status at sector %" PRId64
": %s",
2897 sector_num
, strerror(-ret
));
2900 if (ret
& BDRV_BLOCK_ZERO
) {
2904 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2906 error_report("error writing zeroes at sector %" PRId64
": %s",
2907 sector_num
, strerror(-ret
));
2914 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2917 struct iovec iov
= {
2918 .iov_base
= (void *)buf
,
2927 qemu_iovec_init_external(&qiov
, &iov
, 1);
2928 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2936 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2940 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2948 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2949 const void *buf
, int bytes
)
2952 struct iovec iov
= {
2953 .iov_base
= (void *) buf
,
2961 qemu_iovec_init_external(&qiov
, &iov
, 1);
2962 return bdrv_pwritev(bs
, offset
, &qiov
);
2966 * Writes to the file and ensures that no writes are reordered across this
2967 * request (acts as a barrier)
2969 * Returns 0 on success, -errno in error cases.
2971 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2972 const void *buf
, int count
)
2976 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2981 /* No flush needed for cache modes that already do it */
2982 if (bs
->enable_write_cache
) {
2989 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2990 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2992 /* Perform I/O through a temporary buffer so that users who scribble over
2993 * their read buffer while the operation is in progress do not end up
2994 * modifying the image file. This is critical for zero-copy guest I/O
2995 * where anything might happen inside guest memory.
2997 void *bounce_buffer
;
2999 BlockDriver
*drv
= bs
->drv
;
3001 QEMUIOVector bounce_qiov
;
3002 int64_t cluster_sector_num
;
3003 int cluster_nb_sectors
;
3007 /* Cover entire cluster so no additional backing file I/O is required when
3008 * allocating cluster in the image file.
3010 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
3011 &cluster_sector_num
, &cluster_nb_sectors
);
3013 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
3014 cluster_sector_num
, cluster_nb_sectors
);
3016 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
3017 iov
.iov_base
= bounce_buffer
= qemu_try_blockalign(bs
, iov
.iov_len
);
3018 if (bounce_buffer
== NULL
) {
3023 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
3025 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
3031 if (drv
->bdrv_co_write_zeroes
&&
3032 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
3033 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
3034 cluster_nb_sectors
, 0);
3036 /* This does not change the data on the disk, it is not necessary
3037 * to flush even in cache=writethrough mode.
3039 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
3044 /* It might be okay to ignore write errors for guest requests. If this
3045 * is a deliberate copy-on-read then we don't want to ignore the error.
3046 * Simply report it in all cases.
3051 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
3052 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
3053 nb_sectors
* BDRV_SECTOR_SIZE
);
3056 qemu_vfree(bounce_buffer
);
3061 * Forwards an already correctly aligned request to the BlockDriver. This
3062 * handles copy on read and zeroing after EOF; any other features must be
3063 * implemented by the caller.
3065 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
3066 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3067 int64_t align
, QEMUIOVector
*qiov
, int flags
)
3069 BlockDriver
*drv
= bs
->drv
;
3072 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3073 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3075 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3076 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3077 assert(!qiov
|| bytes
== qiov
->size
);
3079 /* Handle Copy on Read and associated serialisation */
3080 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3081 /* If we touch the same cluster it counts as an overlap. This
3082 * guarantees that allocating writes will be serialized and not race
3083 * with each other for the same cluster. For example, in copy-on-read
3084 * it ensures that the CoR read and write operations are atomic and
3085 * guest writes cannot interleave between them. */
3086 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3089 wait_serialising_requests(req
);
3091 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3094 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3099 if (!ret
|| pnum
!= nb_sectors
) {
3100 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3105 /* Forward the request to the BlockDriver */
3106 if (!(bs
->zero_beyond_eof
&& bs
->growable
)) {
3107 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3109 /* Read zeros after EOF of growable BDSes */
3110 int64_t total_sectors
, max_nb_sectors
;
3112 total_sectors
= bdrv_nb_sectors(bs
);
3113 if (total_sectors
< 0) {
3114 ret
= total_sectors
;
3118 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3119 align
>> BDRV_SECTOR_BITS
);
3120 if (max_nb_sectors
> 0) {
3121 QEMUIOVector local_qiov
;
3122 size_t local_sectors
;
3124 max_nb_sectors
= MIN(max_nb_sectors
, SIZE_MAX
/ BDRV_SECTOR_BITS
);
3125 local_sectors
= MIN(max_nb_sectors
, nb_sectors
);
3127 qemu_iovec_init(&local_qiov
, qiov
->niov
);
3128 qemu_iovec_concat(&local_qiov
, qiov
, 0,
3129 local_sectors
* BDRV_SECTOR_SIZE
);
3131 ret
= drv
->bdrv_co_readv(bs
, sector_num
, local_sectors
,
3134 qemu_iovec_destroy(&local_qiov
);
3139 /* Reading beyond end of file is supposed to produce zeroes */
3140 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3141 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3142 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3144 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3153 * Handle a read request in coroutine context
3155 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3156 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3157 BdrvRequestFlags flags
)
3159 BlockDriver
*drv
= bs
->drv
;
3160 BdrvTrackedRequest req
;
3162 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3163 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3164 uint8_t *head_buf
= NULL
;
3165 uint8_t *tail_buf
= NULL
;
3166 QEMUIOVector local_qiov
;
3167 bool use_local_qiov
= false;
3173 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3177 if (bs
->copy_on_read
) {
3178 flags
|= BDRV_REQ_COPY_ON_READ
;
3181 /* throttling disk I/O */
3182 if (bs
->io_limits_enabled
) {
3183 bdrv_io_limits_intercept(bs
, bytes
, false);
3186 /* Align read if necessary by padding qiov */
3187 if (offset
& (align
- 1)) {
3188 head_buf
= qemu_blockalign(bs
, align
);
3189 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3190 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3191 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3192 use_local_qiov
= true;
3194 bytes
+= offset
& (align
- 1);
3195 offset
= offset
& ~(align
- 1);
3198 if ((offset
+ bytes
) & (align
- 1)) {
3199 if (!use_local_qiov
) {
3200 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3201 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3202 use_local_qiov
= true;
3204 tail_buf
= qemu_blockalign(bs
, align
);
3205 qemu_iovec_add(&local_qiov
, tail_buf
,
3206 align
- ((offset
+ bytes
) & (align
- 1)));
3208 bytes
= ROUND_UP(bytes
, align
);
3211 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3212 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3213 use_local_qiov
? &local_qiov
: qiov
,
3215 tracked_request_end(&req
);
3217 if (use_local_qiov
) {
3218 qemu_iovec_destroy(&local_qiov
);
3219 qemu_vfree(head_buf
);
3220 qemu_vfree(tail_buf
);
3226 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3227 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3228 BdrvRequestFlags flags
)
3230 if (nb_sectors
< 0 || nb_sectors
> (UINT_MAX
>> BDRV_SECTOR_BITS
)) {
3234 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3235 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3238 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3239 int nb_sectors
, QEMUIOVector
*qiov
)
3241 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3243 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3246 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3247 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3249 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3251 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3252 BDRV_REQ_COPY_ON_READ
);
3255 /* if no limit is specified in the BlockLimits use a default
3256 * of 32768 512-byte sectors (16 MiB) per request.
3258 #define MAX_WRITE_ZEROES_DEFAULT 32768
3260 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3261 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3263 BlockDriver
*drv
= bs
->drv
;
3265 struct iovec iov
= {0};
3268 int max_write_zeroes
= bs
->bl
.max_write_zeroes
?
3269 bs
->bl
.max_write_zeroes
: MAX_WRITE_ZEROES_DEFAULT
;
3271 while (nb_sectors
> 0 && !ret
) {
3272 int num
= nb_sectors
;
3274 /* Align request. Block drivers can expect the "bulk" of the request
3277 if (bs
->bl
.write_zeroes_alignment
3278 && num
> bs
->bl
.write_zeroes_alignment
) {
3279 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3280 /* Make a small request up to the first aligned sector. */
3281 num
= bs
->bl
.write_zeroes_alignment
;
3282 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3283 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3284 /* Shorten the request to the last aligned sector. num cannot
3285 * underflow because num > bs->bl.write_zeroes_alignment.
3287 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3291 /* limit request size */
3292 if (num
> max_write_zeroes
) {
3293 num
= max_write_zeroes
;
3297 /* First try the efficient write zeroes operation */
3298 if (drv
->bdrv_co_write_zeroes
) {
3299 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3302 if (ret
== -ENOTSUP
) {
3303 /* Fall back to bounce buffer if write zeroes is unsupported */
3304 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3305 if (iov
.iov_base
== NULL
) {
3306 iov
.iov_base
= qemu_try_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3307 if (iov
.iov_base
== NULL
) {
3311 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3313 qemu_iovec_init_external(&qiov
, &iov
, 1);
3315 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3317 /* Keep bounce buffer around if it is big enough for all
3318 * all future requests.
3320 if (num
< max_write_zeroes
) {
3321 qemu_vfree(iov
.iov_base
);
3322 iov
.iov_base
= NULL
;
3331 qemu_vfree(iov
.iov_base
);
3336 * Forwards an already correctly aligned write request to the BlockDriver.
3338 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3339 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3340 QEMUIOVector
*qiov
, int flags
)
3342 BlockDriver
*drv
= bs
->drv
;
3346 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3347 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3349 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3350 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3351 assert(!qiov
|| bytes
== qiov
->size
);
3353 waited
= wait_serialising_requests(req
);
3354 assert(!waited
|| !req
->serialising
);
3355 assert(req
->overlap_offset
<= offset
);
3356 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3358 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3360 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3361 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3362 qemu_iovec_is_zero(qiov
)) {
3363 flags
|= BDRV_REQ_ZERO_WRITE
;
3364 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3365 flags
|= BDRV_REQ_MAY_UNMAP
;
3370 /* Do nothing, write notifier decided to fail this request */
3371 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3372 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3373 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3375 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3376 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3378 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3380 if (ret
== 0 && !bs
->enable_write_cache
) {
3381 ret
= bdrv_co_flush(bs
);
3384 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3386 block_acct_highest_sector(&bs
->stats
, sector_num
, nb_sectors
);
3388 if (bs
->growable
&& ret
>= 0) {
3389 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3396 * Handle a write request in coroutine context
3398 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3399 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3400 BdrvRequestFlags flags
)
3402 BdrvTrackedRequest req
;
3403 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3404 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3405 uint8_t *head_buf
= NULL
;
3406 uint8_t *tail_buf
= NULL
;
3407 QEMUIOVector local_qiov
;
3408 bool use_local_qiov
= false;
3414 if (bs
->read_only
) {
3417 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3421 /* throttling disk I/O */
3422 if (bs
->io_limits_enabled
) {
3423 bdrv_io_limits_intercept(bs
, bytes
, true);
3427 * Align write if necessary by performing a read-modify-write cycle.
3428 * Pad qiov with the read parts and be sure to have a tracked request not
3429 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3431 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3433 if (offset
& (align
- 1)) {
3434 QEMUIOVector head_qiov
;
3435 struct iovec head_iov
;
3437 mark_request_serialising(&req
, align
);
3438 wait_serialising_requests(&req
);
3440 head_buf
= qemu_blockalign(bs
, align
);
3441 head_iov
= (struct iovec
) {
3442 .iov_base
= head_buf
,
3445 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3447 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3448 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3449 align
, &head_qiov
, 0);
3453 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3455 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3456 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3457 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3458 use_local_qiov
= true;
3460 bytes
+= offset
& (align
- 1);
3461 offset
= offset
& ~(align
- 1);
3464 if ((offset
+ bytes
) & (align
- 1)) {
3465 QEMUIOVector tail_qiov
;
3466 struct iovec tail_iov
;
3470 mark_request_serialising(&req
, align
);
3471 waited
= wait_serialising_requests(&req
);
3472 assert(!waited
|| !use_local_qiov
);
3474 tail_buf
= qemu_blockalign(bs
, align
);
3475 tail_iov
= (struct iovec
) {
3476 .iov_base
= tail_buf
,
3479 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3481 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3482 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3483 align
, &tail_qiov
, 0);
3487 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3489 if (!use_local_qiov
) {
3490 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3491 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3492 use_local_qiov
= true;
3495 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3496 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3498 bytes
= ROUND_UP(bytes
, align
);
3501 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3502 use_local_qiov
? &local_qiov
: qiov
,
3506 tracked_request_end(&req
);
3508 if (use_local_qiov
) {
3509 qemu_iovec_destroy(&local_qiov
);
3511 qemu_vfree(head_buf
);
3512 qemu_vfree(tail_buf
);
3517 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3518 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3519 BdrvRequestFlags flags
)
3521 if (nb_sectors
< 0 || nb_sectors
> (INT_MAX
>> BDRV_SECTOR_BITS
)) {
3525 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3526 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3529 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3530 int nb_sectors
, QEMUIOVector
*qiov
)
3532 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3534 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3537 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3538 int64_t sector_num
, int nb_sectors
,
3539 BdrvRequestFlags flags
)
3541 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3543 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3544 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3547 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3548 BDRV_REQ_ZERO_WRITE
| flags
);
3552 * Truncate file to 'offset' bytes (needed only for file protocols)
3554 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3556 BlockDriver
*drv
= bs
->drv
;
3560 if (!drv
->bdrv_truncate
)
3565 ret
= drv
->bdrv_truncate(bs
, offset
);
3567 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3568 bdrv_dev_resize_cb(bs
);
3574 * Length of a allocated file in bytes. Sparse files are counted by actual
3575 * allocated space. Return < 0 if error or unknown.
3577 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3579 BlockDriver
*drv
= bs
->drv
;
3583 if (drv
->bdrv_get_allocated_file_size
) {
3584 return drv
->bdrv_get_allocated_file_size(bs
);
3587 return bdrv_get_allocated_file_size(bs
->file
);
3593 * Return number of sectors on success, -errno on error.
3595 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
3597 BlockDriver
*drv
= bs
->drv
;
3602 if (drv
->has_variable_length
) {
3603 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3608 return bs
->total_sectors
;
3612 * Return length in bytes on success, -errno on error.
3613 * The length is always a multiple of BDRV_SECTOR_SIZE.
3615 int64_t bdrv_getlength(BlockDriverState
*bs
)
3617 int64_t ret
= bdrv_nb_sectors(bs
);
3619 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
3622 /* return 0 as number of sectors if no device present or error */
3623 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3625 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
3627 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
3630 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3631 BlockdevOnError on_write_error
)
3633 bs
->on_read_error
= on_read_error
;
3634 bs
->on_write_error
= on_write_error
;
3637 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3639 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3642 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3644 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3647 case BLOCKDEV_ON_ERROR_ENOSPC
:
3648 return (error
== ENOSPC
) ?
3649 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
3650 case BLOCKDEV_ON_ERROR_STOP
:
3651 return BLOCK_ERROR_ACTION_STOP
;
3652 case BLOCKDEV_ON_ERROR_REPORT
:
3653 return BLOCK_ERROR_ACTION_REPORT
;
3654 case BLOCKDEV_ON_ERROR_IGNORE
:
3655 return BLOCK_ERROR_ACTION_IGNORE
;
3661 static void send_qmp_error_event(BlockDriverState
*bs
,
3662 BlockErrorAction action
,
3663 bool is_read
, int error
)
3665 BlockErrorAction ac
;
3667 ac
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
3668 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), ac
, action
,
3669 bdrv_iostatus_is_enabled(bs
),
3670 error
== ENOSPC
, strerror(error
),
3674 /* This is done by device models because, while the block layer knows
3675 * about the error, it does not know whether an operation comes from
3676 * the device or the block layer (from a job, for example).
3678 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3679 bool is_read
, int error
)
3683 if (action
== BLOCK_ERROR_ACTION_STOP
) {
3684 /* First set the iostatus, so that "info block" returns an iostatus
3685 * that matches the events raised so far (an additional error iostatus
3686 * is fine, but not a lost one).
3688 bdrv_iostatus_set_err(bs
, error
);
3690 /* Then raise the request to stop the VM and the event.
3691 * qemu_system_vmstop_request_prepare has two effects. First,
3692 * it ensures that the STOP event always comes after the
3693 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3694 * can observe the STOP event and do a "cont" before the STOP
3695 * event is issued, the VM will not stop. In this case, vm_start()
3696 * also ensures that the STOP/RESUME pair of events is emitted.
3698 qemu_system_vmstop_request_prepare();
3699 send_qmp_error_event(bs
, action
, is_read
, error
);
3700 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
3702 send_qmp_error_event(bs
, action
, is_read
, error
);
3706 int bdrv_is_read_only(BlockDriverState
*bs
)
3708 return bs
->read_only
;
3711 int bdrv_is_sg(BlockDriverState
*bs
)
3716 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3718 return bs
->enable_write_cache
;
3721 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3723 bs
->enable_write_cache
= wce
;
3725 /* so a reopen() will preserve wce */
3727 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3729 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3733 int bdrv_is_encrypted(BlockDriverState
*bs
)
3735 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3737 return bs
->encrypted
;
3740 int bdrv_key_required(BlockDriverState
*bs
)
3742 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3744 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3746 return (bs
->encrypted
&& !bs
->valid_key
);
3749 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3752 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3753 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3759 if (!bs
->encrypted
) {
3761 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3764 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3767 } else if (!bs
->valid_key
) {
3769 /* call the change callback now, we skipped it on open */
3770 bdrv_dev_change_media_cb(bs
, true);
3775 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3777 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3780 static int qsort_strcmp(const void *a
, const void *b
)
3782 return strcmp(a
, b
);
3785 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3791 const char **formats
= NULL
;
3793 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3794 if (drv
->format_name
) {
3797 while (formats
&& i
&& !found
) {
3798 found
= !strcmp(formats
[--i
], drv
->format_name
);
3802 formats
= g_renew(const char *, formats
, count
+ 1);
3803 formats
[count
++] = drv
->format_name
;
3808 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
3810 for (i
= 0; i
< count
; i
++) {
3811 it(opaque
, formats
[i
]);
3817 /* This function is to find block backend bs */
3818 BlockDriverState
*bdrv_find(const char *name
)
3820 BlockDriverState
*bs
;
3822 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3823 if (!strcmp(name
, bs
->device_name
)) {
3830 /* This function is to find a node in the bs graph */
3831 BlockDriverState
*bdrv_find_node(const char *node_name
)
3833 BlockDriverState
*bs
;
3837 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3838 if (!strcmp(node_name
, bs
->node_name
)) {
3845 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3846 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3848 BlockDeviceInfoList
*list
, *entry
;
3849 BlockDriverState
*bs
;
3852 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3853 entry
= g_malloc0(sizeof(*entry
));
3854 entry
->value
= bdrv_block_device_info(bs
);
3862 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3863 const char *node_name
,
3866 BlockDriverState
*bs
= NULL
;
3869 bs
= bdrv_find(device
);
3877 bs
= bdrv_find_node(node_name
);
3884 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3885 device
? device
: "",
3886 node_name
? node_name
: "");
3890 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3891 * return false. If either argument is NULL, return false. */
3892 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
3894 while (top
&& top
!= base
) {
3895 top
= top
->backing_hd
;
3901 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3904 return QTAILQ_FIRST(&bdrv_states
);
3906 return QTAILQ_NEXT(bs
, device_list
);
3909 const char *bdrv_get_device_name(BlockDriverState
*bs
)
3911 return bs
->device_name
;
3914 int bdrv_get_flags(BlockDriverState
*bs
)
3916 return bs
->open_flags
;
3919 int bdrv_flush_all(void)
3921 BlockDriverState
*bs
;
3924 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3925 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3928 aio_context_acquire(aio_context
);
3929 ret
= bdrv_flush(bs
);
3930 if (ret
< 0 && !result
) {
3933 aio_context_release(aio_context
);
3939 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3944 int bdrv_has_zero_init(BlockDriverState
*bs
)
3948 /* If BS is a copy on write image, it is initialized to
3949 the contents of the base image, which may not be zeroes. */
3950 if (bs
->backing_hd
) {
3953 if (bs
->drv
->bdrv_has_zero_init
) {
3954 return bs
->drv
->bdrv_has_zero_init(bs
);
3961 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3963 BlockDriverInfo bdi
;
3965 if (bs
->backing_hd
) {
3969 if (bdrv_get_info(bs
, &bdi
) == 0) {
3970 return bdi
.unallocated_blocks_are_zero
;
3976 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3978 BlockDriverInfo bdi
;
3980 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3984 if (bdrv_get_info(bs
, &bdi
) == 0) {
3985 return bdi
.can_write_zeroes_with_unmap
;
3991 typedef struct BdrvCoGetBlockStatusData
{
3992 BlockDriverState
*bs
;
3993 BlockDriverState
*base
;
3999 } BdrvCoGetBlockStatusData
;
4002 * Returns true iff the specified sector is present in the disk image. Drivers
4003 * not implementing the functionality are assumed to not support backing files,
4004 * hence all their sectors are reported as allocated.
4006 * If 'sector_num' is beyond the end of the disk image the return value is 0
4007 * and 'pnum' is set to 0.
4009 * 'pnum' is set to the number of sectors (including and immediately following
4010 * the specified sector) that are known to be in the same
4011 * allocated/unallocated state.
4013 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
4014 * beyond the end of the disk image it will be clamped.
4016 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
4018 int nb_sectors
, int *pnum
)
4020 int64_t total_sectors
;
4024 total_sectors
= bdrv_nb_sectors(bs
);
4025 if (total_sectors
< 0) {
4026 return total_sectors
;
4029 if (sector_num
>= total_sectors
) {
4034 n
= total_sectors
- sector_num
;
4035 if (n
< nb_sectors
) {
4039 if (!bs
->drv
->bdrv_co_get_block_status
) {
4041 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
;
4042 if (bs
->drv
->protocol_name
) {
4043 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
4048 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4054 if (ret
& BDRV_BLOCK_RAW
) {
4055 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
4056 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4060 if (ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ZERO
)) {
4061 ret
|= BDRV_BLOCK_ALLOCATED
;
4064 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
4065 if (bdrv_unallocated_blocks_are_zero(bs
)) {
4066 ret
|= BDRV_BLOCK_ZERO
;
4067 } else if (bs
->backing_hd
) {
4068 BlockDriverState
*bs2
= bs
->backing_hd
;
4069 int64_t nb_sectors2
= bdrv_nb_sectors(bs2
);
4070 if (nb_sectors2
>= 0 && sector_num
>= nb_sectors2
) {
4071 ret
|= BDRV_BLOCK_ZERO
;
4077 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
4078 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
4079 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4082 /* Ignore errors. This is just providing extra information, it
4083 * is useful but not necessary.
4085 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
4092 /* Coroutine wrapper for bdrv_get_block_status() */
4093 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
4095 BdrvCoGetBlockStatusData
*data
= opaque
;
4096 BlockDriverState
*bs
= data
->bs
;
4098 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
4104 * Synchronous wrapper around bdrv_co_get_block_status().
4106 * See bdrv_co_get_block_status() for details.
4108 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
4109 int nb_sectors
, int *pnum
)
4112 BdrvCoGetBlockStatusData data
= {
4114 .sector_num
= sector_num
,
4115 .nb_sectors
= nb_sectors
,
4120 if (qemu_in_coroutine()) {
4121 /* Fast-path if already in coroutine context */
4122 bdrv_get_block_status_co_entry(&data
);
4124 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4126 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
4127 qemu_coroutine_enter(co
, &data
);
4128 while (!data
.done
) {
4129 aio_poll(aio_context
, true);
4135 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
4136 int nb_sectors
, int *pnum
)
4138 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4142 return !!(ret
& BDRV_BLOCK_ALLOCATED
);
4146 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4148 * Return true if the given sector is allocated in any image between
4149 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4150 * sector is allocated in any image of the chain. Return false otherwise.
4152 * 'pnum' is set to the number of sectors (including and immediately following
4153 * the specified sector) that are known to be in the same
4154 * allocated/unallocated state.
4157 int bdrv_is_allocated_above(BlockDriverState
*top
,
4158 BlockDriverState
*base
,
4160 int nb_sectors
, int *pnum
)
4162 BlockDriverState
*intermediate
;
4163 int ret
, n
= nb_sectors
;
4166 while (intermediate
&& intermediate
!= base
) {
4168 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
4178 * [sector_num, nb_sectors] is unallocated on top but intermediate
4181 * [sector_num+x, nr_sectors] allocated.
4183 if (n
> pnum_inter
&&
4184 (intermediate
== top
||
4185 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
4189 intermediate
= intermediate
->backing_hd
;
4196 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
4198 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
4199 return bs
->backing_file
;
4200 else if (bs
->encrypted
)
4201 return bs
->filename
;
4206 void bdrv_get_backing_filename(BlockDriverState
*bs
,
4207 char *filename
, int filename_size
)
4209 pstrcpy(filename
, filename_size
, bs
->backing_file
);
4212 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
4213 const uint8_t *buf
, int nb_sectors
)
4215 BlockDriver
*drv
= bs
->drv
;
4218 if (!drv
->bdrv_write_compressed
)
4220 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
4223 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
4225 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
4228 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4230 BlockDriver
*drv
= bs
->drv
;
4233 if (!drv
->bdrv_get_info
)
4235 memset(bdi
, 0, sizeof(*bdi
));
4236 return drv
->bdrv_get_info(bs
, bdi
);
4239 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
4241 BlockDriver
*drv
= bs
->drv
;
4242 if (drv
&& drv
->bdrv_get_specific_info
) {
4243 return drv
->bdrv_get_specific_info(bs
);
4248 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4249 int64_t pos
, int size
)
4252 struct iovec iov
= {
4253 .iov_base
= (void *) buf
,
4257 qemu_iovec_init_external(&qiov
, &iov
, 1);
4258 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4261 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4263 BlockDriver
*drv
= bs
->drv
;
4267 } else if (drv
->bdrv_save_vmstate
) {
4268 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4269 } else if (bs
->file
) {
4270 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4276 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4277 int64_t pos
, int size
)
4279 BlockDriver
*drv
= bs
->drv
;
4282 if (drv
->bdrv_load_vmstate
)
4283 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4285 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4289 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4291 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4295 bs
->drv
->bdrv_debug_event(bs
, event
);
4298 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4301 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4305 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4306 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4312 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4314 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4318 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4319 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4325 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4327 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
4331 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4332 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4338 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4340 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4344 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4345 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4351 int bdrv_is_snapshot(BlockDriverState
*bs
)
4353 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4356 /* backing_file can either be relative, or absolute, or a protocol. If it is
4357 * relative, it must be relative to the chain. So, passing in bs->filename
4358 * from a BDS as backing_file should not be done, as that may be relative to
4359 * the CWD rather than the chain. */
4360 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4361 const char *backing_file
)
4363 char *filename_full
= NULL
;
4364 char *backing_file_full
= NULL
;
4365 char *filename_tmp
= NULL
;
4366 int is_protocol
= 0;
4367 BlockDriverState
*curr_bs
= NULL
;
4368 BlockDriverState
*retval
= NULL
;
4370 if (!bs
|| !bs
->drv
|| !backing_file
) {
4374 filename_full
= g_malloc(PATH_MAX
);
4375 backing_file_full
= g_malloc(PATH_MAX
);
4376 filename_tmp
= g_malloc(PATH_MAX
);
4378 is_protocol
= path_has_protocol(backing_file
);
4380 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4382 /* If either of the filename paths is actually a protocol, then
4383 * compare unmodified paths; otherwise make paths relative */
4384 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4385 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4386 retval
= curr_bs
->backing_hd
;
4390 /* If not an absolute filename path, make it relative to the current
4391 * image's filename path */
4392 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4395 /* We are going to compare absolute pathnames */
4396 if (!realpath(filename_tmp
, filename_full
)) {
4400 /* We need to make sure the backing filename we are comparing against
4401 * is relative to the current image filename (or absolute) */
4402 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4403 curr_bs
->backing_file
);
4405 if (!realpath(filename_tmp
, backing_file_full
)) {
4409 if (strcmp(backing_file_full
, filename_full
) == 0) {
4410 retval
= curr_bs
->backing_hd
;
4416 g_free(filename_full
);
4417 g_free(backing_file_full
);
4418 g_free(filename_tmp
);
4422 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4428 if (!bs
->backing_hd
) {
4432 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4435 /**************************************************************/
4438 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4439 QEMUIOVector
*qiov
, int nb_sectors
,
4440 BlockDriverCompletionFunc
*cb
, void *opaque
)
4442 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4444 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4448 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4449 QEMUIOVector
*qiov
, int nb_sectors
,
4450 BlockDriverCompletionFunc
*cb
, void *opaque
)
4452 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4454 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4458 BlockDriverAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4459 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4460 BlockDriverCompletionFunc
*cb
, void *opaque
)
4462 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4464 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4465 BDRV_REQ_ZERO_WRITE
| flags
,
4470 typedef struct MultiwriteCB
{
4475 BlockDriverCompletionFunc
*cb
;
4477 QEMUIOVector
*free_qiov
;
4481 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4485 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4486 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4487 if (mcb
->callbacks
[i
].free_qiov
) {
4488 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4490 g_free(mcb
->callbacks
[i
].free_qiov
);
4494 static void multiwrite_cb(void *opaque
, int ret
)
4496 MultiwriteCB
*mcb
= opaque
;
4498 trace_multiwrite_cb(mcb
, ret
);
4500 if (ret
< 0 && !mcb
->error
) {
4504 mcb
->num_requests
--;
4505 if (mcb
->num_requests
== 0) {
4506 multiwrite_user_cb(mcb
);
4511 static int multiwrite_req_compare(const void *a
, const void *b
)
4513 const BlockRequest
*req1
= a
, *req2
= b
;
4516 * Note that we can't simply subtract req2->sector from req1->sector
4517 * here as that could overflow the return value.
4519 if (req1
->sector
> req2
->sector
) {
4521 } else if (req1
->sector
< req2
->sector
) {
4529 * Takes a bunch of requests and tries to merge them. Returns the number of
4530 * requests that remain after merging.
4532 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4533 int num_reqs
, MultiwriteCB
*mcb
)
4537 // Sort requests by start sector
4538 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4540 // Check if adjacent requests touch the same clusters. If so, combine them,
4541 // filling up gaps with zero sectors.
4543 for (i
= 1; i
< num_reqs
; i
++) {
4545 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4547 // Handle exactly sequential writes and overlapping writes.
4548 if (reqs
[i
].sector
<= oldreq_last
) {
4552 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4558 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4559 qemu_iovec_init(qiov
,
4560 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4562 // Add the first request to the merged one. If the requests are
4563 // overlapping, drop the last sectors of the first request.
4564 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4565 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4567 // We should need to add any zeros between the two requests
4568 assert (reqs
[i
].sector
<= oldreq_last
);
4570 // Add the second request
4571 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4573 // Add tail of first request, if necessary
4574 if (qiov
->size
< reqs
[outidx
].qiov
->size
) {
4575 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, qiov
->size
,
4576 reqs
[outidx
].qiov
->size
- qiov
->size
);
4579 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4580 reqs
[outidx
].qiov
= qiov
;
4582 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4585 reqs
[outidx
].sector
= reqs
[i
].sector
;
4586 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4587 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4595 * Submit multiple AIO write requests at once.
4597 * On success, the function returns 0 and all requests in the reqs array have
4598 * been submitted. In error case this function returns -1, and any of the
4599 * requests may or may not be submitted yet. In particular, this means that the
4600 * callback will be called for some of the requests, for others it won't. The
4601 * caller must check the error field of the BlockRequest to wait for the right
4602 * callbacks (if error != 0, no callback will be called).
4604 * The implementation may modify the contents of the reqs array, e.g. to merge
4605 * requests. However, the fields opaque and error are left unmodified as they
4606 * are used to signal failure for a single request to the caller.
4608 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4613 /* don't submit writes if we don't have a medium */
4614 if (bs
->drv
== NULL
) {
4615 for (i
= 0; i
< num_reqs
; i
++) {
4616 reqs
[i
].error
= -ENOMEDIUM
;
4621 if (num_reqs
== 0) {
4625 // Create MultiwriteCB structure
4626 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4627 mcb
->num_requests
= 0;
4628 mcb
->num_callbacks
= num_reqs
;
4630 for (i
= 0; i
< num_reqs
; i
++) {
4631 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4632 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4635 // Check for mergable requests
4636 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4638 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4640 /* Run the aio requests. */
4641 mcb
->num_requests
= num_reqs
;
4642 for (i
= 0; i
< num_reqs
; i
++) {
4643 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4644 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4652 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
4655 bdrv_aio_cancel_async(acb
);
4656 while (acb
->refcnt
> 1) {
4657 if (acb
->aiocb_info
->get_aio_context
) {
4658 aio_poll(acb
->aiocb_info
->get_aio_context(acb
), true);
4659 } else if (acb
->bs
) {
4660 aio_poll(bdrv_get_aio_context(acb
->bs
), true);
4665 qemu_aio_unref(acb
);
4668 /* Async version of aio cancel. The caller is not blocked if the acb implements
4669 * cancel_async, otherwise we do nothing and let the request normally complete.
4670 * In either case the completion callback must be called. */
4671 void bdrv_aio_cancel_async(BlockDriverAIOCB
*acb
)
4673 if (acb
->aiocb_info
->cancel_async
) {
4674 acb
->aiocb_info
->cancel_async(acb
);
4678 /**************************************************************/
4679 /* async block device emulation */
4681 typedef struct BlockDriverAIOCBSync
{
4682 BlockDriverAIOCB common
;
4685 /* vector translation state */
4689 } BlockDriverAIOCBSync
;
4691 static const AIOCBInfo bdrv_em_aiocb_info
= {
4692 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
4695 static void bdrv_aio_bh_cb(void *opaque
)
4697 BlockDriverAIOCBSync
*acb
= opaque
;
4699 if (!acb
->is_write
&& acb
->ret
>= 0) {
4700 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4702 qemu_vfree(acb
->bounce
);
4703 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4704 qemu_bh_delete(acb
->bh
);
4706 qemu_aio_unref(acb
);
4709 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4713 BlockDriverCompletionFunc
*cb
,
4718 BlockDriverAIOCBSync
*acb
;
4720 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4721 acb
->is_write
= is_write
;
4723 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
4724 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_aio_bh_cb
, acb
);
4726 if (acb
->bounce
== NULL
) {
4728 } else if (is_write
) {
4729 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4730 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4732 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4735 qemu_bh_schedule(acb
->bh
);
4737 return &acb
->common
;
4740 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4741 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4742 BlockDriverCompletionFunc
*cb
, void *opaque
)
4744 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4747 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4748 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4749 BlockDriverCompletionFunc
*cb
, void *opaque
)
4751 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4755 typedef struct BlockDriverAIOCBCoroutine
{
4756 BlockDriverAIOCB common
;
4761 } BlockDriverAIOCBCoroutine
;
4763 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4764 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
4767 static void bdrv_co_em_bh(void *opaque
)
4769 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4771 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4773 qemu_bh_delete(acb
->bh
);
4774 qemu_aio_unref(acb
);
4777 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4778 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4780 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4781 BlockDriverState
*bs
= acb
->common
.bs
;
4783 if (!acb
->is_write
) {
4784 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4785 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4787 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4788 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4791 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4792 qemu_bh_schedule(acb
->bh
);
4795 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4799 BdrvRequestFlags flags
,
4800 BlockDriverCompletionFunc
*cb
,
4805 BlockDriverAIOCBCoroutine
*acb
;
4807 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4808 acb
->req
.sector
= sector_num
;
4809 acb
->req
.nb_sectors
= nb_sectors
;
4810 acb
->req
.qiov
= qiov
;
4811 acb
->req
.flags
= flags
;
4812 acb
->is_write
= is_write
;
4814 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4815 qemu_coroutine_enter(co
, acb
);
4817 return &acb
->common
;
4820 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4822 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4823 BlockDriverState
*bs
= acb
->common
.bs
;
4825 acb
->req
.error
= bdrv_co_flush(bs
);
4826 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4827 qemu_bh_schedule(acb
->bh
);
4830 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4831 BlockDriverCompletionFunc
*cb
, void *opaque
)
4833 trace_bdrv_aio_flush(bs
, opaque
);
4836 BlockDriverAIOCBCoroutine
*acb
;
4838 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4840 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4841 qemu_coroutine_enter(co
, acb
);
4843 return &acb
->common
;
4846 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4848 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4849 BlockDriverState
*bs
= acb
->common
.bs
;
4851 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4852 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4853 qemu_bh_schedule(acb
->bh
);
4856 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4857 int64_t sector_num
, int nb_sectors
,
4858 BlockDriverCompletionFunc
*cb
, void *opaque
)
4861 BlockDriverAIOCBCoroutine
*acb
;
4863 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4865 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4866 acb
->req
.sector
= sector_num
;
4867 acb
->req
.nb_sectors
= nb_sectors
;
4868 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4869 qemu_coroutine_enter(co
, acb
);
4871 return &acb
->common
;
4874 void bdrv_init(void)
4876 module_call_init(MODULE_INIT_BLOCK
);
4879 void bdrv_init_with_whitelist(void)
4881 use_bdrv_whitelist
= 1;
4885 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4886 BlockDriverCompletionFunc
*cb
, void *opaque
)
4888 BlockDriverAIOCB
*acb
;
4890 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4891 acb
->aiocb_info
= aiocb_info
;
4894 acb
->opaque
= opaque
;
4899 void qemu_aio_ref(void *p
)
4901 BlockDriverAIOCB
*acb
= p
;
4905 void qemu_aio_unref(void *p
)
4907 BlockDriverAIOCB
*acb
= p
;
4908 assert(acb
->refcnt
> 0);
4909 if (--acb
->refcnt
== 0) {
4910 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4914 /**************************************************************/
4915 /* Coroutine block device emulation */
4917 typedef struct CoroutineIOCompletion
{
4918 Coroutine
*coroutine
;
4920 } CoroutineIOCompletion
;
4922 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4924 CoroutineIOCompletion
*co
= opaque
;
4927 qemu_coroutine_enter(co
->coroutine
, NULL
);
4930 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4931 int nb_sectors
, QEMUIOVector
*iov
,
4934 CoroutineIOCompletion co
= {
4935 .coroutine
= qemu_coroutine_self(),
4937 BlockDriverAIOCB
*acb
;
4940 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4941 bdrv_co_io_em_complete
, &co
);
4943 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4944 bdrv_co_io_em_complete
, &co
);
4947 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4951 qemu_coroutine_yield();
4956 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4957 int64_t sector_num
, int nb_sectors
,
4960 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4963 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4964 int64_t sector_num
, int nb_sectors
,
4967 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4970 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4972 RwCo
*rwco
= opaque
;
4974 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4977 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4981 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4985 /* Write back cached data to the OS even with cache=unsafe */
4986 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4987 if (bs
->drv
->bdrv_co_flush_to_os
) {
4988 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4994 /* But don't actually force it to the disk with cache=unsafe */
4995 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4999 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
5000 if (bs
->drv
->bdrv_co_flush_to_disk
) {
5001 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
5002 } else if (bs
->drv
->bdrv_aio_flush
) {
5003 BlockDriverAIOCB
*acb
;
5004 CoroutineIOCompletion co
= {
5005 .coroutine
= qemu_coroutine_self(),
5008 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
5012 qemu_coroutine_yield();
5017 * Some block drivers always operate in either writethrough or unsafe
5018 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
5019 * know how the server works (because the behaviour is hardcoded or
5020 * depends on server-side configuration), so we can't ensure that
5021 * everything is safe on disk. Returning an error doesn't work because
5022 * that would break guests even if the server operates in writethrough
5025 * Let's hope the user knows what he's doing.
5033 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
5034 * in the case of cache=unsafe, so there are no useless flushes.
5037 return bdrv_co_flush(bs
->file
);
5040 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
5042 Error
*local_err
= NULL
;
5049 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
5052 bs
->open_flags
&= ~BDRV_O_INCOMING
;
5054 if (bs
->drv
->bdrv_invalidate_cache
) {
5055 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
5056 } else if (bs
->file
) {
5057 bdrv_invalidate_cache(bs
->file
, &local_err
);
5060 error_propagate(errp
, local_err
);
5064 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
5066 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
5071 void bdrv_invalidate_cache_all(Error
**errp
)
5073 BlockDriverState
*bs
;
5074 Error
*local_err
= NULL
;
5076 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5077 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5079 aio_context_acquire(aio_context
);
5080 bdrv_invalidate_cache(bs
, &local_err
);
5081 aio_context_release(aio_context
);
5083 error_propagate(errp
, local_err
);
5089 int bdrv_flush(BlockDriverState
*bs
)
5097 if (qemu_in_coroutine()) {
5098 /* Fast-path if already in coroutine context */
5099 bdrv_flush_co_entry(&rwco
);
5101 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5103 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
5104 qemu_coroutine_enter(co
, &rwco
);
5105 while (rwco
.ret
== NOT_DONE
) {
5106 aio_poll(aio_context
, true);
5113 typedef struct DiscardCo
{
5114 BlockDriverState
*bs
;
5119 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
5121 DiscardCo
*rwco
= opaque
;
5123 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
5126 /* if no limit is specified in the BlockLimits use a default
5127 * of 32768 512-byte sectors (16 MiB) per request.
5129 #define MAX_DISCARD_DEFAULT 32768
5131 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
5138 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
5140 } else if (bs
->read_only
) {
5144 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
5146 /* Do nothing if disabled. */
5147 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
5151 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
5155 max_discard
= bs
->bl
.max_discard
? bs
->bl
.max_discard
: MAX_DISCARD_DEFAULT
;
5156 while (nb_sectors
> 0) {
5158 int num
= nb_sectors
;
5161 if (bs
->bl
.discard_alignment
&&
5162 num
>= bs
->bl
.discard_alignment
&&
5163 sector_num
% bs
->bl
.discard_alignment
) {
5164 if (num
> bs
->bl
.discard_alignment
) {
5165 num
= bs
->bl
.discard_alignment
;
5167 num
-= sector_num
% bs
->bl
.discard_alignment
;
5170 /* limit request size */
5171 if (num
> max_discard
) {
5175 if (bs
->drv
->bdrv_co_discard
) {
5176 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
5178 BlockDriverAIOCB
*acb
;
5179 CoroutineIOCompletion co
= {
5180 .coroutine
= qemu_coroutine_self(),
5183 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
5184 bdrv_co_io_em_complete
, &co
);
5188 qemu_coroutine_yield();
5192 if (ret
&& ret
!= -ENOTSUP
) {
5202 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
5207 .sector_num
= sector_num
,
5208 .nb_sectors
= nb_sectors
,
5212 if (qemu_in_coroutine()) {
5213 /* Fast-path if already in coroutine context */
5214 bdrv_discard_co_entry(&rwco
);
5216 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5218 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
5219 qemu_coroutine_enter(co
, &rwco
);
5220 while (rwco
.ret
== NOT_DONE
) {
5221 aio_poll(aio_context
, true);
5228 /**************************************************************/
5229 /* removable device support */
5232 * Return TRUE if the media is present
5234 int bdrv_is_inserted(BlockDriverState
*bs
)
5236 BlockDriver
*drv
= bs
->drv
;
5240 if (!drv
->bdrv_is_inserted
)
5242 return drv
->bdrv_is_inserted(bs
);
5246 * Return whether the media changed since the last call to this
5247 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5249 int bdrv_media_changed(BlockDriverState
*bs
)
5251 BlockDriver
*drv
= bs
->drv
;
5253 if (drv
&& drv
->bdrv_media_changed
) {
5254 return drv
->bdrv_media_changed(bs
);
5260 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5262 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
5264 BlockDriver
*drv
= bs
->drv
;
5266 if (drv
&& drv
->bdrv_eject
) {
5267 drv
->bdrv_eject(bs
, eject_flag
);
5270 if (bs
->device_name
[0] != '\0') {
5271 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
5272 eject_flag
, &error_abort
);
5277 * Lock or unlock the media (if it is locked, the user won't be able
5278 * to eject it manually).
5280 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5282 BlockDriver
*drv
= bs
->drv
;
5284 trace_bdrv_lock_medium(bs
, locked
);
5286 if (drv
&& drv
->bdrv_lock_medium
) {
5287 drv
->bdrv_lock_medium(bs
, locked
);
5291 /* needed for generic scsi interface */
5293 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5295 BlockDriver
*drv
= bs
->drv
;
5297 if (drv
&& drv
->bdrv_ioctl
)
5298 return drv
->bdrv_ioctl(bs
, req
, buf
);
5302 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5303 unsigned long int req
, void *buf
,
5304 BlockDriverCompletionFunc
*cb
, void *opaque
)
5306 BlockDriver
*drv
= bs
->drv
;
5308 if (drv
&& drv
->bdrv_aio_ioctl
)
5309 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5313 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5315 bs
->guest_block_size
= align
;
5318 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5320 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5323 void *qemu_try_blockalign(BlockDriverState
*bs
, size_t size
)
5325 size_t align
= bdrv_opt_mem_align(bs
);
5327 /* Ensure that NULL is never returned on success */
5333 return qemu_try_memalign(align
, size
);
5337 * Check if all memory in this vector is sector aligned.
5339 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5342 size_t alignment
= bdrv_opt_mem_align(bs
);
5344 for (i
= 0; i
< qiov
->niov
; i
++) {
5345 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5348 if (qiov
->iov
[i
].iov_len
% alignment
) {
5356 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
,
5359 int64_t bitmap_size
;
5360 BdrvDirtyBitmap
*bitmap
;
5362 assert((granularity
& (granularity
- 1)) == 0);
5364 granularity
>>= BDRV_SECTOR_BITS
;
5365 assert(granularity
);
5366 bitmap_size
= bdrv_nb_sectors(bs
);
5367 if (bitmap_size
< 0) {
5368 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
5369 errno
= -bitmap_size
;
5372 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
5373 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
5374 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5378 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5380 BdrvDirtyBitmap
*bm
, *next
;
5381 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5383 QLIST_REMOVE(bitmap
, list
);
5384 hbitmap_free(bitmap
->bitmap
);
5391 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5393 BdrvDirtyBitmap
*bm
;
5394 BlockDirtyInfoList
*list
= NULL
;
5395 BlockDirtyInfoList
**plist
= &list
;
5397 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5398 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
5399 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
5400 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5402 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5403 entry
->value
= info
;
5405 plist
= &entry
->next
;
5411 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5414 return hbitmap_get(bitmap
->bitmap
, sector
);
5420 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5421 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5423 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5426 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5429 BdrvDirtyBitmap
*bitmap
;
5430 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5431 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5435 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
, int nr_sectors
)
5437 BdrvDirtyBitmap
*bitmap
;
5438 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5439 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5443 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5445 return hbitmap_count(bitmap
->bitmap
);
5448 /* Get a reference to bs */
5449 void bdrv_ref(BlockDriverState
*bs
)
5454 /* Release a previously grabbed reference to bs.
5455 * If after releasing, reference count is zero, the BlockDriverState is
5457 void bdrv_unref(BlockDriverState
*bs
)
5462 assert(bs
->refcnt
> 0);
5463 if (--bs
->refcnt
== 0) {
5468 struct BdrvOpBlocker
{
5470 QLIST_ENTRY(BdrvOpBlocker
) list
;
5473 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
5475 BdrvOpBlocker
*blocker
;
5476 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5477 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
5478 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
5480 error_setg(errp
, "Device '%s' is busy: %s",
5481 bs
->device_name
, error_get_pretty(blocker
->reason
));
5488 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5490 BdrvOpBlocker
*blocker
;
5491 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5493 blocker
= g_new0(BdrvOpBlocker
, 1);
5494 blocker
->reason
= reason
;
5495 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
5498 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5500 BdrvOpBlocker
*blocker
, *next
;
5501 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5502 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
5503 if (blocker
->reason
== reason
) {
5504 QLIST_REMOVE(blocker
, list
);
5510 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
5513 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5514 bdrv_op_block(bs
, i
, reason
);
5518 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
5521 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5522 bdrv_op_unblock(bs
, i
, reason
);
5526 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
5530 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5531 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
5538 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5540 bs
->iostatus_enabled
= true;
5541 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5544 /* The I/O status is only enabled if the drive explicitly
5545 * enables it _and_ the VM is configured to stop on errors */
5546 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5548 return (bs
->iostatus_enabled
&&
5549 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5550 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5551 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5554 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5556 bs
->iostatus_enabled
= false;
5559 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5561 if (bdrv_iostatus_is_enabled(bs
)) {
5562 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5564 block_job_iostatus_reset(bs
->job
);
5569 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5571 assert(bdrv_iostatus_is_enabled(bs
));
5572 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5573 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5574 BLOCK_DEVICE_IO_STATUS_FAILED
;
5578 void bdrv_img_create(const char *filename
, const char *fmt
,
5579 const char *base_filename
, const char *base_fmt
,
5580 char *options
, uint64_t img_size
, int flags
,
5581 Error
**errp
, bool quiet
)
5583 QemuOptsList
*create_opts
= NULL
;
5584 QemuOpts
*opts
= NULL
;
5585 const char *backing_fmt
, *backing_file
;
5587 BlockDriver
*drv
, *proto_drv
;
5588 BlockDriver
*backing_drv
= NULL
;
5589 Error
*local_err
= NULL
;
5592 /* Find driver and parse its options */
5593 drv
= bdrv_find_format(fmt
);
5595 error_setg(errp
, "Unknown file format '%s'", fmt
);
5599 proto_drv
= bdrv_find_protocol(filename
, true);
5601 error_setg(errp
, "Unknown protocol '%s'", filename
);
5605 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5606 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5608 /* Create parameter list with default values */
5609 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5610 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
);
5612 /* Parse -o options */
5614 if (qemu_opts_do_parse(opts
, options
, NULL
) != 0) {
5615 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
5620 if (base_filename
) {
5621 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
5622 error_setg(errp
, "Backing file not supported for file format '%s'",
5629 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
5630 error_setg(errp
, "Backing file format not supported for file "
5631 "format '%s'", fmt
);
5636 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5638 if (!strcmp(filename
, backing_file
)) {
5639 error_setg(errp
, "Error: Trying to create an image with the "
5640 "same filename as the backing file");
5645 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5647 backing_drv
= bdrv_find_format(backing_fmt
);
5649 error_setg(errp
, "Unknown backing file format '%s'",
5655 // The size for the image must always be specified, with one exception:
5656 // If we are using a backing file, we can obtain the size from there
5657 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5660 BlockDriverState
*bs
;
5664 /* backing files always opened read-only */
5666 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5669 ret
= bdrv_open(&bs
, backing_file
, NULL
, NULL
, back_flags
,
5670 backing_drv
, &local_err
);
5672 error_setg_errno(errp
, -ret
, "Could not open '%s': %s",
5674 error_get_pretty(local_err
));
5675 error_free(local_err
);
5679 size
= bdrv_getlength(bs
);
5681 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
5687 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
);
5691 error_setg(errp
, "Image creation needs a size parameter");
5697 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
5698 qemu_opts_print(opts
);
5702 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
5704 if (ret
== -EFBIG
) {
5705 /* This is generally a better message than whatever the driver would
5706 * deliver (especially because of the cluster_size_hint), since that
5707 * is most probably not much different from "image too large". */
5708 const char *cluster_size_hint
= "";
5709 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
5710 cluster_size_hint
= " (try using a larger cluster size)";
5712 error_setg(errp
, "The image size is too large for file format '%s'"
5713 "%s", fmt
, cluster_size_hint
);
5714 error_free(local_err
);
5719 qemu_opts_del(opts
);
5720 qemu_opts_free(create_opts
);
5722 error_propagate(errp
, local_err
);
5726 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5728 return bs
->aio_context
;
5731 void bdrv_detach_aio_context(BlockDriverState
*bs
)
5733 BdrvAioNotifier
*baf
;
5739 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
5740 baf
->detach_aio_context(baf
->opaque
);
5743 if (bs
->io_limits_enabled
) {
5744 throttle_detach_aio_context(&bs
->throttle_state
);
5746 if (bs
->drv
->bdrv_detach_aio_context
) {
5747 bs
->drv
->bdrv_detach_aio_context(bs
);
5750 bdrv_detach_aio_context(bs
->file
);
5752 if (bs
->backing_hd
) {
5753 bdrv_detach_aio_context(bs
->backing_hd
);
5756 bs
->aio_context
= NULL
;
5759 void bdrv_attach_aio_context(BlockDriverState
*bs
,
5760 AioContext
*new_context
)
5762 BdrvAioNotifier
*ban
;
5768 bs
->aio_context
= new_context
;
5770 if (bs
->backing_hd
) {
5771 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
5774 bdrv_attach_aio_context(bs
->file
, new_context
);
5776 if (bs
->drv
->bdrv_attach_aio_context
) {
5777 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
5779 if (bs
->io_limits_enabled
) {
5780 throttle_attach_aio_context(&bs
->throttle_state
, new_context
);
5783 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
5784 ban
->attached_aio_context(new_context
, ban
->opaque
);
5788 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
5790 bdrv_drain_all(); /* ensure there are no in-flight requests */
5792 bdrv_detach_aio_context(bs
);
5794 /* This function executes in the old AioContext so acquire the new one in
5795 * case it runs in a different thread.
5797 aio_context_acquire(new_context
);
5798 bdrv_attach_aio_context(bs
, new_context
);
5799 aio_context_release(new_context
);
5802 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
5803 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
5804 void (*detach_aio_context
)(void *opaque
), void *opaque
)
5806 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
5807 *ban
= (BdrvAioNotifier
){
5808 .attached_aio_context
= attached_aio_context
,
5809 .detach_aio_context
= detach_aio_context
,
5813 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
5816 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
5817 void (*attached_aio_context
)(AioContext
*,
5819 void (*detach_aio_context
)(void *),
5822 BdrvAioNotifier
*ban
, *ban_next
;
5824 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
5825 if (ban
->attached_aio_context
== attached_aio_context
&&
5826 ban
->detach_aio_context
== detach_aio_context
&&
5827 ban
->opaque
== opaque
)
5829 QLIST_REMOVE(ban
, list
);
5839 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
5840 NotifierWithReturn
*notifier
)
5842 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
5845 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
)
5847 if (!bs
->drv
->bdrv_amend_options
) {
5850 return bs
->drv
->bdrv_amend_options(bs
, opts
);
5853 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5854 * of block filter and by bdrv_is_first_non_filter.
5855 * It is used to test if the given bs is the candidate or recurse more in the
5858 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
5859 BlockDriverState
*candidate
)
5861 /* return false if basic checks fails */
5862 if (!bs
|| !bs
->drv
) {
5866 /* the code reached a non block filter driver -> check if the bs is
5867 * the same as the candidate. It's the recursion termination condition.
5869 if (!bs
->drv
->is_filter
) {
5870 return bs
== candidate
;
5872 /* Down this path the driver is a block filter driver */
5874 /* If the block filter recursion method is defined use it to recurse down
5877 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
5878 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
5881 /* the driver is a block filter but don't allow to recurse -> return false
5886 /* This function checks if the candidate is the first non filter bs down it's
5887 * bs chain. Since we don't have pointers to parents it explore all bs chains
5888 * from the top. Some filters can choose not to pass down the recursion.
5890 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
5892 BlockDriverState
*bs
;
5894 /* walk down the bs forest recursively */
5895 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5898 /* try to recurse in this top level bs */
5899 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
5901 /* candidate is the first non filter */
5910 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
5912 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
5913 if (!to_replace_bs
) {
5914 error_setg(errp
, "Node name '%s' not found", node_name
);
5918 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
5922 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5923 * most non filter in order to prevent data corruption.
5924 * Another benefit is that this tests exclude backing files which are
5925 * blocked by the backing blockers.
5927 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
5928 error_setg(errp
, "Only top most non filter can be replaced");
5932 return to_replace_bs
;
5935 void bdrv_io_plug(BlockDriverState
*bs
)
5937 BlockDriver
*drv
= bs
->drv
;
5938 if (drv
&& drv
->bdrv_io_plug
) {
5939 drv
->bdrv_io_plug(bs
);
5940 } else if (bs
->file
) {
5941 bdrv_io_plug(bs
->file
);
5945 void bdrv_io_unplug(BlockDriverState
*bs
)
5947 BlockDriver
*drv
= bs
->drv
;
5948 if (drv
&& drv
->bdrv_io_unplug
) {
5949 drv
->bdrv_io_unplug(bs
);
5950 } else if (bs
->file
) {
5951 bdrv_io_unplug(bs
->file
);
5955 void bdrv_flush_io_queue(BlockDriverState
*bs
)
5957 BlockDriver
*drv
= bs
->drv
;
5958 if (drv
&& drv
->bdrv_flush_io_queue
) {
5959 drv
->bdrv_flush_io_queue(bs
);
5960 } else if (bs
->file
) {
5961 bdrv_flush_io_queue(bs
->file
);
5965 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
5967 const QDictEntry
*entry
;
5968 bool found_any
= false;
5970 for (entry
= qdict_first(bs
->options
); entry
;
5971 entry
= qdict_next(bs
->options
, entry
))
5973 /* Only take options for this level and exclude all non-driver-specific
5975 if (!strchr(qdict_entry_key(entry
), '.') &&
5976 strcmp(qdict_entry_key(entry
), "node-name"))
5978 qobject_incref(qdict_entry_value(entry
));
5979 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
5987 /* Updates the following BDS fields:
5988 * - exact_filename: A filename which may be used for opening a block device
5989 * which (mostly) equals the given BDS (even without any
5990 * other options; so reading and writing must return the same
5991 * results, but caching etc. may be different)
5992 * - full_open_options: Options which, when given when opening a block device
5993 * (without a filename), result in a BDS (mostly)
5994 * equalling the given one
5995 * - filename: If exact_filename is set, it is copied here. Otherwise,
5996 * full_open_options is converted to a JSON object, prefixed with
5997 * "json:" (for use through the JSON pseudo protocol) and put here.
5999 void bdrv_refresh_filename(BlockDriverState
*bs
)
6001 BlockDriver
*drv
= bs
->drv
;
6008 /* This BDS's file name will most probably depend on its file's name, so
6009 * refresh that first */
6011 bdrv_refresh_filename(bs
->file
);
6014 if (drv
->bdrv_refresh_filename
) {
6015 /* Obsolete information is of no use here, so drop the old file name
6016 * information before refreshing it */
6017 bs
->exact_filename
[0] = '\0';
6018 if (bs
->full_open_options
) {
6019 QDECREF(bs
->full_open_options
);
6020 bs
->full_open_options
= NULL
;
6023 drv
->bdrv_refresh_filename(bs
);
6024 } else if (bs
->file
) {
6025 /* Try to reconstruct valid information from the underlying file */
6026 bool has_open_options
;
6028 bs
->exact_filename
[0] = '\0';
6029 if (bs
->full_open_options
) {
6030 QDECREF(bs
->full_open_options
);
6031 bs
->full_open_options
= NULL
;
6035 has_open_options
= append_open_options(opts
, bs
);
6037 /* If no specific options have been given for this BDS, the filename of
6038 * the underlying file should suffice for this one as well */
6039 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
6040 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
6042 /* Reconstructing the full options QDict is simple for most format block
6043 * drivers, as long as the full options are known for the underlying
6044 * file BDS. The full options QDict of that file BDS should somehow
6045 * contain a representation of the filename, therefore the following
6046 * suffices without querying the (exact_)filename of this BDS. */
6047 if (bs
->file
->full_open_options
) {
6048 qdict_put_obj(opts
, "driver",
6049 QOBJECT(qstring_from_str(drv
->format_name
)));
6050 QINCREF(bs
->file
->full_open_options
);
6051 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
6053 bs
->full_open_options
= opts
;
6057 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
6058 /* There is no underlying file BDS (at least referenced by BDS.file),
6059 * so the full options QDict should be equal to the options given
6060 * specifically for this block device when it was opened (plus the
6061 * driver specification).
6062 * Because those options don't change, there is no need to update
6063 * full_open_options when it's already set. */
6066 append_open_options(opts
, bs
);
6067 qdict_put_obj(opts
, "driver",
6068 QOBJECT(qstring_from_str(drv
->format_name
)));
6070 if (bs
->exact_filename
[0]) {
6071 /* This may not work for all block protocol drivers (some may
6072 * require this filename to be parsed), but we have to find some
6073 * default solution here, so just include it. If some block driver
6074 * does not support pure options without any filename at all or
6075 * needs some special format of the options QDict, it needs to
6076 * implement the driver-specific bdrv_refresh_filename() function.
6078 qdict_put_obj(opts
, "filename",
6079 QOBJECT(qstring_from_str(bs
->exact_filename
)));
6082 bs
->full_open_options
= opts
;
6085 if (bs
->exact_filename
[0]) {
6086 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
6087 } else if (bs
->full_open_options
) {
6088 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
6089 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
6090 qstring_get_str(json
));
6095 /* This accessor function purpose is to allow the device models to access the
6096 * BlockAcctStats structure embedded inside a BlockDriverState without being
6097 * aware of the BlockDriverState structure layout.
6098 * It will go away when the BlockAcctStats structure will be moved inside
6099 * the device models.
6101 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)