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 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
61 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
62 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
63 BlockDriverCompletionFunc
*cb
, void *opaque
);
64 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
65 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
66 BlockDriverCompletionFunc
*cb
, void *opaque
);
67 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
68 int64_t sector_num
, int nb_sectors
,
70 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
71 int64_t sector_num
, int nb_sectors
,
73 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
74 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
75 BdrvRequestFlags flags
);
76 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
77 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
78 BdrvRequestFlags flags
);
79 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
83 BdrvRequestFlags flags
,
84 BlockDriverCompletionFunc
*cb
,
87 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
88 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
89 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
91 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
92 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
94 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
97 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
98 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
100 /* If non-zero, use only whitelisted block drivers */
101 static int use_bdrv_whitelist
;
104 static int is_windows_drive_prefix(const char *filename
)
106 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
107 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
111 int is_windows_drive(const char *filename
)
113 if (is_windows_drive_prefix(filename
) &&
116 if (strstart(filename
, "\\\\.\\", NULL
) ||
117 strstart(filename
, "//./", NULL
))
123 /* throttling disk I/O limits */
124 void bdrv_set_io_limits(BlockDriverState
*bs
,
129 throttle_config(&bs
->throttle_state
, cfg
);
131 for (i
= 0; i
< 2; i
++) {
132 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
136 /* this function drain all the throttled IOs */
137 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
139 bool drained
= false;
140 bool enabled
= bs
->io_limits_enabled
;
143 bs
->io_limits_enabled
= false;
145 for (i
= 0; i
< 2; i
++) {
146 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
151 bs
->io_limits_enabled
= enabled
;
156 void bdrv_io_limits_disable(BlockDriverState
*bs
)
158 bs
->io_limits_enabled
= false;
160 bdrv_start_throttled_reqs(bs
);
162 throttle_destroy(&bs
->throttle_state
);
165 static void bdrv_throttle_read_timer_cb(void *opaque
)
167 BlockDriverState
*bs
= opaque
;
168 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
171 static void bdrv_throttle_write_timer_cb(void *opaque
)
173 BlockDriverState
*bs
= opaque
;
174 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
177 /* should be called before bdrv_set_io_limits if a limit is set */
178 void bdrv_io_limits_enable(BlockDriverState
*bs
)
180 assert(!bs
->io_limits_enabled
);
181 throttle_init(&bs
->throttle_state
,
182 bdrv_get_aio_context(bs
),
184 bdrv_throttle_read_timer_cb
,
185 bdrv_throttle_write_timer_cb
,
187 bs
->io_limits_enabled
= true;
190 /* This function makes an IO wait if needed
192 * @nb_sectors: the number of sectors of the IO
193 * @is_write: is the IO a write
195 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
199 /* does this io must wait */
200 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
202 /* if must wait or any request of this type throttled queue the IO */
204 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
205 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
208 /* the IO will be executed, do the accounting */
209 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
212 /* if the next request must wait -> do nothing */
213 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
217 /* else queue next request for execution */
218 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
221 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
223 if (!bs
|| !bs
->drv
) {
224 /* 4k should be on the safe side */
228 return bs
->bl
.opt_mem_alignment
;
231 /* check if the path starts with "<protocol>:" */
232 static int path_has_protocol(const char *path
)
237 if (is_windows_drive(path
) ||
238 is_windows_drive_prefix(path
)) {
241 p
= path
+ strcspn(path
, ":/\\");
243 p
= path
+ strcspn(path
, ":/");
249 int path_is_absolute(const char *path
)
252 /* specific case for names like: "\\.\d:" */
253 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
256 return (*path
== '/' || *path
== '\\');
258 return (*path
== '/');
262 /* if filename is absolute, just copy it to dest. Otherwise, build a
263 path to it by considering it is relative to base_path. URL are
265 void path_combine(char *dest
, int dest_size
,
266 const char *base_path
,
267 const char *filename
)
274 if (path_is_absolute(filename
)) {
275 pstrcpy(dest
, dest_size
, filename
);
277 p
= strchr(base_path
, ':');
282 p1
= strrchr(base_path
, '/');
286 p2
= strrchr(base_path
, '\\');
298 if (len
> dest_size
- 1)
300 memcpy(dest
, base_path
, len
);
302 pstrcat(dest
, dest_size
, filename
);
306 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
308 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
309 pstrcpy(dest
, sz
, bs
->backing_file
);
311 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
315 void bdrv_register(BlockDriver
*bdrv
)
317 /* Block drivers without coroutine functions need emulation */
318 if (!bdrv
->bdrv_co_readv
) {
319 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
320 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
323 * the block driver lacks aio we need to emulate that too.
325 if (!bdrv
->bdrv_aio_readv
) {
326 /* add AIO emulation layer */
327 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
328 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
332 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
335 /* create a new block device (by default it is empty) */
336 BlockDriverState
*bdrv_new(const char *device_name
, Error
**errp
)
338 BlockDriverState
*bs
;
341 if (bdrv_find(device_name
)) {
342 error_setg(errp
, "Device with id '%s' already exists",
346 if (bdrv_find_node(device_name
)) {
347 error_setg(errp
, "Device with node-name '%s' already exists",
352 bs
= g_malloc0(sizeof(BlockDriverState
));
353 QLIST_INIT(&bs
->dirty_bitmaps
);
354 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
355 if (device_name
[0] != '\0') {
356 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
358 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
359 QLIST_INIT(&bs
->op_blockers
[i
]);
361 bdrv_iostatus_disable(bs
);
362 notifier_list_init(&bs
->close_notifiers
);
363 notifier_with_return_list_init(&bs
->before_write_notifiers
);
364 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
365 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
367 bs
->aio_context
= qemu_get_aio_context();
372 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
374 notifier_list_add(&bs
->close_notifiers
, notify
);
377 BlockDriver
*bdrv_find_format(const char *format_name
)
380 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
381 if (!strcmp(drv1
->format_name
, format_name
)) {
388 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
390 static const char *whitelist_rw
[] = {
391 CONFIG_BDRV_RW_WHITELIST
393 static const char *whitelist_ro
[] = {
394 CONFIG_BDRV_RO_WHITELIST
398 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
399 return 1; /* no whitelist, anything goes */
402 for (p
= whitelist_rw
; *p
; p
++) {
403 if (!strcmp(drv
->format_name
, *p
)) {
408 for (p
= whitelist_ro
; *p
; p
++) {
409 if (!strcmp(drv
->format_name
, *p
)) {
417 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
420 BlockDriver
*drv
= bdrv_find_format(format_name
);
421 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
424 typedef struct CreateCo
{
432 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
434 Error
*local_err
= NULL
;
437 CreateCo
*cco
= opaque
;
440 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
442 error_propagate(&cco
->err
, local_err
);
447 int bdrv_create(BlockDriver
*drv
, const char* filename
,
448 QemuOpts
*opts
, Error
**errp
)
455 .filename
= g_strdup(filename
),
461 if (!drv
->bdrv_create
) {
462 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
467 if (qemu_in_coroutine()) {
468 /* Fast-path if already in coroutine context */
469 bdrv_create_co_entry(&cco
);
471 co
= qemu_coroutine_create(bdrv_create_co_entry
);
472 qemu_coroutine_enter(co
, &cco
);
473 while (cco
.ret
== NOT_DONE
) {
474 aio_poll(qemu_get_aio_context(), true);
481 error_propagate(errp
, cco
.err
);
483 error_setg_errno(errp
, -ret
, "Could not create image");
488 g_free(cco
.filename
);
492 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
495 Error
*local_err
= NULL
;
498 drv
= bdrv_find_protocol(filename
, true);
500 error_setg(errp
, "Could not find protocol for file '%s'", filename
);
504 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
506 error_propagate(errp
, local_err
);
511 int bdrv_refresh_limits(BlockDriverState
*bs
)
513 BlockDriver
*drv
= bs
->drv
;
515 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
521 /* Take some limits from the children as a default */
523 bdrv_refresh_limits(bs
->file
);
524 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
525 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
527 bs
->bl
.opt_mem_alignment
= 512;
530 if (bs
->backing_hd
) {
531 bdrv_refresh_limits(bs
->backing_hd
);
532 bs
->bl
.opt_transfer_length
=
533 MAX(bs
->bl
.opt_transfer_length
,
534 bs
->backing_hd
->bl
.opt_transfer_length
);
535 bs
->bl
.opt_mem_alignment
=
536 MAX(bs
->bl
.opt_mem_alignment
,
537 bs
->backing_hd
->bl
.opt_mem_alignment
);
540 /* Then let the driver override it */
541 if (drv
->bdrv_refresh_limits
) {
542 return drv
->bdrv_refresh_limits(bs
);
549 * Create a uniquely-named empty temporary file.
550 * Return 0 upon success, otherwise a negative errno value.
552 int get_tmp_filename(char *filename
, int size
)
555 char temp_dir
[MAX_PATH
];
556 /* GetTempFileName requires that its output buffer (4th param)
557 have length MAX_PATH or greater. */
558 assert(size
>= MAX_PATH
);
559 return (GetTempPath(MAX_PATH
, temp_dir
)
560 && GetTempFileName(temp_dir
, "qem", 0, filename
)
561 ? 0 : -GetLastError());
565 tmpdir
= getenv("TMPDIR");
569 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
572 fd
= mkstemp(filename
);
576 if (close(fd
) != 0) {
585 * Detect host devices. By convention, /dev/cdrom[N] is always
586 * recognized as a host CDROM.
588 static BlockDriver
*find_hdev_driver(const char *filename
)
590 int score_max
= 0, score
;
591 BlockDriver
*drv
= NULL
, *d
;
593 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
594 if (d
->bdrv_probe_device
) {
595 score
= d
->bdrv_probe_device(filename
);
596 if (score
> score_max
) {
606 BlockDriver
*bdrv_find_protocol(const char *filename
,
607 bool allow_protocol_prefix
)
614 /* TODO Drivers without bdrv_file_open must be specified explicitly */
617 * XXX(hch): we really should not let host device detection
618 * override an explicit protocol specification, but moving this
619 * later breaks access to device names with colons in them.
620 * Thanks to the brain-dead persistent naming schemes on udev-
621 * based Linux systems those actually are quite common.
623 drv1
= find_hdev_driver(filename
);
628 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
629 return bdrv_find_format("file");
632 p
= strchr(filename
, ':');
635 if (len
> sizeof(protocol
) - 1)
636 len
= sizeof(protocol
) - 1;
637 memcpy(protocol
, filename
, len
);
638 protocol
[len
] = '\0';
639 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
640 if (drv1
->protocol_name
&&
641 !strcmp(drv1
->protocol_name
, protocol
)) {
648 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
649 BlockDriver
**pdrv
, Error
**errp
)
651 int score
, score_max
;
652 BlockDriver
*drv1
, *drv
;
656 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
657 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
658 drv
= bdrv_find_format("raw");
660 error_setg(errp
, "Could not find raw image format");
667 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
669 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
677 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
678 if (drv1
->bdrv_probe
) {
679 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
680 if (score
> score_max
) {
687 error_setg(errp
, "Could not determine image format: No compatible "
696 * Set the current 'total_sectors' value
698 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
700 BlockDriver
*drv
= bs
->drv
;
702 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
706 /* query actual device if possible, otherwise just trust the hint */
707 if (drv
->bdrv_getlength
) {
708 int64_t length
= drv
->bdrv_getlength(bs
);
712 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
715 bs
->total_sectors
= hint
;
720 * Set open flags for a given discard mode
722 * Return 0 on success, -1 if the discard mode was invalid.
724 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
726 *flags
&= ~BDRV_O_UNMAP
;
728 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
730 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
731 *flags
|= BDRV_O_UNMAP
;
740 * Set open flags for a given cache mode
742 * Return 0 on success, -1 if the cache mode was invalid.
744 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
746 *flags
&= ~BDRV_O_CACHE_MASK
;
748 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
749 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
750 } else if (!strcmp(mode
, "directsync")) {
751 *flags
|= BDRV_O_NOCACHE
;
752 } else if (!strcmp(mode
, "writeback")) {
753 *flags
|= BDRV_O_CACHE_WB
;
754 } else if (!strcmp(mode
, "unsafe")) {
755 *flags
|= BDRV_O_CACHE_WB
;
756 *flags
|= BDRV_O_NO_FLUSH
;
757 } else if (!strcmp(mode
, "writethrough")) {
758 /* this is the default */
767 * The copy-on-read flag is actually a reference count so multiple users may
768 * use the feature without worrying about clobbering its previous state.
769 * Copy-on-read stays enabled until all users have called to disable it.
771 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
776 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
778 assert(bs
->copy_on_read
> 0);
783 * Returns the flags that a temporary snapshot should get, based on the
784 * originally requested flags (the originally requested image will have flags
785 * like a backing file)
787 static int bdrv_temp_snapshot_flags(int flags
)
789 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
793 * Returns the flags that bs->file should get, based on the given flags for
796 static int bdrv_inherited_flags(int flags
)
798 /* Enable protocol handling, disable format probing for bs->file */
799 flags
|= BDRV_O_PROTOCOL
;
801 /* Our block drivers take care to send flushes and respect unmap policy,
802 * so we can enable both unconditionally on lower layers. */
803 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
805 /* Clear flags that only apply to the top layer */
806 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
812 * Returns the flags that bs->backing_hd should get, based on the given flags
815 static int bdrv_backing_flags(int flags
)
817 /* backing files always opened read-only */
818 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
820 /* snapshot=on is handled on the top layer */
821 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
826 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
828 int open_flags
= flags
| BDRV_O_CACHE_WB
;
831 * Clear flags that are internal to the block layer before opening the
834 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
837 * Snapshots should be writable.
839 if (flags
& BDRV_O_TEMPORARY
) {
840 open_flags
|= BDRV_O_RDWR
;
846 static void bdrv_assign_node_name(BlockDriverState
*bs
,
847 const char *node_name
,
854 /* empty string node name is invalid */
855 if (node_name
[0] == '\0') {
856 error_setg(errp
, "Empty node name");
860 /* takes care of avoiding namespaces collisions */
861 if (bdrv_find(node_name
)) {
862 error_setg(errp
, "node-name=%s is conflicting with a device id",
867 /* takes care of avoiding duplicates node names */
868 if (bdrv_find_node(node_name
)) {
869 error_setg(errp
, "Duplicate node name");
873 /* copy node name into the bs and insert it into the graph list */
874 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
875 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
879 * Common part for opening disk images and files
881 * Removes all processed options from *options.
883 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
884 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
887 const char *filename
;
888 const char *node_name
= NULL
;
889 Error
*local_err
= NULL
;
892 assert(bs
->file
== NULL
);
893 assert(options
!= NULL
&& bs
->options
!= options
);
896 filename
= file
->filename
;
898 filename
= qdict_get_try_str(options
, "filename");
901 if (drv
->bdrv_needs_filename
&& !filename
) {
902 error_setg(errp
, "The '%s' block driver requires a file name",
907 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
909 node_name
= qdict_get_try_str(options
, "node-name");
910 bdrv_assign_node_name(bs
, node_name
, &local_err
);
912 error_propagate(errp
, local_err
);
915 qdict_del(options
, "node-name");
917 /* bdrv_open() with directly using a protocol as drv. This layer is already
918 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
919 * and return immediately. */
920 if (file
!= NULL
&& drv
->bdrv_file_open
) {
925 bs
->open_flags
= flags
;
926 bs
->guest_block_size
= 512;
927 bs
->request_alignment
= 512;
928 bs
->zero_beyond_eof
= true;
929 open_flags
= bdrv_open_flags(bs
, flags
);
930 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
931 bs
->growable
= !!(flags
& BDRV_O_PROTOCOL
);
933 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
935 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
936 ? "Driver '%s' can only be used for read-only devices"
937 : "Driver '%s' is not whitelisted",
942 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
943 if (flags
& BDRV_O_COPY_ON_READ
) {
944 if (!bs
->read_only
) {
945 bdrv_enable_copy_on_read(bs
);
947 error_setg(errp
, "Can't use copy-on-read on read-only device");
952 if (filename
!= NULL
) {
953 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
955 bs
->filename
[0] = '\0';
959 bs
->opaque
= g_malloc0(drv
->instance_size
);
961 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
963 /* Open the image, either directly or using a protocol */
964 if (drv
->bdrv_file_open
) {
965 assert(file
== NULL
);
966 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
967 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
970 error_setg(errp
, "Can't use '%s' as a block driver for the "
971 "protocol level", drv
->format_name
);
976 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
981 error_propagate(errp
, local_err
);
982 } else if (bs
->filename
[0]) {
983 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
985 error_setg_errno(errp
, -ret
, "Could not open image");
990 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
992 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
996 bdrv_refresh_limits(bs
);
997 assert(bdrv_opt_mem_align(bs
) != 0);
998 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1009 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1011 QObject
*options_obj
;
1015 ret
= strstart(filename
, "json:", &filename
);
1018 options_obj
= qobject_from_json(filename
);
1020 error_setg(errp
, "Could not parse the JSON options");
1024 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1025 qobject_decref(options_obj
);
1026 error_setg(errp
, "Invalid JSON object given");
1030 options
= qobject_to_qdict(options_obj
);
1031 qdict_flatten(options
);
1037 * Fills in default options for opening images and converts the legacy
1038 * filename/flags pair to option QDict entries.
1040 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
1041 BlockDriver
*drv
, Error
**errp
)
1043 const char *filename
= *pfilename
;
1044 const char *drvname
;
1045 bool protocol
= flags
& BDRV_O_PROTOCOL
;
1046 bool parse_filename
= false;
1047 Error
*local_err
= NULL
;
1049 /* Parse json: pseudo-protocol */
1050 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1051 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1053 error_propagate(errp
, local_err
);
1057 /* Options given in the filename have lower priority than options
1058 * specified directly */
1059 qdict_join(*options
, json_options
, false);
1060 QDECREF(json_options
);
1061 *pfilename
= filename
= NULL
;
1064 /* Fetch the file name from the options QDict if necessary */
1065 if (protocol
&& filename
) {
1066 if (!qdict_haskey(*options
, "filename")) {
1067 qdict_put(*options
, "filename", qstring_from_str(filename
));
1068 parse_filename
= true;
1070 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1076 /* Find the right block driver */
1077 filename
= qdict_get_try_str(*options
, "filename");
1078 drvname
= qdict_get_try_str(*options
, "driver");
1082 error_setg(errp
, "Driver specified twice");
1085 drvname
= drv
->format_name
;
1086 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1088 if (!drvname
&& protocol
) {
1090 drv
= bdrv_find_protocol(filename
, parse_filename
);
1092 error_setg(errp
, "Unknown protocol");
1096 drvname
= drv
->format_name
;
1097 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1099 error_setg(errp
, "Must specify either driver or file");
1102 } else if (drvname
) {
1103 drv
= bdrv_find_format(drvname
);
1105 error_setg(errp
, "Unknown driver '%s'", drvname
);
1111 assert(drv
|| !protocol
);
1113 /* Driver-specific filename parsing */
1114 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1115 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1117 error_propagate(errp
, local_err
);
1121 if (!drv
->bdrv_needs_filename
) {
1122 qdict_del(*options
, "filename");
1129 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1132 if (bs
->backing_hd
) {
1133 assert(bs
->backing_blocker
);
1134 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1135 } else if (backing_hd
) {
1136 error_setg(&bs
->backing_blocker
,
1137 "device is used as backing hd of '%s'",
1141 bs
->backing_hd
= backing_hd
;
1143 error_free(bs
->backing_blocker
);
1144 bs
->backing_blocker
= NULL
;
1147 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1148 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1149 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1150 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1152 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1153 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1154 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
,
1155 bs
->backing_blocker
);
1157 bdrv_refresh_limits(bs
);
1161 * Opens the backing file for a BlockDriverState if not yet open
1163 * options is a QDict of options to pass to the block drivers, or NULL for an
1164 * empty set of options. The reference to the QDict is transferred to this
1165 * function (even on failure), so if the caller intends to reuse the dictionary,
1166 * it needs to use QINCREF() before calling bdrv_file_open.
1168 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1170 char *backing_filename
= g_malloc0(PATH_MAX
);
1172 BlockDriver
*back_drv
= NULL
;
1173 BlockDriverState
*backing_hd
;
1174 Error
*local_err
= NULL
;
1176 if (bs
->backing_hd
!= NULL
) {
1181 /* NULL means an empty set of options */
1182 if (options
== NULL
) {
1183 options
= qdict_new();
1186 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1187 if (qdict_haskey(options
, "file.filename")) {
1188 backing_filename
[0] = '\0';
1189 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1193 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
);
1196 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1198 error_setg(errp
, "Driver doesn't support backing files");
1203 backing_hd
= bdrv_new("", errp
);
1205 if (bs
->backing_format
[0] != '\0') {
1206 back_drv
= bdrv_find_format(bs
->backing_format
);
1209 assert(bs
->backing_hd
== NULL
);
1210 ret
= bdrv_open(&backing_hd
,
1211 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1212 bdrv_backing_flags(bs
->open_flags
), back_drv
, &local_err
);
1214 bdrv_unref(backing_hd
);
1216 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1217 error_setg(errp
, "Could not open backing file: %s",
1218 error_get_pretty(local_err
));
1219 error_free(local_err
);
1222 bdrv_set_backing_hd(bs
, backing_hd
);
1225 g_free(backing_filename
);
1230 * Opens a disk image whose options are given as BlockdevRef in another block
1233 * If allow_none is true, no image will be opened if filename is false and no
1234 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1236 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1237 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1238 * itself, all options starting with "${bdref_key}." are considered part of the
1241 * The BlockdevRef will be removed from the options QDict.
1243 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1245 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1246 QDict
*options
, const char *bdref_key
, int flags
,
1247 bool allow_none
, Error
**errp
)
1249 QDict
*image_options
;
1251 char *bdref_key_dot
;
1252 const char *reference
;
1255 assert(*pbs
== NULL
);
1257 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1258 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1259 g_free(bdref_key_dot
);
1261 reference
= qdict_get_try_str(options
, bdref_key
);
1262 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1266 error_setg(errp
, "A block device must be specified for \"%s\"",
1270 QDECREF(image_options
);
1274 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1277 qdict_del(options
, bdref_key
);
1281 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1283 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1284 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1286 BlockDriver
*bdrv_qcow2
;
1287 QemuOpts
*opts
= NULL
;
1288 QDict
*snapshot_options
;
1289 BlockDriverState
*bs_snapshot
;
1293 /* if snapshot, we create a temporary backing file and open it
1294 instead of opening 'filename' directly */
1296 /* Get the required size from the image */
1297 total_size
= bdrv_getlength(bs
);
1298 if (total_size
< 0) {
1300 error_setg_errno(errp
, -total_size
, "Could not get image size");
1303 total_size
&= BDRV_SECTOR_MASK
;
1305 /* Create the temporary image */
1306 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1308 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1312 bdrv_qcow2
= bdrv_find_format("qcow2");
1313 opts
= qemu_opts_create(bdrv_qcow2
->create_opts
, NULL
, 0,
1315 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
);
1316 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1317 qemu_opts_del(opts
);
1319 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1320 "'%s': %s", tmp_filename
,
1321 error_get_pretty(local_err
));
1322 error_free(local_err
);
1326 /* Prepare a new options QDict for the temporary file */
1327 snapshot_options
= qdict_new();
1328 qdict_put(snapshot_options
, "file.driver",
1329 qstring_from_str("file"));
1330 qdict_put(snapshot_options
, "file.filename",
1331 qstring_from_str(tmp_filename
));
1333 bs_snapshot
= bdrv_new("", &error_abort
);
1335 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1336 flags
, bdrv_qcow2
, &local_err
);
1338 error_propagate(errp
, local_err
);
1342 bdrv_append(bs_snapshot
, bs
);
1345 g_free(tmp_filename
);
1350 * Opens a disk image (raw, qcow2, vmdk, ...)
1352 * options is a QDict of options to pass to the block drivers, or NULL for an
1353 * empty set of options. The reference to the QDict belongs to the block layer
1354 * after the call (even on failure), so if the caller intends to reuse the
1355 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1357 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1358 * If it is not NULL, the referenced BDS will be reused.
1360 * The reference parameter may be used to specify an existing block device which
1361 * should be opened. If specified, neither options nor a filename may be given,
1362 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1364 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1365 const char *reference
, QDict
*options
, int flags
,
1366 BlockDriver
*drv
, Error
**errp
)
1369 BlockDriverState
*file
= NULL
, *bs
;
1370 const char *drvname
;
1371 Error
*local_err
= NULL
;
1372 int snapshot_flags
= 0;
1377 bool options_non_empty
= options
? qdict_size(options
) : false;
1381 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1382 "another block device");
1386 if (filename
|| options_non_empty
) {
1387 error_setg(errp
, "Cannot reference an existing block device with "
1388 "additional options or a new filename");
1392 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1404 bs
= bdrv_new("", &error_abort
);
1407 /* NULL means an empty set of options */
1408 if (options
== NULL
) {
1409 options
= qdict_new();
1412 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1417 /* Find the right image format driver */
1419 drvname
= qdict_get_try_str(options
, "driver");
1421 drv
= bdrv_find_format(drvname
);
1422 qdict_del(options
, "driver");
1424 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1430 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1431 if (drv
&& !drv
->bdrv_file_open
) {
1432 /* If the user explicitly wants a format driver here, we'll need to add
1433 * another layer for the protocol in bs->file */
1434 flags
&= ~BDRV_O_PROTOCOL
;
1437 bs
->options
= options
;
1438 options
= qdict_clone_shallow(options
);
1440 /* Open image file without format layer */
1441 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1442 if (flags
& BDRV_O_RDWR
) {
1443 flags
|= BDRV_O_ALLOW_RDWR
;
1445 if (flags
& BDRV_O_SNAPSHOT
) {
1446 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1447 flags
= bdrv_backing_flags(flags
);
1450 assert(file
== NULL
);
1451 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1452 bdrv_inherited_flags(flags
),
1459 /* Image format probing */
1461 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1466 error_setg(errp
, "Must specify either driver or file");
1471 /* Open the image */
1472 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1477 if (file
&& (bs
->file
!= file
)) {
1482 /* If there is a backing file, use it */
1483 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1484 QDict
*backing_options
;
1486 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1487 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1489 goto close_and_fail
;
1493 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1494 * temporary snapshot afterwards. */
1495 if (snapshot_flags
) {
1496 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1498 goto close_and_fail
;
1502 /* Check if any unknown options were used */
1503 if (options
&& (qdict_size(options
) != 0)) {
1504 const QDictEntry
*entry
= qdict_first(options
);
1505 if (flags
& BDRV_O_PROTOCOL
) {
1506 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1507 "'%s'", drv
->format_name
, entry
->key
);
1509 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1510 "support the option '%s'", drv
->format_name
,
1511 bs
->device_name
, entry
->key
);
1515 goto close_and_fail
;
1518 if (!bdrv_key_required(bs
)) {
1519 bdrv_dev_change_media_cb(bs
, true);
1520 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1521 && !runstate_check(RUN_STATE_INMIGRATE
)
1522 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1524 "Guest must be stopped for opening of encrypted image");
1526 goto close_and_fail
;
1537 QDECREF(bs
->options
);
1541 /* If *pbs is NULL, a new BDS has been created in this function and
1542 needs to be freed now. Otherwise, it does not need to be closed,
1543 since it has not really been opened yet. */
1547 error_propagate(errp
, local_err
);
1552 /* See fail path, but now the BDS has to be always closed */
1560 error_propagate(errp
, local_err
);
1565 typedef struct BlockReopenQueueEntry
{
1567 BDRVReopenState state
;
1568 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1569 } BlockReopenQueueEntry
;
1572 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1573 * reopen of multiple devices.
1575 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1576 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1577 * be created and initialized. This newly created BlockReopenQueue should be
1578 * passed back in for subsequent calls that are intended to be of the same
1581 * bs is the BlockDriverState to add to the reopen queue.
1583 * flags contains the open flags for the associated bs
1585 * returns a pointer to bs_queue, which is either the newly allocated
1586 * bs_queue, or the existing bs_queue being used.
1589 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1590 BlockDriverState
*bs
, int flags
)
1594 BlockReopenQueueEntry
*bs_entry
;
1595 if (bs_queue
== NULL
) {
1596 bs_queue
= g_new0(BlockReopenQueue
, 1);
1597 QSIMPLEQ_INIT(bs_queue
);
1600 /* bdrv_open() masks this flag out */
1601 flags
&= ~BDRV_O_PROTOCOL
;
1604 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1607 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1608 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1610 bs_entry
->state
.bs
= bs
;
1611 bs_entry
->state
.flags
= flags
;
1617 * Reopen multiple BlockDriverStates atomically & transactionally.
1619 * The queue passed in (bs_queue) must have been built up previous
1620 * via bdrv_reopen_queue().
1622 * Reopens all BDS specified in the queue, with the appropriate
1623 * flags. All devices are prepared for reopen, and failure of any
1624 * device will cause all device changes to be abandonded, and intermediate
1627 * If all devices prepare successfully, then the changes are committed
1631 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1634 BlockReopenQueueEntry
*bs_entry
, *next
;
1635 Error
*local_err
= NULL
;
1637 assert(bs_queue
!= NULL
);
1641 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1642 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1643 error_propagate(errp
, local_err
);
1646 bs_entry
->prepared
= true;
1649 /* If we reach this point, we have success and just need to apply the
1652 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1653 bdrv_reopen_commit(&bs_entry
->state
);
1659 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1660 if (ret
&& bs_entry
->prepared
) {
1661 bdrv_reopen_abort(&bs_entry
->state
);
1670 /* Reopen a single BlockDriverState with the specified flags. */
1671 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1674 Error
*local_err
= NULL
;
1675 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1677 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1678 if (local_err
!= NULL
) {
1679 error_propagate(errp
, local_err
);
1686 * Prepares a BlockDriverState for reopen. All changes are staged in the
1687 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1688 * the block driver layer .bdrv_reopen_prepare()
1690 * bs is the BlockDriverState to reopen
1691 * flags are the new open flags
1692 * queue is the reopen queue
1694 * Returns 0 on success, non-zero on error. On error errp will be set
1697 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1698 * It is the responsibility of the caller to then call the abort() or
1699 * commit() for any other BDS that have been left in a prepare() state
1702 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1706 Error
*local_err
= NULL
;
1709 assert(reopen_state
!= NULL
);
1710 assert(reopen_state
->bs
->drv
!= NULL
);
1711 drv
= reopen_state
->bs
->drv
;
1713 /* if we are to stay read-only, do not allow permission change
1715 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1716 reopen_state
->flags
& BDRV_O_RDWR
) {
1717 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1718 reopen_state
->bs
->device_name
);
1723 ret
= bdrv_flush(reopen_state
->bs
);
1725 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1730 if (drv
->bdrv_reopen_prepare
) {
1731 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1733 if (local_err
!= NULL
) {
1734 error_propagate(errp
, local_err
);
1736 error_setg(errp
, "failed while preparing to reopen image '%s'",
1737 reopen_state
->bs
->filename
);
1742 /* It is currently mandatory to have a bdrv_reopen_prepare()
1743 * handler for each supported drv. */
1744 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1745 drv
->format_name
, reopen_state
->bs
->device_name
,
1746 "reopening of file");
1758 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1759 * makes them final by swapping the staging BlockDriverState contents into
1760 * the active BlockDriverState contents.
1762 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1766 assert(reopen_state
!= NULL
);
1767 drv
= reopen_state
->bs
->drv
;
1768 assert(drv
!= NULL
);
1770 /* If there are any driver level actions to take */
1771 if (drv
->bdrv_reopen_commit
) {
1772 drv
->bdrv_reopen_commit(reopen_state
);
1775 /* set BDS specific flags now */
1776 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1777 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1779 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1781 bdrv_refresh_limits(reopen_state
->bs
);
1785 * Abort the reopen, and delete and free the staged changes in
1788 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1792 assert(reopen_state
!= NULL
);
1793 drv
= reopen_state
->bs
->drv
;
1794 assert(drv
!= NULL
);
1796 if (drv
->bdrv_reopen_abort
) {
1797 drv
->bdrv_reopen_abort(reopen_state
);
1802 void bdrv_close(BlockDriverState
*bs
)
1805 block_job_cancel_sync(bs
->job
);
1807 bdrv_drain_all(); /* complete I/O */
1809 bdrv_drain_all(); /* in case flush left pending I/O */
1810 notifier_list_notify(&bs
->close_notifiers
, bs
);
1813 if (bs
->backing_hd
) {
1814 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1815 bdrv_set_backing_hd(bs
, NULL
);
1816 bdrv_unref(backing_hd
);
1818 bs
->drv
->bdrv_close(bs
);
1822 bs
->copy_on_read
= 0;
1823 bs
->backing_file
[0] = '\0';
1824 bs
->backing_format
[0] = '\0';
1825 bs
->total_sectors
= 0;
1830 bs
->zero_beyond_eof
= false;
1831 QDECREF(bs
->options
);
1834 if (bs
->file
!= NULL
) {
1835 bdrv_unref(bs
->file
);
1840 bdrv_dev_change_media_cb(bs
, false);
1842 /*throttling disk I/O limits*/
1843 if (bs
->io_limits_enabled
) {
1844 bdrv_io_limits_disable(bs
);
1848 void bdrv_close_all(void)
1850 BlockDriverState
*bs
;
1852 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1853 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1855 aio_context_acquire(aio_context
);
1857 aio_context_release(aio_context
);
1861 /* Check if any requests are in-flight (including throttled requests) */
1862 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1864 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1867 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1870 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1873 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1876 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1883 * Wait for pending requests to complete across all BlockDriverStates
1885 * This function does not flush data to disk, use bdrv_flush_all() for that
1886 * after calling this function.
1888 * Note that completion of an asynchronous I/O operation can trigger any
1889 * number of other I/O operations on other devices---for example a coroutine
1890 * can be arbitrarily complex and a constant flow of I/O can come until the
1891 * coroutine is complete. Because of this, it is not possible to have a
1892 * function to drain a single device's I/O queue.
1894 void bdrv_drain_all(void)
1896 /* Always run first iteration so any pending completion BHs run */
1898 BlockDriverState
*bs
;
1903 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1904 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1907 aio_context_acquire(aio_context
);
1908 bdrv_flush_io_queue(bs
);
1909 bdrv_start_throttled_reqs(bs
);
1910 bs_busy
= bdrv_requests_pending(bs
);
1911 bs_busy
|= aio_poll(aio_context
, bs_busy
);
1912 aio_context_release(aio_context
);
1919 /* make a BlockDriverState anonymous by removing from bdrv_state and
1920 * graph_bdrv_state list.
1921 Also, NULL terminate the device_name to prevent double remove */
1922 void bdrv_make_anon(BlockDriverState
*bs
)
1924 if (bs
->device_name
[0] != '\0') {
1925 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1927 bs
->device_name
[0] = '\0';
1928 if (bs
->node_name
[0] != '\0') {
1929 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1931 bs
->node_name
[0] = '\0';
1934 static void bdrv_rebind(BlockDriverState
*bs
)
1936 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1937 bs
->drv
->bdrv_rebind(bs
);
1941 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1942 BlockDriverState
*bs_src
)
1944 /* move some fields that need to stay attached to the device */
1947 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1948 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1949 bs_dest
->dev
= bs_src
->dev
;
1950 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1951 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1953 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1955 /* i/o throttled req */
1956 memcpy(&bs_dest
->throttle_state
,
1957 &bs_src
->throttle_state
,
1958 sizeof(ThrottleState
));
1959 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1960 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1961 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1964 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1965 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1968 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1969 bs_dest
->iostatus
= bs_src
->iostatus
;
1972 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1974 /* reference count */
1975 bs_dest
->refcnt
= bs_src
->refcnt
;
1978 bs_dest
->job
= bs_src
->job
;
1980 /* keep the same entry in bdrv_states */
1981 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1982 bs_src
->device_name
);
1983 bs_dest
->device_list
= bs_src
->device_list
;
1984 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1985 sizeof(bs_dest
->op_blockers
));
1989 * Swap bs contents for two image chains while they are live,
1990 * while keeping required fields on the BlockDriverState that is
1991 * actually attached to a device.
1993 * This will modify the BlockDriverState fields, and swap contents
1994 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1996 * bs_new is required to be anonymous.
1998 * This function does not create any image files.
2000 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2002 BlockDriverState tmp
;
2004 /* The code needs to swap the node_name but simply swapping node_list won't
2005 * work so first remove the nodes from the graph list, do the swap then
2006 * insert them back if needed.
2008 if (bs_new
->node_name
[0] != '\0') {
2009 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2011 if (bs_old
->node_name
[0] != '\0') {
2012 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2015 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2016 assert(bs_new
->device_name
[0] == '\0');
2017 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2018 assert(bs_new
->job
== NULL
);
2019 assert(bs_new
->dev
== NULL
);
2020 assert(bs_new
->io_limits_enabled
== false);
2021 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2027 /* there are some fields that should not be swapped, move them back */
2028 bdrv_move_feature_fields(&tmp
, bs_old
);
2029 bdrv_move_feature_fields(bs_old
, bs_new
);
2030 bdrv_move_feature_fields(bs_new
, &tmp
);
2032 /* bs_new shouldn't be in bdrv_states even after the swap! */
2033 assert(bs_new
->device_name
[0] == '\0');
2035 /* Check a few fields that should remain attached to the device */
2036 assert(bs_new
->dev
== NULL
);
2037 assert(bs_new
->job
== NULL
);
2038 assert(bs_new
->io_limits_enabled
== false);
2039 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2041 /* insert the nodes back into the graph node list if needed */
2042 if (bs_new
->node_name
[0] != '\0') {
2043 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2045 if (bs_old
->node_name
[0] != '\0') {
2046 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2049 bdrv_rebind(bs_new
);
2050 bdrv_rebind(bs_old
);
2054 * Add new bs contents at the top of an image chain while the chain is
2055 * live, while keeping required fields on the top layer.
2057 * This will modify the BlockDriverState fields, and swap contents
2058 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2060 * bs_new is required to be anonymous.
2062 * This function does not create any image files.
2064 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2066 bdrv_swap(bs_new
, bs_top
);
2068 /* The contents of 'tmp' will become bs_top, as we are
2069 * swapping bs_new and bs_top contents. */
2070 bdrv_set_backing_hd(bs_top
, bs_new
);
2073 static void bdrv_delete(BlockDriverState
*bs
)
2077 assert(bdrv_op_blocker_is_empty(bs
));
2078 assert(!bs
->refcnt
);
2079 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2083 /* remove from list, if necessary */
2089 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
2090 /* TODO change to DeviceState *dev when all users are qdevified */
2096 bdrv_iostatus_reset(bs
);
2100 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2101 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
2103 if (bdrv_attach_dev(bs
, dev
) < 0) {
2108 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
2109 /* TODO change to DeviceState *dev when all users are qdevified */
2111 assert(bs
->dev
== dev
);
2114 bs
->dev_opaque
= NULL
;
2115 bs
->guest_block_size
= 512;
2118 /* TODO change to return DeviceState * when all users are qdevified */
2119 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
2124 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
2128 bs
->dev_opaque
= opaque
;
2131 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
2133 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
2134 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
2135 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
2136 if (tray_was_closed
) {
2138 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2139 true, &error_abort
);
2143 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2144 false, &error_abort
);
2149 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
2151 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
2154 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
2156 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
2157 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
2161 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
2163 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
2164 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
2169 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
2171 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
2172 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
2176 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
2178 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
2179 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
2185 * Run consistency checks on an image
2187 * Returns 0 if the check could be completed (it doesn't mean that the image is
2188 * free of errors) or -errno when an internal error occurred. The results of the
2189 * check are stored in res.
2191 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2193 if (bs
->drv
->bdrv_check
== NULL
) {
2197 memset(res
, 0, sizeof(*res
));
2198 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2201 #define COMMIT_BUF_SECTORS 2048
2203 /* commit COW file into the raw image */
2204 int bdrv_commit(BlockDriverState
*bs
)
2206 BlockDriver
*drv
= bs
->drv
;
2207 int64_t sector
, total_sectors
, length
, backing_length
;
2208 int n
, ro
, open_flags
;
2210 uint8_t *buf
= NULL
;
2211 char filename
[PATH_MAX
];
2216 if (!bs
->backing_hd
) {
2220 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT
, NULL
) ||
2221 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
, NULL
)) {
2225 ro
= bs
->backing_hd
->read_only
;
2226 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2227 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
2228 open_flags
= bs
->backing_hd
->open_flags
;
2231 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2236 length
= bdrv_getlength(bs
);
2242 backing_length
= bdrv_getlength(bs
->backing_hd
);
2243 if (backing_length
< 0) {
2244 ret
= backing_length
;
2248 /* If our top snapshot is larger than the backing file image,
2249 * grow the backing file image if possible. If not possible,
2250 * we must return an error */
2251 if (length
> backing_length
) {
2252 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2258 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2259 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2261 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2262 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2267 ret
= bdrv_read(bs
, sector
, buf
, n
);
2272 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2279 if (drv
->bdrv_make_empty
) {
2280 ret
= drv
->bdrv_make_empty(bs
);
2288 * Make sure all data we wrote to the backing device is actually
2291 if (bs
->backing_hd
) {
2292 bdrv_flush(bs
->backing_hd
);
2300 /* ignoring error return here */
2301 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2307 int bdrv_commit_all(void)
2309 BlockDriverState
*bs
;
2311 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2312 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2314 aio_context_acquire(aio_context
);
2315 if (bs
->drv
&& bs
->backing_hd
) {
2316 int ret
= bdrv_commit(bs
);
2318 aio_context_release(aio_context
);
2322 aio_context_release(aio_context
);
2328 * Remove an active request from the tracked requests list
2330 * This function should be called when a tracked request is completing.
2332 static void tracked_request_end(BdrvTrackedRequest
*req
)
2334 if (req
->serialising
) {
2335 req
->bs
->serialising_in_flight
--;
2338 QLIST_REMOVE(req
, list
);
2339 qemu_co_queue_restart_all(&req
->wait_queue
);
2343 * Add an active request to the tracked requests list
2345 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2346 BlockDriverState
*bs
,
2348 unsigned int bytes
, bool is_write
)
2350 *req
= (BdrvTrackedRequest
){
2354 .is_write
= is_write
,
2355 .co
= qemu_coroutine_self(),
2356 .serialising
= false,
2357 .overlap_offset
= offset
,
2358 .overlap_bytes
= bytes
,
2361 qemu_co_queue_init(&req
->wait_queue
);
2363 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2366 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2368 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2369 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2372 if (!req
->serialising
) {
2373 req
->bs
->serialising_in_flight
++;
2374 req
->serialising
= true;
2377 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2378 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2382 * Round a region to cluster boundaries
2384 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2385 int64_t sector_num
, int nb_sectors
,
2386 int64_t *cluster_sector_num
,
2387 int *cluster_nb_sectors
)
2389 BlockDriverInfo bdi
;
2391 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2392 *cluster_sector_num
= sector_num
;
2393 *cluster_nb_sectors
= nb_sectors
;
2395 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2396 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2397 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2402 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2404 BlockDriverInfo bdi
;
2407 ret
= bdrv_get_info(bs
, &bdi
);
2408 if (ret
< 0 || bdi
.cluster_size
== 0) {
2409 return bs
->request_alignment
;
2411 return bdi
.cluster_size
;
2415 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2416 int64_t offset
, unsigned int bytes
)
2419 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2423 if (req
->overlap_offset
>= offset
+ bytes
) {
2429 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2431 BlockDriverState
*bs
= self
->bs
;
2432 BdrvTrackedRequest
*req
;
2434 bool waited
= false;
2436 if (!bs
->serialising_in_flight
) {
2442 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2443 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2446 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2447 self
->overlap_bytes
))
2449 /* Hitting this means there was a reentrant request, for
2450 * example, a block driver issuing nested requests. This must
2451 * never happen since it means deadlock.
2453 assert(qemu_coroutine_self() != req
->co
);
2455 /* If the request is already (indirectly) waiting for us, or
2456 * will wait for us as soon as it wakes up, then just go on
2457 * (instead of producing a deadlock in the former case). */
2458 if (!req
->waiting_for
) {
2459 self
->waiting_for
= req
;
2460 qemu_co_queue_wait(&req
->wait_queue
);
2461 self
->waiting_for
= NULL
;
2476 * -EINVAL - backing format specified, but no file
2477 * -ENOSPC - can't update the backing file because no space is left in the
2479 * -ENOTSUP - format driver doesn't support changing the backing file
2481 int bdrv_change_backing_file(BlockDriverState
*bs
,
2482 const char *backing_file
, const char *backing_fmt
)
2484 BlockDriver
*drv
= bs
->drv
;
2487 /* Backing file format doesn't make sense without a backing file */
2488 if (backing_fmt
&& !backing_file
) {
2492 if (drv
->bdrv_change_backing_file
!= NULL
) {
2493 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2499 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2500 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2506 * Finds the image layer in the chain that has 'bs' as its backing file.
2508 * active is the current topmost image.
2510 * Returns NULL if bs is not found in active's image chain,
2511 * or if active == bs.
2513 * Returns the bottommost base image if bs == NULL.
2515 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2516 BlockDriverState
*bs
)
2518 while (active
&& bs
!= active
->backing_hd
) {
2519 active
= active
->backing_hd
;
2525 /* Given a BDS, searches for the base layer. */
2526 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2528 return bdrv_find_overlay(bs
, NULL
);
2531 typedef struct BlkIntermediateStates
{
2532 BlockDriverState
*bs
;
2533 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2534 } BlkIntermediateStates
;
2538 * Drops images above 'base' up to and including 'top', and sets the image
2539 * above 'top' to have base as its backing file.
2541 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2542 * information in 'bs' can be properly updated.
2544 * E.g., this will convert the following chain:
2545 * bottom <- base <- intermediate <- top <- active
2549 * bottom <- base <- active
2551 * It is allowed for bottom==base, in which case it converts:
2553 * base <- intermediate <- top <- active
2559 * If backing_file_str is non-NULL, it will be used when modifying top's
2560 * overlay image metadata.
2563 * if active == top, that is considered an error
2566 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2567 BlockDriverState
*base
, const char *backing_file_str
)
2569 BlockDriverState
*intermediate
;
2570 BlockDriverState
*base_bs
= NULL
;
2571 BlockDriverState
*new_top_bs
= NULL
;
2572 BlkIntermediateStates
*intermediate_state
, *next
;
2575 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2576 QSIMPLEQ_INIT(&states_to_delete
);
2578 if (!top
->drv
|| !base
->drv
) {
2582 new_top_bs
= bdrv_find_overlay(active
, top
);
2584 if (new_top_bs
== NULL
) {
2585 /* we could not find the image above 'top', this is an error */
2589 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2590 * to do, no intermediate images */
2591 if (new_top_bs
->backing_hd
== base
) {
2598 /* now we will go down through the list, and add each BDS we find
2599 * into our deletion queue, until we hit the 'base'
2601 while (intermediate
) {
2602 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
2603 intermediate_state
->bs
= intermediate
;
2604 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2606 if (intermediate
->backing_hd
== base
) {
2607 base_bs
= intermediate
->backing_hd
;
2610 intermediate
= intermediate
->backing_hd
;
2612 if (base_bs
== NULL
) {
2613 /* something went wrong, we did not end at the base. safely
2614 * unravel everything, and exit with error */
2618 /* success - we can delete the intermediate states, and link top->base */
2619 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2620 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2621 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2625 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2627 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2628 /* so that bdrv_close() does not recursively close the chain */
2629 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2630 bdrv_unref(intermediate_state
->bs
);
2635 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2636 g_free(intermediate_state
);
2642 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2647 if (size
> INT_MAX
) {
2651 if (!bdrv_is_inserted(bs
))
2657 len
= bdrv_getlength(bs
);
2662 if ((offset
> len
) || (len
- offset
< size
))
2668 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2671 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2675 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2676 nb_sectors
* BDRV_SECTOR_SIZE
);
2679 typedef struct RwCo
{
2680 BlockDriverState
*bs
;
2685 BdrvRequestFlags flags
;
2688 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2690 RwCo
*rwco
= opaque
;
2692 if (!rwco
->is_write
) {
2693 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2694 rwco
->qiov
->size
, rwco
->qiov
,
2697 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2698 rwco
->qiov
->size
, rwco
->qiov
,
2704 * Process a vectored synchronous request using coroutines
2706 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2707 QEMUIOVector
*qiov
, bool is_write
,
2708 BdrvRequestFlags flags
)
2715 .is_write
= is_write
,
2721 * In sync call context, when the vcpu is blocked, this throttling timer
2722 * will not fire; so the I/O throttling function has to be disabled here
2723 * if it has been enabled.
2725 if (bs
->io_limits_enabled
) {
2726 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2727 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2728 bdrv_io_limits_disable(bs
);
2731 if (qemu_in_coroutine()) {
2732 /* Fast-path if already in coroutine context */
2733 bdrv_rw_co_entry(&rwco
);
2735 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2737 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2738 qemu_coroutine_enter(co
, &rwco
);
2739 while (rwco
.ret
== NOT_DONE
) {
2740 aio_poll(aio_context
, true);
2747 * Process a synchronous request using coroutines
2749 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2750 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2753 struct iovec iov
= {
2754 .iov_base
= (void *)buf
,
2755 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2758 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2762 qemu_iovec_init_external(&qiov
, &iov
, 1);
2763 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2764 &qiov
, is_write
, flags
);
2767 /* return < 0 if error. See bdrv_write() for the return codes */
2768 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2769 uint8_t *buf
, int nb_sectors
)
2771 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2774 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2775 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2776 uint8_t *buf
, int nb_sectors
)
2781 enabled
= bs
->io_limits_enabled
;
2782 bs
->io_limits_enabled
= false;
2783 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2784 bs
->io_limits_enabled
= enabled
;
2788 /* Return < 0 if error. Important errors are:
2789 -EIO generic I/O error (may happen for all errors)
2790 -ENOMEDIUM No media inserted.
2791 -EINVAL Invalid sector number or nb_sectors
2792 -EACCES Trying to write a read-only device
2794 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2795 const uint8_t *buf
, int nb_sectors
)
2797 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2800 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2801 int nb_sectors
, BdrvRequestFlags flags
)
2803 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2804 BDRV_REQ_ZERO_WRITE
| flags
);
2808 * Completely zero out a block device with the help of bdrv_write_zeroes.
2809 * The operation is sped up by checking the block status and only writing
2810 * zeroes to the device if they currently do not return zeroes. Optional
2811 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2813 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2815 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2817 int64_t target_size
;
2818 int64_t ret
, nb_sectors
, sector_num
= 0;
2821 target_size
= bdrv_getlength(bs
);
2822 if (target_size
< 0) {
2825 target_size
/= BDRV_SECTOR_SIZE
;
2828 nb_sectors
= target_size
- sector_num
;
2829 if (nb_sectors
<= 0) {
2832 if (nb_sectors
> INT_MAX
) {
2833 nb_sectors
= INT_MAX
;
2835 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2837 error_report("error getting block status at sector %" PRId64
": %s",
2838 sector_num
, strerror(-ret
));
2841 if (ret
& BDRV_BLOCK_ZERO
) {
2845 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2847 error_report("error writing zeroes at sector %" PRId64
": %s",
2848 sector_num
, strerror(-ret
));
2855 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2858 struct iovec iov
= {
2859 .iov_base
= (void *)buf
,
2868 qemu_iovec_init_external(&qiov
, &iov
, 1);
2869 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2877 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2881 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2889 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2890 const void *buf
, int bytes
)
2893 struct iovec iov
= {
2894 .iov_base
= (void *) buf
,
2902 qemu_iovec_init_external(&qiov
, &iov
, 1);
2903 return bdrv_pwritev(bs
, offset
, &qiov
);
2907 * Writes to the file and ensures that no writes are reordered across this
2908 * request (acts as a barrier)
2910 * Returns 0 on success, -errno in error cases.
2912 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2913 const void *buf
, int count
)
2917 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2922 /* No flush needed for cache modes that already do it */
2923 if (bs
->enable_write_cache
) {
2930 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2931 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2933 /* Perform I/O through a temporary buffer so that users who scribble over
2934 * their read buffer while the operation is in progress do not end up
2935 * modifying the image file. This is critical for zero-copy guest I/O
2936 * where anything might happen inside guest memory.
2938 void *bounce_buffer
;
2940 BlockDriver
*drv
= bs
->drv
;
2942 QEMUIOVector bounce_qiov
;
2943 int64_t cluster_sector_num
;
2944 int cluster_nb_sectors
;
2948 /* Cover entire cluster so no additional backing file I/O is required when
2949 * allocating cluster in the image file.
2951 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2952 &cluster_sector_num
, &cluster_nb_sectors
);
2954 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2955 cluster_sector_num
, cluster_nb_sectors
);
2957 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2958 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2959 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2961 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2967 if (drv
->bdrv_co_write_zeroes
&&
2968 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2969 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2970 cluster_nb_sectors
, 0);
2972 /* This does not change the data on the disk, it is not necessary
2973 * to flush even in cache=writethrough mode.
2975 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2980 /* It might be okay to ignore write errors for guest requests. If this
2981 * is a deliberate copy-on-read then we don't want to ignore the error.
2982 * Simply report it in all cases.
2987 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2988 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2989 nb_sectors
* BDRV_SECTOR_SIZE
);
2992 qemu_vfree(bounce_buffer
);
2997 * Forwards an already correctly aligned request to the BlockDriver. This
2998 * handles copy on read and zeroing after EOF; any other features must be
2999 * implemented by the caller.
3001 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
3002 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3003 int64_t align
, QEMUIOVector
*qiov
, int flags
)
3005 BlockDriver
*drv
= bs
->drv
;
3008 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3009 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3011 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3012 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3014 /* Handle Copy on Read and associated serialisation */
3015 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3016 /* If we touch the same cluster it counts as an overlap. This
3017 * guarantees that allocating writes will be serialized and not race
3018 * with each other for the same cluster. For example, in copy-on-read
3019 * it ensures that the CoR read and write operations are atomic and
3020 * guest writes cannot interleave between them. */
3021 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3024 wait_serialising_requests(req
);
3026 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3029 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3034 if (!ret
|| pnum
!= nb_sectors
) {
3035 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3040 /* Forward the request to the BlockDriver */
3041 if (!(bs
->zero_beyond_eof
&& bs
->growable
)) {
3042 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3044 /* Read zeros after EOF of growable BDSes */
3045 int64_t len
, total_sectors
, max_nb_sectors
;
3047 len
= bdrv_getlength(bs
);
3053 total_sectors
= DIV_ROUND_UP(len
, BDRV_SECTOR_SIZE
);
3054 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3055 align
>> BDRV_SECTOR_BITS
);
3056 if (max_nb_sectors
> 0) {
3057 QEMUIOVector local_qiov
;
3058 size_t local_sectors
;
3060 max_nb_sectors
= MIN(max_nb_sectors
, SIZE_MAX
/ BDRV_SECTOR_BITS
);
3061 local_sectors
= MIN(max_nb_sectors
, nb_sectors
);
3063 qemu_iovec_init(&local_qiov
, qiov
->niov
);
3064 qemu_iovec_concat(&local_qiov
, qiov
, 0,
3065 local_sectors
* BDRV_SECTOR_SIZE
);
3067 ret
= drv
->bdrv_co_readv(bs
, sector_num
, local_sectors
,
3070 qemu_iovec_destroy(&local_qiov
);
3075 /* Reading beyond end of file is supposed to produce zeroes */
3076 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3077 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3078 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3080 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3089 * Handle a read request in coroutine context
3091 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3092 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3093 BdrvRequestFlags flags
)
3095 BlockDriver
*drv
= bs
->drv
;
3096 BdrvTrackedRequest req
;
3098 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3099 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3100 uint8_t *head_buf
= NULL
;
3101 uint8_t *tail_buf
= NULL
;
3102 QEMUIOVector local_qiov
;
3103 bool use_local_qiov
= false;
3109 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3113 if (bs
->copy_on_read
) {
3114 flags
|= BDRV_REQ_COPY_ON_READ
;
3117 /* throttling disk I/O */
3118 if (bs
->io_limits_enabled
) {
3119 bdrv_io_limits_intercept(bs
, bytes
, false);
3122 /* Align read if necessary by padding qiov */
3123 if (offset
& (align
- 1)) {
3124 head_buf
= qemu_blockalign(bs
, align
);
3125 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3126 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3127 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3128 use_local_qiov
= true;
3130 bytes
+= offset
& (align
- 1);
3131 offset
= offset
& ~(align
- 1);
3134 if ((offset
+ bytes
) & (align
- 1)) {
3135 if (!use_local_qiov
) {
3136 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3137 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3138 use_local_qiov
= true;
3140 tail_buf
= qemu_blockalign(bs
, align
);
3141 qemu_iovec_add(&local_qiov
, tail_buf
,
3142 align
- ((offset
+ bytes
) & (align
- 1)));
3144 bytes
= ROUND_UP(bytes
, align
);
3147 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3148 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3149 use_local_qiov
? &local_qiov
: qiov
,
3151 tracked_request_end(&req
);
3153 if (use_local_qiov
) {
3154 qemu_iovec_destroy(&local_qiov
);
3155 qemu_vfree(head_buf
);
3156 qemu_vfree(tail_buf
);
3162 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3163 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3164 BdrvRequestFlags flags
)
3166 if (nb_sectors
< 0 || nb_sectors
> (UINT_MAX
>> BDRV_SECTOR_BITS
)) {
3170 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3171 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3174 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3175 int nb_sectors
, QEMUIOVector
*qiov
)
3177 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3179 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3182 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3183 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3185 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3187 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3188 BDRV_REQ_COPY_ON_READ
);
3191 /* if no limit is specified in the BlockLimits use a default
3192 * of 32768 512-byte sectors (16 MiB) per request.
3194 #define MAX_WRITE_ZEROES_DEFAULT 32768
3196 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3197 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3199 BlockDriver
*drv
= bs
->drv
;
3201 struct iovec iov
= {0};
3204 int max_write_zeroes
= bs
->bl
.max_write_zeroes
?
3205 bs
->bl
.max_write_zeroes
: MAX_WRITE_ZEROES_DEFAULT
;
3207 while (nb_sectors
> 0 && !ret
) {
3208 int num
= nb_sectors
;
3210 /* Align request. Block drivers can expect the "bulk" of the request
3213 if (bs
->bl
.write_zeroes_alignment
3214 && num
> bs
->bl
.write_zeroes_alignment
) {
3215 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3216 /* Make a small request up to the first aligned sector. */
3217 num
= bs
->bl
.write_zeroes_alignment
;
3218 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3219 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3220 /* Shorten the request to the last aligned sector. num cannot
3221 * underflow because num > bs->bl.write_zeroes_alignment.
3223 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3227 /* limit request size */
3228 if (num
> max_write_zeroes
) {
3229 num
= max_write_zeroes
;
3233 /* First try the efficient write zeroes operation */
3234 if (drv
->bdrv_co_write_zeroes
) {
3235 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3238 if (ret
== -ENOTSUP
) {
3239 /* Fall back to bounce buffer if write zeroes is unsupported */
3240 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3241 if (iov
.iov_base
== NULL
) {
3242 iov
.iov_base
= qemu_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3243 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3245 qemu_iovec_init_external(&qiov
, &iov
, 1);
3247 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3249 /* Keep bounce buffer around if it is big enough for all
3250 * all future requests.
3252 if (num
< max_write_zeroes
) {
3253 qemu_vfree(iov
.iov_base
);
3254 iov
.iov_base
= NULL
;
3262 qemu_vfree(iov
.iov_base
);
3267 * Forwards an already correctly aligned write request to the BlockDriver.
3269 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3270 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3271 QEMUIOVector
*qiov
, int flags
)
3273 BlockDriver
*drv
= bs
->drv
;
3277 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3278 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3280 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3281 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3283 waited
= wait_serialising_requests(req
);
3284 assert(!waited
|| !req
->serialising
);
3285 assert(req
->overlap_offset
<= offset
);
3286 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3288 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3290 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3291 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3292 qemu_iovec_is_zero(qiov
)) {
3293 flags
|= BDRV_REQ_ZERO_WRITE
;
3294 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3295 flags
|= BDRV_REQ_MAY_UNMAP
;
3300 /* Do nothing, write notifier decided to fail this request */
3301 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3302 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3303 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3305 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3306 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3308 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3310 if (ret
== 0 && !bs
->enable_write_cache
) {
3311 ret
= bdrv_co_flush(bs
);
3314 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3316 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
3317 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
3319 if (bs
->growable
&& ret
>= 0) {
3320 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3327 * Handle a write request in coroutine context
3329 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3330 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3331 BdrvRequestFlags flags
)
3333 BdrvTrackedRequest req
;
3334 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3335 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3336 uint8_t *head_buf
= NULL
;
3337 uint8_t *tail_buf
= NULL
;
3338 QEMUIOVector local_qiov
;
3339 bool use_local_qiov
= false;
3345 if (bs
->read_only
) {
3348 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3352 /* throttling disk I/O */
3353 if (bs
->io_limits_enabled
) {
3354 bdrv_io_limits_intercept(bs
, bytes
, true);
3358 * Align write if necessary by performing a read-modify-write cycle.
3359 * Pad qiov with the read parts and be sure to have a tracked request not
3360 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3362 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3364 if (offset
& (align
- 1)) {
3365 QEMUIOVector head_qiov
;
3366 struct iovec head_iov
;
3368 mark_request_serialising(&req
, align
);
3369 wait_serialising_requests(&req
);
3371 head_buf
= qemu_blockalign(bs
, align
);
3372 head_iov
= (struct iovec
) {
3373 .iov_base
= head_buf
,
3376 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3378 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3379 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3380 align
, &head_qiov
, 0);
3384 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3386 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3387 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3388 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3389 use_local_qiov
= true;
3391 bytes
+= offset
& (align
- 1);
3392 offset
= offset
& ~(align
- 1);
3395 if ((offset
+ bytes
) & (align
- 1)) {
3396 QEMUIOVector tail_qiov
;
3397 struct iovec tail_iov
;
3401 mark_request_serialising(&req
, align
);
3402 waited
= wait_serialising_requests(&req
);
3403 assert(!waited
|| !use_local_qiov
);
3405 tail_buf
= qemu_blockalign(bs
, align
);
3406 tail_iov
= (struct iovec
) {
3407 .iov_base
= tail_buf
,
3410 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3412 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3413 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3414 align
, &tail_qiov
, 0);
3418 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3420 if (!use_local_qiov
) {
3421 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3422 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3423 use_local_qiov
= true;
3426 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3427 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3429 bytes
= ROUND_UP(bytes
, align
);
3432 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3433 use_local_qiov
? &local_qiov
: qiov
,
3437 tracked_request_end(&req
);
3439 if (use_local_qiov
) {
3440 qemu_iovec_destroy(&local_qiov
);
3442 qemu_vfree(head_buf
);
3443 qemu_vfree(tail_buf
);
3448 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3449 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3450 BdrvRequestFlags flags
)
3452 if (nb_sectors
< 0 || nb_sectors
> (INT_MAX
>> BDRV_SECTOR_BITS
)) {
3456 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3457 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3460 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3461 int nb_sectors
, QEMUIOVector
*qiov
)
3463 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3465 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3468 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3469 int64_t sector_num
, int nb_sectors
,
3470 BdrvRequestFlags flags
)
3472 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3474 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3475 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3478 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3479 BDRV_REQ_ZERO_WRITE
| flags
);
3483 * Truncate file to 'offset' bytes (needed only for file protocols)
3485 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3487 BlockDriver
*drv
= bs
->drv
;
3491 if (!drv
->bdrv_truncate
)
3496 ret
= drv
->bdrv_truncate(bs
, offset
);
3498 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3499 bdrv_dev_resize_cb(bs
);
3505 * Length of a allocated file in bytes. Sparse files are counted by actual
3506 * allocated space. Return < 0 if error or unknown.
3508 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3510 BlockDriver
*drv
= bs
->drv
;
3514 if (drv
->bdrv_get_allocated_file_size
) {
3515 return drv
->bdrv_get_allocated_file_size(bs
);
3518 return bdrv_get_allocated_file_size(bs
->file
);
3524 * Length of a file in bytes. Return < 0 if error or unknown.
3526 int64_t bdrv_getlength(BlockDriverState
*bs
)
3528 BlockDriver
*drv
= bs
->drv
;
3532 if (drv
->has_variable_length
) {
3533 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3538 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3541 /* return 0 as number of sectors if no device present or error */
3542 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3545 length
= bdrv_getlength(bs
);
3549 length
= length
>> BDRV_SECTOR_BITS
;
3550 *nb_sectors_ptr
= length
;
3553 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3554 BlockdevOnError on_write_error
)
3556 bs
->on_read_error
= on_read_error
;
3557 bs
->on_write_error
= on_write_error
;
3560 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3562 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3565 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3567 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3570 case BLOCKDEV_ON_ERROR_ENOSPC
:
3571 return (error
== ENOSPC
) ?
3572 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
3573 case BLOCKDEV_ON_ERROR_STOP
:
3574 return BLOCK_ERROR_ACTION_STOP
;
3575 case BLOCKDEV_ON_ERROR_REPORT
:
3576 return BLOCK_ERROR_ACTION_REPORT
;
3577 case BLOCKDEV_ON_ERROR_IGNORE
:
3578 return BLOCK_ERROR_ACTION_IGNORE
;
3584 /* This is done by device models because, while the block layer knows
3585 * about the error, it does not know whether an operation comes from
3586 * the device or the block layer (from a job, for example).
3588 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3589 bool is_read
, int error
)
3593 if (action
== BLOCK_ERROR_ACTION_STOP
) {
3594 /* First set the iostatus, so that "info block" returns an iostatus
3595 * that matches the events raised so far (an additional error iostatus
3596 * is fine, but not a lost one).
3598 bdrv_iostatus_set_err(bs
, error
);
3600 /* Then raise the request to stop the VM and the event.
3601 * qemu_system_vmstop_request_prepare has two effects. First,
3602 * it ensures that the STOP event always comes after the
3603 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3604 * can observe the STOP event and do a "cont" before the STOP
3605 * event is issued, the VM will not stop. In this case, vm_start()
3606 * also ensures that the STOP/RESUME pair of events is emitted.
3608 qemu_system_vmstop_request_prepare();
3609 qapi_event_send_block_io_error(bdrv_get_device_name(bs
),
3610 is_read
? IO_OPERATION_TYPE_READ
:
3611 IO_OPERATION_TYPE_WRITE
,
3612 action
, &error_abort
);
3613 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
3615 qapi_event_send_block_io_error(bdrv_get_device_name(bs
),
3616 is_read
? IO_OPERATION_TYPE_READ
:
3617 IO_OPERATION_TYPE_WRITE
,
3618 action
, &error_abort
);
3622 int bdrv_is_read_only(BlockDriverState
*bs
)
3624 return bs
->read_only
;
3627 int bdrv_is_sg(BlockDriverState
*bs
)
3632 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3634 return bs
->enable_write_cache
;
3637 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3639 bs
->enable_write_cache
= wce
;
3641 /* so a reopen() will preserve wce */
3643 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3645 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3649 int bdrv_is_encrypted(BlockDriverState
*bs
)
3651 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3653 return bs
->encrypted
;
3656 int bdrv_key_required(BlockDriverState
*bs
)
3658 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3660 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3662 return (bs
->encrypted
&& !bs
->valid_key
);
3665 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3668 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3669 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3675 if (!bs
->encrypted
) {
3677 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3680 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3683 } else if (!bs
->valid_key
) {
3685 /* call the change callback now, we skipped it on open */
3686 bdrv_dev_change_media_cb(bs
, true);
3691 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3693 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3696 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3701 const char **formats
= NULL
;
3703 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3704 if (drv
->format_name
) {
3707 while (formats
&& i
&& !found
) {
3708 found
= !strcmp(formats
[--i
], drv
->format_name
);
3712 formats
= g_realloc(formats
, (count
+ 1) * sizeof(char *));
3713 formats
[count
++] = drv
->format_name
;
3714 it(opaque
, drv
->format_name
);
3721 /* This function is to find block backend bs */
3722 BlockDriverState
*bdrv_find(const char *name
)
3724 BlockDriverState
*bs
;
3726 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3727 if (!strcmp(name
, bs
->device_name
)) {
3734 /* This function is to find a node in the bs graph */
3735 BlockDriverState
*bdrv_find_node(const char *node_name
)
3737 BlockDriverState
*bs
;
3741 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3742 if (!strcmp(node_name
, bs
->node_name
)) {
3749 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3750 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3752 BlockDeviceInfoList
*list
, *entry
;
3753 BlockDriverState
*bs
;
3756 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3757 entry
= g_malloc0(sizeof(*entry
));
3758 entry
->value
= bdrv_block_device_info(bs
);
3766 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3767 const char *node_name
,
3770 BlockDriverState
*bs
= NULL
;
3773 bs
= bdrv_find(device
);
3781 bs
= bdrv_find_node(node_name
);
3788 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3789 device
? device
: "",
3790 node_name
? node_name
: "");
3794 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3795 * return false. If either argument is NULL, return false. */
3796 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
3798 while (top
&& top
!= base
) {
3799 top
= top
->backing_hd
;
3805 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3808 return QTAILQ_FIRST(&bdrv_states
);
3810 return QTAILQ_NEXT(bs
, device_list
);
3813 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
3815 BlockDriverState
*bs
;
3817 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3822 const char *bdrv_get_device_name(BlockDriverState
*bs
)
3824 return bs
->device_name
;
3827 int bdrv_get_flags(BlockDriverState
*bs
)
3829 return bs
->open_flags
;
3832 int bdrv_flush_all(void)
3834 BlockDriverState
*bs
;
3837 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3838 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3841 aio_context_acquire(aio_context
);
3842 ret
= bdrv_flush(bs
);
3843 if (ret
< 0 && !result
) {
3846 aio_context_release(aio_context
);
3852 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3857 int bdrv_has_zero_init(BlockDriverState
*bs
)
3861 /* If BS is a copy on write image, it is initialized to
3862 the contents of the base image, which may not be zeroes. */
3863 if (bs
->backing_hd
) {
3866 if (bs
->drv
->bdrv_has_zero_init
) {
3867 return bs
->drv
->bdrv_has_zero_init(bs
);
3874 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3876 BlockDriverInfo bdi
;
3878 if (bs
->backing_hd
) {
3882 if (bdrv_get_info(bs
, &bdi
) == 0) {
3883 return bdi
.unallocated_blocks_are_zero
;
3889 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3891 BlockDriverInfo bdi
;
3893 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3897 if (bdrv_get_info(bs
, &bdi
) == 0) {
3898 return bdi
.can_write_zeroes_with_unmap
;
3904 typedef struct BdrvCoGetBlockStatusData
{
3905 BlockDriverState
*bs
;
3906 BlockDriverState
*base
;
3912 } BdrvCoGetBlockStatusData
;
3915 * Returns true iff the specified sector is present in the disk image. Drivers
3916 * not implementing the functionality are assumed to not support backing files,
3917 * hence all their sectors are reported as allocated.
3919 * If 'sector_num' is beyond the end of the disk image the return value is 0
3920 * and 'pnum' is set to 0.
3922 * 'pnum' is set to the number of sectors (including and immediately following
3923 * the specified sector) that are known to be in the same
3924 * allocated/unallocated state.
3926 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3927 * beyond the end of the disk image it will be clamped.
3929 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
3931 int nb_sectors
, int *pnum
)
3937 length
= bdrv_getlength(bs
);
3942 if (sector_num
>= (length
>> BDRV_SECTOR_BITS
)) {
3947 n
= bs
->total_sectors
- sector_num
;
3948 if (n
< nb_sectors
) {
3952 if (!bs
->drv
->bdrv_co_get_block_status
) {
3954 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
;
3955 if (bs
->drv
->protocol_name
) {
3956 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
3961 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
3967 if (ret
& BDRV_BLOCK_RAW
) {
3968 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
3969 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3973 if (ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ZERO
)) {
3974 ret
|= BDRV_BLOCK_ALLOCATED
;
3977 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
3978 if (bdrv_unallocated_blocks_are_zero(bs
)) {
3979 ret
|= BDRV_BLOCK_ZERO
;
3980 } else if (bs
->backing_hd
) {
3981 BlockDriverState
*bs2
= bs
->backing_hd
;
3982 int64_t length2
= bdrv_getlength(bs2
);
3983 if (length2
>= 0 && sector_num
>= (length2
>> BDRV_SECTOR_BITS
)) {
3984 ret
|= BDRV_BLOCK_ZERO
;
3990 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
3991 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
3992 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3995 /* Ignore errors. This is just providing extra information, it
3996 * is useful but not necessary.
3998 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
4005 /* Coroutine wrapper for bdrv_get_block_status() */
4006 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
4008 BdrvCoGetBlockStatusData
*data
= opaque
;
4009 BlockDriverState
*bs
= data
->bs
;
4011 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
4017 * Synchronous wrapper around bdrv_co_get_block_status().
4019 * See bdrv_co_get_block_status() for details.
4021 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
4022 int nb_sectors
, int *pnum
)
4025 BdrvCoGetBlockStatusData data
= {
4027 .sector_num
= sector_num
,
4028 .nb_sectors
= nb_sectors
,
4033 if (qemu_in_coroutine()) {
4034 /* Fast-path if already in coroutine context */
4035 bdrv_get_block_status_co_entry(&data
);
4037 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4039 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
4040 qemu_coroutine_enter(co
, &data
);
4041 while (!data
.done
) {
4042 aio_poll(aio_context
, true);
4048 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
4049 int nb_sectors
, int *pnum
)
4051 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4055 return !!(ret
& BDRV_BLOCK_ALLOCATED
);
4059 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4061 * Return true if the given sector is allocated in any image between
4062 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4063 * sector is allocated in any image of the chain. Return false otherwise.
4065 * 'pnum' is set to the number of sectors (including and immediately following
4066 * the specified sector) that are known to be in the same
4067 * allocated/unallocated state.
4070 int bdrv_is_allocated_above(BlockDriverState
*top
,
4071 BlockDriverState
*base
,
4073 int nb_sectors
, int *pnum
)
4075 BlockDriverState
*intermediate
;
4076 int ret
, n
= nb_sectors
;
4079 while (intermediate
&& intermediate
!= base
) {
4081 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
4091 * [sector_num, nb_sectors] is unallocated on top but intermediate
4094 * [sector_num+x, nr_sectors] allocated.
4096 if (n
> pnum_inter
&&
4097 (intermediate
== top
||
4098 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
4102 intermediate
= intermediate
->backing_hd
;
4109 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
4111 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
4112 return bs
->backing_file
;
4113 else if (bs
->encrypted
)
4114 return bs
->filename
;
4119 void bdrv_get_backing_filename(BlockDriverState
*bs
,
4120 char *filename
, int filename_size
)
4122 pstrcpy(filename
, filename_size
, bs
->backing_file
);
4125 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
4126 const uint8_t *buf
, int nb_sectors
)
4128 BlockDriver
*drv
= bs
->drv
;
4131 if (!drv
->bdrv_write_compressed
)
4133 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
4136 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
4138 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
4141 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4143 BlockDriver
*drv
= bs
->drv
;
4146 if (!drv
->bdrv_get_info
)
4148 memset(bdi
, 0, sizeof(*bdi
));
4149 return drv
->bdrv_get_info(bs
, bdi
);
4152 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
4154 BlockDriver
*drv
= bs
->drv
;
4155 if (drv
&& drv
->bdrv_get_specific_info
) {
4156 return drv
->bdrv_get_specific_info(bs
);
4161 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4162 int64_t pos
, int size
)
4165 struct iovec iov
= {
4166 .iov_base
= (void *) buf
,
4170 qemu_iovec_init_external(&qiov
, &iov
, 1);
4171 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4174 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4176 BlockDriver
*drv
= bs
->drv
;
4180 } else if (drv
->bdrv_save_vmstate
) {
4181 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4182 } else if (bs
->file
) {
4183 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4189 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4190 int64_t pos
, int size
)
4192 BlockDriver
*drv
= bs
->drv
;
4195 if (drv
->bdrv_load_vmstate
)
4196 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4198 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4202 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4204 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4208 bs
->drv
->bdrv_debug_event(bs
, event
);
4211 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4214 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4218 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4219 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4225 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4227 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4231 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4232 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4238 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4240 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
4244 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4245 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4251 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4253 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4257 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4258 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4264 int bdrv_is_snapshot(BlockDriverState
*bs
)
4266 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4269 /* backing_file can either be relative, or absolute, or a protocol. If it is
4270 * relative, it must be relative to the chain. So, passing in bs->filename
4271 * from a BDS as backing_file should not be done, as that may be relative to
4272 * the CWD rather than the chain. */
4273 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4274 const char *backing_file
)
4276 char *filename_full
= NULL
;
4277 char *backing_file_full
= NULL
;
4278 char *filename_tmp
= NULL
;
4279 int is_protocol
= 0;
4280 BlockDriverState
*curr_bs
= NULL
;
4281 BlockDriverState
*retval
= NULL
;
4283 if (!bs
|| !bs
->drv
|| !backing_file
) {
4287 filename_full
= g_malloc(PATH_MAX
);
4288 backing_file_full
= g_malloc(PATH_MAX
);
4289 filename_tmp
= g_malloc(PATH_MAX
);
4291 is_protocol
= path_has_protocol(backing_file
);
4293 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4295 /* If either of the filename paths is actually a protocol, then
4296 * compare unmodified paths; otherwise make paths relative */
4297 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4298 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4299 retval
= curr_bs
->backing_hd
;
4303 /* If not an absolute filename path, make it relative to the current
4304 * image's filename path */
4305 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4308 /* We are going to compare absolute pathnames */
4309 if (!realpath(filename_tmp
, filename_full
)) {
4313 /* We need to make sure the backing filename we are comparing against
4314 * is relative to the current image filename (or absolute) */
4315 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4316 curr_bs
->backing_file
);
4318 if (!realpath(filename_tmp
, backing_file_full
)) {
4322 if (strcmp(backing_file_full
, filename_full
) == 0) {
4323 retval
= curr_bs
->backing_hd
;
4329 g_free(filename_full
);
4330 g_free(backing_file_full
);
4331 g_free(filename_tmp
);
4335 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4341 if (!bs
->backing_hd
) {
4345 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4348 /**************************************************************/
4351 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4352 QEMUIOVector
*qiov
, int nb_sectors
,
4353 BlockDriverCompletionFunc
*cb
, void *opaque
)
4355 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4357 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4361 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4362 QEMUIOVector
*qiov
, int nb_sectors
,
4363 BlockDriverCompletionFunc
*cb
, void *opaque
)
4365 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4367 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4371 BlockDriverAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4372 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4373 BlockDriverCompletionFunc
*cb
, void *opaque
)
4375 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4377 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4378 BDRV_REQ_ZERO_WRITE
| flags
,
4383 typedef struct MultiwriteCB
{
4388 BlockDriverCompletionFunc
*cb
;
4390 QEMUIOVector
*free_qiov
;
4394 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4398 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4399 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4400 if (mcb
->callbacks
[i
].free_qiov
) {
4401 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4403 g_free(mcb
->callbacks
[i
].free_qiov
);
4407 static void multiwrite_cb(void *opaque
, int ret
)
4409 MultiwriteCB
*mcb
= opaque
;
4411 trace_multiwrite_cb(mcb
, ret
);
4413 if (ret
< 0 && !mcb
->error
) {
4417 mcb
->num_requests
--;
4418 if (mcb
->num_requests
== 0) {
4419 multiwrite_user_cb(mcb
);
4424 static int multiwrite_req_compare(const void *a
, const void *b
)
4426 const BlockRequest
*req1
= a
, *req2
= b
;
4429 * Note that we can't simply subtract req2->sector from req1->sector
4430 * here as that could overflow the return value.
4432 if (req1
->sector
> req2
->sector
) {
4434 } else if (req1
->sector
< req2
->sector
) {
4442 * Takes a bunch of requests and tries to merge them. Returns the number of
4443 * requests that remain after merging.
4445 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4446 int num_reqs
, MultiwriteCB
*mcb
)
4450 // Sort requests by start sector
4451 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4453 // Check if adjacent requests touch the same clusters. If so, combine them,
4454 // filling up gaps with zero sectors.
4456 for (i
= 1; i
< num_reqs
; i
++) {
4458 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4460 // Handle exactly sequential writes and overlapping writes.
4461 if (reqs
[i
].sector
<= oldreq_last
) {
4465 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4471 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4472 qemu_iovec_init(qiov
,
4473 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4475 // Add the first request to the merged one. If the requests are
4476 // overlapping, drop the last sectors of the first request.
4477 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4478 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4480 // We should need to add any zeros between the two requests
4481 assert (reqs
[i
].sector
<= oldreq_last
);
4483 // Add the second request
4484 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4486 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4487 reqs
[outidx
].qiov
= qiov
;
4489 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4492 reqs
[outidx
].sector
= reqs
[i
].sector
;
4493 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4494 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4502 * Submit multiple AIO write requests at once.
4504 * On success, the function returns 0 and all requests in the reqs array have
4505 * been submitted. In error case this function returns -1, and any of the
4506 * requests may or may not be submitted yet. In particular, this means that the
4507 * callback will be called for some of the requests, for others it won't. The
4508 * caller must check the error field of the BlockRequest to wait for the right
4509 * callbacks (if error != 0, no callback will be called).
4511 * The implementation may modify the contents of the reqs array, e.g. to merge
4512 * requests. However, the fields opaque and error are left unmodified as they
4513 * are used to signal failure for a single request to the caller.
4515 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4520 /* don't submit writes if we don't have a medium */
4521 if (bs
->drv
== NULL
) {
4522 for (i
= 0; i
< num_reqs
; i
++) {
4523 reqs
[i
].error
= -ENOMEDIUM
;
4528 if (num_reqs
== 0) {
4532 // Create MultiwriteCB structure
4533 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4534 mcb
->num_requests
= 0;
4535 mcb
->num_callbacks
= num_reqs
;
4537 for (i
= 0; i
< num_reqs
; i
++) {
4538 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4539 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4542 // Check for mergable requests
4543 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4545 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4547 /* Run the aio requests. */
4548 mcb
->num_requests
= num_reqs
;
4549 for (i
= 0; i
< num_reqs
; i
++) {
4550 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4551 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4559 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
4561 acb
->aiocb_info
->cancel(acb
);
4564 /**************************************************************/
4565 /* async block device emulation */
4567 typedef struct BlockDriverAIOCBSync
{
4568 BlockDriverAIOCB common
;
4571 /* vector translation state */
4575 } BlockDriverAIOCBSync
;
4577 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
4579 BlockDriverAIOCBSync
*acb
=
4580 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
4581 qemu_bh_delete(acb
->bh
);
4583 qemu_aio_release(acb
);
4586 static const AIOCBInfo bdrv_em_aiocb_info
= {
4587 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
4588 .cancel
= bdrv_aio_cancel_em
,
4591 static void bdrv_aio_bh_cb(void *opaque
)
4593 BlockDriverAIOCBSync
*acb
= opaque
;
4596 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4597 qemu_vfree(acb
->bounce
);
4598 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4599 qemu_bh_delete(acb
->bh
);
4601 qemu_aio_release(acb
);
4604 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4608 BlockDriverCompletionFunc
*cb
,
4613 BlockDriverAIOCBSync
*acb
;
4615 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4616 acb
->is_write
= is_write
;
4618 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
4619 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_aio_bh_cb
, acb
);
4622 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4623 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4625 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4628 qemu_bh_schedule(acb
->bh
);
4630 return &acb
->common
;
4633 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4634 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4635 BlockDriverCompletionFunc
*cb
, void *opaque
)
4637 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4640 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4641 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4642 BlockDriverCompletionFunc
*cb
, void *opaque
)
4644 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4648 typedef struct BlockDriverAIOCBCoroutine
{
4649 BlockDriverAIOCB common
;
4654 } BlockDriverAIOCBCoroutine
;
4656 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
4658 AioContext
*aio_context
= bdrv_get_aio_context(blockacb
->bs
);
4659 BlockDriverAIOCBCoroutine
*acb
=
4660 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
4665 aio_poll(aio_context
, true);
4669 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4670 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
4671 .cancel
= bdrv_aio_co_cancel_em
,
4674 static void bdrv_co_em_bh(void *opaque
)
4676 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4678 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4684 qemu_bh_delete(acb
->bh
);
4685 qemu_aio_release(acb
);
4688 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4689 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4691 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4692 BlockDriverState
*bs
= acb
->common
.bs
;
4694 if (!acb
->is_write
) {
4695 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4696 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4698 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4699 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4702 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4703 qemu_bh_schedule(acb
->bh
);
4706 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4710 BdrvRequestFlags flags
,
4711 BlockDriverCompletionFunc
*cb
,
4716 BlockDriverAIOCBCoroutine
*acb
;
4718 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4719 acb
->req
.sector
= sector_num
;
4720 acb
->req
.nb_sectors
= nb_sectors
;
4721 acb
->req
.qiov
= qiov
;
4722 acb
->req
.flags
= flags
;
4723 acb
->is_write
= is_write
;
4726 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4727 qemu_coroutine_enter(co
, acb
);
4729 return &acb
->common
;
4732 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4734 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4735 BlockDriverState
*bs
= acb
->common
.bs
;
4737 acb
->req
.error
= bdrv_co_flush(bs
);
4738 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4739 qemu_bh_schedule(acb
->bh
);
4742 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4743 BlockDriverCompletionFunc
*cb
, void *opaque
)
4745 trace_bdrv_aio_flush(bs
, opaque
);
4748 BlockDriverAIOCBCoroutine
*acb
;
4750 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4753 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4754 qemu_coroutine_enter(co
, acb
);
4756 return &acb
->common
;
4759 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4761 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4762 BlockDriverState
*bs
= acb
->common
.bs
;
4764 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4765 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4766 qemu_bh_schedule(acb
->bh
);
4769 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4770 int64_t sector_num
, int nb_sectors
,
4771 BlockDriverCompletionFunc
*cb
, void *opaque
)
4774 BlockDriverAIOCBCoroutine
*acb
;
4776 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4778 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4779 acb
->req
.sector
= sector_num
;
4780 acb
->req
.nb_sectors
= nb_sectors
;
4782 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4783 qemu_coroutine_enter(co
, acb
);
4785 return &acb
->common
;
4788 void bdrv_init(void)
4790 module_call_init(MODULE_INIT_BLOCK
);
4793 void bdrv_init_with_whitelist(void)
4795 use_bdrv_whitelist
= 1;
4799 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4800 BlockDriverCompletionFunc
*cb
, void *opaque
)
4802 BlockDriverAIOCB
*acb
;
4804 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4805 acb
->aiocb_info
= aiocb_info
;
4808 acb
->opaque
= opaque
;
4812 void qemu_aio_release(void *p
)
4814 BlockDriverAIOCB
*acb
= p
;
4815 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4818 /**************************************************************/
4819 /* Coroutine block device emulation */
4821 typedef struct CoroutineIOCompletion
{
4822 Coroutine
*coroutine
;
4824 } CoroutineIOCompletion
;
4826 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4828 CoroutineIOCompletion
*co
= opaque
;
4831 qemu_coroutine_enter(co
->coroutine
, NULL
);
4834 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4835 int nb_sectors
, QEMUIOVector
*iov
,
4838 CoroutineIOCompletion co
= {
4839 .coroutine
= qemu_coroutine_self(),
4841 BlockDriverAIOCB
*acb
;
4844 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4845 bdrv_co_io_em_complete
, &co
);
4847 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4848 bdrv_co_io_em_complete
, &co
);
4851 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4855 qemu_coroutine_yield();
4860 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4861 int64_t sector_num
, int nb_sectors
,
4864 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4867 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4868 int64_t sector_num
, int nb_sectors
,
4871 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4874 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4876 RwCo
*rwco
= opaque
;
4878 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4881 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4885 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4889 /* Write back cached data to the OS even with cache=unsafe */
4890 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4891 if (bs
->drv
->bdrv_co_flush_to_os
) {
4892 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4898 /* But don't actually force it to the disk with cache=unsafe */
4899 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4903 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
4904 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4905 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4906 } else if (bs
->drv
->bdrv_aio_flush
) {
4907 BlockDriverAIOCB
*acb
;
4908 CoroutineIOCompletion co
= {
4909 .coroutine
= qemu_coroutine_self(),
4912 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4916 qemu_coroutine_yield();
4921 * Some block drivers always operate in either writethrough or unsafe
4922 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4923 * know how the server works (because the behaviour is hardcoded or
4924 * depends on server-side configuration), so we can't ensure that
4925 * everything is safe on disk. Returning an error doesn't work because
4926 * that would break guests even if the server operates in writethrough
4929 * Let's hope the user knows what he's doing.
4937 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4938 * in the case of cache=unsafe, so there are no useless flushes.
4941 return bdrv_co_flush(bs
->file
);
4944 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
4946 Error
*local_err
= NULL
;
4953 if (bs
->drv
->bdrv_invalidate_cache
) {
4954 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
4955 } else if (bs
->file
) {
4956 bdrv_invalidate_cache(bs
->file
, &local_err
);
4959 error_propagate(errp
, local_err
);
4963 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
4965 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
4970 void bdrv_invalidate_cache_all(Error
**errp
)
4972 BlockDriverState
*bs
;
4973 Error
*local_err
= NULL
;
4975 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4976 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4978 aio_context_acquire(aio_context
);
4979 bdrv_invalidate_cache(bs
, &local_err
);
4980 aio_context_release(aio_context
);
4982 error_propagate(errp
, local_err
);
4988 void bdrv_clear_incoming_migration_all(void)
4990 BlockDriverState
*bs
;
4992 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4993 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4995 aio_context_acquire(aio_context
);
4996 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4997 aio_context_release(aio_context
);
5001 int bdrv_flush(BlockDriverState
*bs
)
5009 if (qemu_in_coroutine()) {
5010 /* Fast-path if already in coroutine context */
5011 bdrv_flush_co_entry(&rwco
);
5013 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5015 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
5016 qemu_coroutine_enter(co
, &rwco
);
5017 while (rwco
.ret
== NOT_DONE
) {
5018 aio_poll(aio_context
, true);
5025 typedef struct DiscardCo
{
5026 BlockDriverState
*bs
;
5031 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
5033 DiscardCo
*rwco
= opaque
;
5035 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
5038 /* if no limit is specified in the BlockLimits use a default
5039 * of 32768 512-byte sectors (16 MiB) per request.
5041 #define MAX_DISCARD_DEFAULT 32768
5043 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
5050 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
5052 } else if (bs
->read_only
) {
5056 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
5058 /* Do nothing if disabled. */
5059 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
5063 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
5067 max_discard
= bs
->bl
.max_discard
? bs
->bl
.max_discard
: MAX_DISCARD_DEFAULT
;
5068 while (nb_sectors
> 0) {
5070 int num
= nb_sectors
;
5073 if (bs
->bl
.discard_alignment
&&
5074 num
>= bs
->bl
.discard_alignment
&&
5075 sector_num
% bs
->bl
.discard_alignment
) {
5076 if (num
> bs
->bl
.discard_alignment
) {
5077 num
= bs
->bl
.discard_alignment
;
5079 num
-= sector_num
% bs
->bl
.discard_alignment
;
5082 /* limit request size */
5083 if (num
> max_discard
) {
5087 if (bs
->drv
->bdrv_co_discard
) {
5088 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
5090 BlockDriverAIOCB
*acb
;
5091 CoroutineIOCompletion co
= {
5092 .coroutine
= qemu_coroutine_self(),
5095 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
5096 bdrv_co_io_em_complete
, &co
);
5100 qemu_coroutine_yield();
5104 if (ret
&& ret
!= -ENOTSUP
) {
5114 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
5119 .sector_num
= sector_num
,
5120 .nb_sectors
= nb_sectors
,
5124 if (qemu_in_coroutine()) {
5125 /* Fast-path if already in coroutine context */
5126 bdrv_discard_co_entry(&rwco
);
5128 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5130 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
5131 qemu_coroutine_enter(co
, &rwco
);
5132 while (rwco
.ret
== NOT_DONE
) {
5133 aio_poll(aio_context
, true);
5140 /**************************************************************/
5141 /* removable device support */
5144 * Return TRUE if the media is present
5146 int bdrv_is_inserted(BlockDriverState
*bs
)
5148 BlockDriver
*drv
= bs
->drv
;
5152 if (!drv
->bdrv_is_inserted
)
5154 return drv
->bdrv_is_inserted(bs
);
5158 * Return whether the media changed since the last call to this
5159 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5161 int bdrv_media_changed(BlockDriverState
*bs
)
5163 BlockDriver
*drv
= bs
->drv
;
5165 if (drv
&& drv
->bdrv_media_changed
) {
5166 return drv
->bdrv_media_changed(bs
);
5172 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5174 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
5176 BlockDriver
*drv
= bs
->drv
;
5178 if (drv
&& drv
->bdrv_eject
) {
5179 drv
->bdrv_eject(bs
, eject_flag
);
5182 if (bs
->device_name
[0] != '\0') {
5183 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
5184 eject_flag
, &error_abort
);
5189 * Lock or unlock the media (if it is locked, the user won't be able
5190 * to eject it manually).
5192 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5194 BlockDriver
*drv
= bs
->drv
;
5196 trace_bdrv_lock_medium(bs
, locked
);
5198 if (drv
&& drv
->bdrv_lock_medium
) {
5199 drv
->bdrv_lock_medium(bs
, locked
);
5203 /* needed for generic scsi interface */
5205 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5207 BlockDriver
*drv
= bs
->drv
;
5209 if (drv
&& drv
->bdrv_ioctl
)
5210 return drv
->bdrv_ioctl(bs
, req
, buf
);
5214 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5215 unsigned long int req
, void *buf
,
5216 BlockDriverCompletionFunc
*cb
, void *opaque
)
5218 BlockDriver
*drv
= bs
->drv
;
5220 if (drv
&& drv
->bdrv_aio_ioctl
)
5221 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5225 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5227 bs
->guest_block_size
= align
;
5230 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5232 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5236 * Check if all memory in this vector is sector aligned.
5238 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5241 size_t alignment
= bdrv_opt_mem_align(bs
);
5243 for (i
= 0; i
< qiov
->niov
; i
++) {
5244 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5247 if (qiov
->iov
[i
].iov_len
% alignment
) {
5255 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
,
5258 int64_t bitmap_size
;
5259 BdrvDirtyBitmap
*bitmap
;
5261 assert((granularity
& (granularity
- 1)) == 0);
5263 granularity
>>= BDRV_SECTOR_BITS
;
5264 assert(granularity
);
5265 bitmap_size
= bdrv_getlength(bs
);
5266 if (bitmap_size
< 0) {
5267 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
5268 errno
= -bitmap_size
;
5271 bitmap_size
>>= BDRV_SECTOR_BITS
;
5272 bitmap
= g_malloc0(sizeof(BdrvDirtyBitmap
));
5273 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
5274 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5278 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5280 BdrvDirtyBitmap
*bm
, *next
;
5281 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5283 QLIST_REMOVE(bitmap
, list
);
5284 hbitmap_free(bitmap
->bitmap
);
5291 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5293 BdrvDirtyBitmap
*bm
;
5294 BlockDirtyInfoList
*list
= NULL
;
5295 BlockDirtyInfoList
**plist
= &list
;
5297 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5298 BlockDirtyInfo
*info
= g_malloc0(sizeof(BlockDirtyInfo
));
5299 BlockDirtyInfoList
*entry
= g_malloc0(sizeof(BlockDirtyInfoList
));
5300 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5302 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5303 entry
->value
= info
;
5305 plist
= &entry
->next
;
5311 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5314 return hbitmap_get(bitmap
->bitmap
, sector
);
5320 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5321 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5323 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5326 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5329 BdrvDirtyBitmap
*bitmap
;
5330 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5331 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5335 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
, int nr_sectors
)
5337 BdrvDirtyBitmap
*bitmap
;
5338 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5339 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5343 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5345 return hbitmap_count(bitmap
->bitmap
);
5348 /* Get a reference to bs */
5349 void bdrv_ref(BlockDriverState
*bs
)
5354 /* Release a previously grabbed reference to bs.
5355 * If after releasing, reference count is zero, the BlockDriverState is
5357 void bdrv_unref(BlockDriverState
*bs
)
5359 assert(bs
->refcnt
> 0);
5360 if (--bs
->refcnt
== 0) {
5365 struct BdrvOpBlocker
{
5367 QLIST_ENTRY(BdrvOpBlocker
) list
;
5370 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
5372 BdrvOpBlocker
*blocker
;
5373 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5374 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
5375 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
5377 error_setg(errp
, "Device '%s' is busy: %s",
5378 bs
->device_name
, error_get_pretty(blocker
->reason
));
5385 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5387 BdrvOpBlocker
*blocker
;
5388 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5390 blocker
= g_malloc0(sizeof(BdrvOpBlocker
));
5391 blocker
->reason
= reason
;
5392 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
5395 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5397 BdrvOpBlocker
*blocker
, *next
;
5398 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5399 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
5400 if (blocker
->reason
== reason
) {
5401 QLIST_REMOVE(blocker
, list
);
5407 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
5410 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5411 bdrv_op_block(bs
, i
, reason
);
5415 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
5418 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5419 bdrv_op_unblock(bs
, i
, reason
);
5423 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
5427 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5428 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
5435 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5437 bs
->iostatus_enabled
= true;
5438 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5441 /* The I/O status is only enabled if the drive explicitly
5442 * enables it _and_ the VM is configured to stop on errors */
5443 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5445 return (bs
->iostatus_enabled
&&
5446 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5447 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5448 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5451 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5453 bs
->iostatus_enabled
= false;
5456 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5458 if (bdrv_iostatus_is_enabled(bs
)) {
5459 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5461 block_job_iostatus_reset(bs
->job
);
5466 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5468 assert(bdrv_iostatus_is_enabled(bs
));
5469 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5470 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5471 BLOCK_DEVICE_IO_STATUS_FAILED
;
5476 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
5477 enum BlockAcctType type
)
5479 assert(type
< BDRV_MAX_IOTYPE
);
5481 cookie
->bytes
= bytes
;
5482 cookie
->start_time_ns
= get_clock();
5483 cookie
->type
= type
;
5487 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
5489 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
5491 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
5492 bs
->nr_ops
[cookie
->type
]++;
5493 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
5496 void bdrv_img_create(const char *filename
, const char *fmt
,
5497 const char *base_filename
, const char *base_fmt
,
5498 char *options
, uint64_t img_size
, int flags
,
5499 Error
**errp
, bool quiet
)
5501 QemuOptsList
*create_opts
= NULL
;
5502 QemuOpts
*opts
= NULL
;
5503 const char *backing_fmt
, *backing_file
;
5505 BlockDriver
*drv
, *proto_drv
;
5506 BlockDriver
*backing_drv
= NULL
;
5507 Error
*local_err
= NULL
;
5510 /* Find driver and parse its options */
5511 drv
= bdrv_find_format(fmt
);
5513 error_setg(errp
, "Unknown file format '%s'", fmt
);
5517 proto_drv
= bdrv_find_protocol(filename
, true);
5519 error_setg(errp
, "Unknown protocol '%s'", filename
);
5523 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5524 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5526 /* Create parameter list with default values */
5527 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5528 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
);
5530 /* Parse -o options */
5532 if (qemu_opts_do_parse(opts
, options
, NULL
) != 0) {
5533 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
5538 if (base_filename
) {
5539 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
5540 error_setg(errp
, "Backing file not supported for file format '%s'",
5547 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
5548 error_setg(errp
, "Backing file format not supported for file "
5549 "format '%s'", fmt
);
5554 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5556 if (!strcmp(filename
, backing_file
)) {
5557 error_setg(errp
, "Error: Trying to create an image with the "
5558 "same filename as the backing file");
5563 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5565 backing_drv
= bdrv_find_format(backing_fmt
);
5567 error_setg(errp
, "Unknown backing file format '%s'",
5573 // The size for the image must always be specified, with one exception:
5574 // If we are using a backing file, we can obtain the size from there
5575 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5578 BlockDriverState
*bs
;
5582 /* backing files always opened read-only */
5584 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5587 ret
= bdrv_open(&bs
, backing_file
, NULL
, NULL
, back_flags
,
5588 backing_drv
, &local_err
);
5590 error_setg_errno(errp
, -ret
, "Could not open '%s': %s",
5592 error_get_pretty(local_err
));
5593 error_free(local_err
);
5597 bdrv_get_geometry(bs
, &size
);
5600 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
);
5604 error_setg(errp
, "Image creation needs a size parameter");
5610 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
5611 qemu_opts_print(opts
);
5615 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
5617 if (ret
== -EFBIG
) {
5618 /* This is generally a better message than whatever the driver would
5619 * deliver (especially because of the cluster_size_hint), since that
5620 * is most probably not much different from "image too large". */
5621 const char *cluster_size_hint
= "";
5622 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
5623 cluster_size_hint
= " (try using a larger cluster size)";
5625 error_setg(errp
, "The image size is too large for file format '%s'"
5626 "%s", fmt
, cluster_size_hint
);
5627 error_free(local_err
);
5632 qemu_opts_del(opts
);
5633 qemu_opts_free(create_opts
);
5635 error_propagate(errp
, local_err
);
5639 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5641 return bs
->aio_context
;
5644 void bdrv_detach_aio_context(BlockDriverState
*bs
)
5650 if (bs
->io_limits_enabled
) {
5651 throttle_detach_aio_context(&bs
->throttle_state
);
5653 if (bs
->drv
->bdrv_detach_aio_context
) {
5654 bs
->drv
->bdrv_detach_aio_context(bs
);
5657 bdrv_detach_aio_context(bs
->file
);
5659 if (bs
->backing_hd
) {
5660 bdrv_detach_aio_context(bs
->backing_hd
);
5663 bs
->aio_context
= NULL
;
5666 void bdrv_attach_aio_context(BlockDriverState
*bs
,
5667 AioContext
*new_context
)
5673 bs
->aio_context
= new_context
;
5675 if (bs
->backing_hd
) {
5676 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
5679 bdrv_attach_aio_context(bs
->file
, new_context
);
5681 if (bs
->drv
->bdrv_attach_aio_context
) {
5682 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
5684 if (bs
->io_limits_enabled
) {
5685 throttle_attach_aio_context(&bs
->throttle_state
, new_context
);
5689 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
5691 bdrv_drain_all(); /* ensure there are no in-flight requests */
5693 bdrv_detach_aio_context(bs
);
5695 /* This function executes in the old AioContext so acquire the new one in
5696 * case it runs in a different thread.
5698 aio_context_acquire(new_context
);
5699 bdrv_attach_aio_context(bs
, new_context
);
5700 aio_context_release(new_context
);
5703 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
5704 NotifierWithReturn
*notifier
)
5706 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
5709 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
)
5711 if (!bs
->drv
->bdrv_amend_options
) {
5714 return bs
->drv
->bdrv_amend_options(bs
, opts
);
5717 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5718 * of block filter and by bdrv_is_first_non_filter.
5719 * It is used to test if the given bs is the candidate or recurse more in the
5722 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
5723 BlockDriverState
*candidate
)
5725 /* return false if basic checks fails */
5726 if (!bs
|| !bs
->drv
) {
5730 /* the code reached a non block filter driver -> check if the bs is
5731 * the same as the candidate. It's the recursion termination condition.
5733 if (!bs
->drv
->is_filter
) {
5734 return bs
== candidate
;
5736 /* Down this path the driver is a block filter driver */
5738 /* If the block filter recursion method is defined use it to recurse down
5741 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
5742 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
5745 /* the driver is a block filter but don't allow to recurse -> return false
5750 /* This function checks if the candidate is the first non filter bs down it's
5751 * bs chain. Since we don't have pointers to parents it explore all bs chains
5752 * from the top. Some filters can choose not to pass down the recursion.
5754 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
5756 BlockDriverState
*bs
;
5758 /* walk down the bs forest recursively */
5759 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5762 /* try to recurse in this top level bs */
5763 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
5765 /* candidate is the first non filter */
5774 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
5776 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
5777 if (!to_replace_bs
) {
5778 error_setg(errp
, "Node name '%s' not found", node_name
);
5782 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
5786 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5787 * most non filter in order to prevent data corruption.
5788 * Another benefit is that this tests exclude backing files which are
5789 * blocked by the backing blockers.
5791 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
5792 error_setg(errp
, "Only top most non filter can be replaced");
5796 return to_replace_bs
;
5799 void bdrv_io_plug(BlockDriverState
*bs
)
5801 BlockDriver
*drv
= bs
->drv
;
5802 if (drv
&& drv
->bdrv_io_plug
) {
5803 drv
->bdrv_io_plug(bs
);
5804 } else if (bs
->file
) {
5805 bdrv_io_plug(bs
->file
);
5809 void bdrv_io_unplug(BlockDriverState
*bs
)
5811 BlockDriver
*drv
= bs
->drv
;
5812 if (drv
&& drv
->bdrv_io_unplug
) {
5813 drv
->bdrv_io_unplug(bs
);
5814 } else if (bs
->file
) {
5815 bdrv_io_unplug(bs
->file
);
5819 void bdrv_flush_io_queue(BlockDriverState
*bs
)
5821 BlockDriver
*drv
= bs
->drv
;
5822 if (drv
&& drv
->bdrv_flush_io_queue
) {
5823 drv
->bdrv_flush_io_queue(bs
);
5824 } else if (bs
->file
) {
5825 bdrv_flush_io_queue(bs
->file
);