2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
27 #include "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
38 #include "qapi-event.h"
41 #include <sys/types.h>
43 #include <sys/ioctl.h>
44 #include <sys/queue.h>
54 struct BdrvDirtyBitmap
{
56 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
59 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
61 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
62 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
63 BlockCompletionFunc
*cb
, void *opaque
);
64 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
65 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
66 BlockCompletionFunc
*cb
, void *opaque
);
67 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
68 int64_t sector_num
, int nb_sectors
,
70 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
71 int64_t sector_num
, int nb_sectors
,
73 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
74 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
75 BdrvRequestFlags flags
);
76 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
77 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
78 BdrvRequestFlags flags
);
79 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
83 BdrvRequestFlags flags
,
84 BlockCompletionFunc
*cb
,
87 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
88 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
89 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
91 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
92 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
94 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
97 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
98 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
100 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
102 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
104 /* If non-zero, use only whitelisted block drivers */
105 static int use_bdrv_whitelist
;
108 static int is_windows_drive_prefix(const char *filename
)
110 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
111 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
115 int is_windows_drive(const char *filename
)
117 if (is_windows_drive_prefix(filename
) &&
120 if (strstart(filename
, "\\\\.\\", NULL
) ||
121 strstart(filename
, "//./", NULL
))
127 /* throttling disk I/O limits */
128 void bdrv_set_io_limits(BlockDriverState
*bs
,
133 throttle_config(&bs
->throttle_state
, cfg
);
135 for (i
= 0; i
< 2; i
++) {
136 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
140 /* this function drain all the throttled IOs */
141 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
143 bool drained
= false;
144 bool enabled
= bs
->io_limits_enabled
;
147 bs
->io_limits_enabled
= false;
149 for (i
= 0; i
< 2; i
++) {
150 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
155 bs
->io_limits_enabled
= enabled
;
160 void bdrv_io_limits_disable(BlockDriverState
*bs
)
162 bs
->io_limits_enabled
= false;
164 bdrv_start_throttled_reqs(bs
);
166 throttle_destroy(&bs
->throttle_state
);
169 static void bdrv_throttle_read_timer_cb(void *opaque
)
171 BlockDriverState
*bs
= opaque
;
172 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
175 static void bdrv_throttle_write_timer_cb(void *opaque
)
177 BlockDriverState
*bs
= opaque
;
178 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
181 /* should be called before bdrv_set_io_limits if a limit is set */
182 void bdrv_io_limits_enable(BlockDriverState
*bs
)
184 assert(!bs
->io_limits_enabled
);
185 throttle_init(&bs
->throttle_state
,
186 bdrv_get_aio_context(bs
),
188 bdrv_throttle_read_timer_cb
,
189 bdrv_throttle_write_timer_cb
,
191 bs
->io_limits_enabled
= true;
194 /* This function makes an IO wait if needed
196 * @nb_sectors: the number of sectors of the IO
197 * @is_write: is the IO a write
199 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
203 /* does this io must wait */
204 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
206 /* if must wait or any request of this type throttled queue the IO */
208 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
209 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
212 /* the IO will be executed, do the accounting */
213 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
216 /* if the next request must wait -> do nothing */
217 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
221 /* else queue next request for execution */
222 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
225 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
227 if (!bs
|| !bs
->drv
) {
228 /* 4k should be on the safe side */
232 return bs
->bl
.opt_mem_alignment
;
235 /* check if the path starts with "<protocol>:" */
236 int path_has_protocol(const char *path
)
241 if (is_windows_drive(path
) ||
242 is_windows_drive_prefix(path
)) {
245 p
= path
+ strcspn(path
, ":/\\");
247 p
= path
+ strcspn(path
, ":/");
253 int path_is_absolute(const char *path
)
256 /* specific case for names like: "\\.\d:" */
257 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
260 return (*path
== '/' || *path
== '\\');
262 return (*path
== '/');
266 /* if filename is absolute, just copy it to dest. Otherwise, build a
267 path to it by considering it is relative to base_path. URL are
269 void path_combine(char *dest
, int dest_size
,
270 const char *base_path
,
271 const char *filename
)
278 if (path_is_absolute(filename
)) {
279 pstrcpy(dest
, dest_size
, filename
);
281 p
= strchr(base_path
, ':');
286 p1
= strrchr(base_path
, '/');
290 p2
= strrchr(base_path
, '\\');
302 if (len
> dest_size
- 1)
304 memcpy(dest
, base_path
, len
);
306 pstrcat(dest
, dest_size
, filename
);
310 void bdrv_get_full_backing_filename_from_filename(const char *backed
,
312 char *dest
, size_t sz
,
315 if (backing
[0] == '\0' || path_has_protocol(backing
) ||
316 path_is_absolute(backing
))
318 pstrcpy(dest
, sz
, backing
);
319 } else if (backed
[0] == '\0' || strstart(backed
, "json:", NULL
)) {
320 error_setg(errp
, "Cannot use relative backing file names for '%s'",
323 path_combine(dest
, sz
, backed
, backing
);
327 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
,
330 char *backed
= bs
->exact_filename
[0] ? bs
->exact_filename
: bs
->filename
;
332 bdrv_get_full_backing_filename_from_filename(backed
, bs
->backing_file
,
336 void bdrv_register(BlockDriver
*bdrv
)
338 /* Block drivers without coroutine functions need emulation */
339 if (!bdrv
->bdrv_co_readv
) {
340 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
341 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
343 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
344 * the block driver lacks aio we need to emulate that too.
346 if (!bdrv
->bdrv_aio_readv
) {
347 /* add AIO emulation layer */
348 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
349 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
353 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
356 BlockDriverState
*bdrv_new_root(void)
358 BlockDriverState
*bs
= bdrv_new();
360 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
364 BlockDriverState
*bdrv_new(void)
366 BlockDriverState
*bs
;
369 bs
= g_new0(BlockDriverState
, 1);
370 QLIST_INIT(&bs
->dirty_bitmaps
);
371 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
372 QLIST_INIT(&bs
->op_blockers
[i
]);
374 bdrv_iostatus_disable(bs
);
375 notifier_list_init(&bs
->close_notifiers
);
376 notifier_with_return_list_init(&bs
->before_write_notifiers
);
377 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
378 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
380 bs
->aio_context
= qemu_get_aio_context();
385 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
387 notifier_list_add(&bs
->close_notifiers
, notify
);
390 BlockDriver
*bdrv_find_format(const char *format_name
)
393 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
394 if (!strcmp(drv1
->format_name
, format_name
)) {
401 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
403 static const char *whitelist_rw
[] = {
404 CONFIG_BDRV_RW_WHITELIST
406 static const char *whitelist_ro
[] = {
407 CONFIG_BDRV_RO_WHITELIST
411 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
412 return 1; /* no whitelist, anything goes */
415 for (p
= whitelist_rw
; *p
; p
++) {
416 if (!strcmp(drv
->format_name
, *p
)) {
421 for (p
= whitelist_ro
; *p
; p
++) {
422 if (!strcmp(drv
->format_name
, *p
)) {
430 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
433 BlockDriver
*drv
= bdrv_find_format(format_name
);
434 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
437 typedef struct CreateCo
{
445 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
447 Error
*local_err
= NULL
;
450 CreateCo
*cco
= opaque
;
453 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
455 error_propagate(&cco
->err
, local_err
);
460 int bdrv_create(BlockDriver
*drv
, const char* filename
,
461 QemuOpts
*opts
, Error
**errp
)
468 .filename
= g_strdup(filename
),
474 if (!drv
->bdrv_create
) {
475 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
480 if (qemu_in_coroutine()) {
481 /* Fast-path if already in coroutine context */
482 bdrv_create_co_entry(&cco
);
484 co
= qemu_coroutine_create(bdrv_create_co_entry
);
485 qemu_coroutine_enter(co
, &cco
);
486 while (cco
.ret
== NOT_DONE
) {
487 aio_poll(qemu_get_aio_context(), true);
494 error_propagate(errp
, cco
.err
);
496 error_setg_errno(errp
, -ret
, "Could not create image");
501 g_free(cco
.filename
);
505 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
508 Error
*local_err
= NULL
;
511 drv
= bdrv_find_protocol(filename
, true, errp
);
516 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
518 error_propagate(errp
, local_err
);
523 void bdrv_refresh_limits(BlockDriverState
*bs
, Error
**errp
)
525 BlockDriver
*drv
= bs
->drv
;
526 Error
*local_err
= NULL
;
528 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
534 /* Take some limits from the children as a default */
536 bdrv_refresh_limits(bs
->file
, &local_err
);
538 error_propagate(errp
, local_err
);
541 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
542 bs
->bl
.max_transfer_length
= bs
->file
->bl
.max_transfer_length
;
543 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
545 bs
->bl
.opt_mem_alignment
= 512;
548 if (bs
->backing_hd
) {
549 bdrv_refresh_limits(bs
->backing_hd
, &local_err
);
551 error_propagate(errp
, local_err
);
554 bs
->bl
.opt_transfer_length
=
555 MAX(bs
->bl
.opt_transfer_length
,
556 bs
->backing_hd
->bl
.opt_transfer_length
);
557 bs
->bl
.max_transfer_length
=
558 MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
559 bs
->backing_hd
->bl
.max_transfer_length
);
560 bs
->bl
.opt_mem_alignment
=
561 MAX(bs
->bl
.opt_mem_alignment
,
562 bs
->backing_hd
->bl
.opt_mem_alignment
);
565 /* Then let the driver override it */
566 if (drv
->bdrv_refresh_limits
) {
567 drv
->bdrv_refresh_limits(bs
, errp
);
572 * Create a uniquely-named empty temporary file.
573 * Return 0 upon success, otherwise a negative errno value.
575 int get_tmp_filename(char *filename
, int size
)
578 char temp_dir
[MAX_PATH
];
579 /* GetTempFileName requires that its output buffer (4th param)
580 have length MAX_PATH or greater. */
581 assert(size
>= MAX_PATH
);
582 return (GetTempPath(MAX_PATH
, temp_dir
)
583 && GetTempFileName(temp_dir
, "qem", 0, filename
)
584 ? 0 : -GetLastError());
588 tmpdir
= getenv("TMPDIR");
592 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
595 fd
= mkstemp(filename
);
599 if (close(fd
) != 0) {
608 * Detect host devices. By convention, /dev/cdrom[N] is always
609 * recognized as a host CDROM.
611 static BlockDriver
*find_hdev_driver(const char *filename
)
613 int score_max
= 0, score
;
614 BlockDriver
*drv
= NULL
, *d
;
616 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
617 if (d
->bdrv_probe_device
) {
618 score
= d
->bdrv_probe_device(filename
);
619 if (score
> score_max
) {
629 BlockDriver
*bdrv_find_protocol(const char *filename
,
630 bool allow_protocol_prefix
,
638 /* TODO Drivers without bdrv_file_open must be specified explicitly */
641 * XXX(hch): we really should not let host device detection
642 * override an explicit protocol specification, but moving this
643 * later breaks access to device names with colons in them.
644 * Thanks to the brain-dead persistent naming schemes on udev-
645 * based Linux systems those actually are quite common.
647 drv1
= find_hdev_driver(filename
);
652 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
656 p
= strchr(filename
, ':');
659 if (len
> sizeof(protocol
) - 1)
660 len
= sizeof(protocol
) - 1;
661 memcpy(protocol
, filename
, len
);
662 protocol
[len
] = '\0';
663 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
664 if (drv1
->protocol_name
&&
665 !strcmp(drv1
->protocol_name
, protocol
)) {
670 error_setg(errp
, "Unknown protocol '%s'", protocol
);
675 * Guess image format by probing its contents.
676 * This is not a good idea when your image is raw (CVE-2008-2004), but
677 * we do it anyway for backward compatibility.
679 * @buf contains the image's first @buf_size bytes.
680 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE,
681 * but can be smaller if the image file is smaller)
682 * @filename is its filename.
684 * For all block drivers, call the bdrv_probe() method to get its
686 * Return the first block driver with the highest probing score.
688 BlockDriver
*bdrv_probe_all(const uint8_t *buf
, int buf_size
,
689 const char *filename
)
691 int score_max
= 0, score
;
692 BlockDriver
*drv
= NULL
, *d
;
694 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
696 score
= d
->bdrv_probe(buf
, buf_size
, filename
);
697 if (score
> score_max
) {
707 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
708 BlockDriver
**pdrv
, Error
**errp
)
711 uint8_t buf
[BLOCK_PROBE_BUF_SIZE
];
714 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
715 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
720 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
722 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
728 drv
= bdrv_probe_all(buf
, ret
, filename
);
730 error_setg(errp
, "Could not determine image format: No compatible "
739 * Set the current 'total_sectors' value
740 * Return 0 on success, -errno on error.
742 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
744 BlockDriver
*drv
= bs
->drv
;
746 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
750 /* query actual device if possible, otherwise just trust the hint */
751 if (drv
->bdrv_getlength
) {
752 int64_t length
= drv
->bdrv_getlength(bs
);
756 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
759 bs
->total_sectors
= hint
;
764 * Set open flags for a given discard mode
766 * Return 0 on success, -1 if the discard mode was invalid.
768 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
770 *flags
&= ~BDRV_O_UNMAP
;
772 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
774 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
775 *flags
|= BDRV_O_UNMAP
;
784 * Set open flags for a given cache mode
786 * Return 0 on success, -1 if the cache mode was invalid.
788 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
790 *flags
&= ~BDRV_O_CACHE_MASK
;
792 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
793 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
794 } else if (!strcmp(mode
, "directsync")) {
795 *flags
|= BDRV_O_NOCACHE
;
796 } else if (!strcmp(mode
, "writeback")) {
797 *flags
|= BDRV_O_CACHE_WB
;
798 } else if (!strcmp(mode
, "unsafe")) {
799 *flags
|= BDRV_O_CACHE_WB
;
800 *flags
|= BDRV_O_NO_FLUSH
;
801 } else if (!strcmp(mode
, "writethrough")) {
802 /* this is the default */
811 * The copy-on-read flag is actually a reference count so multiple users may
812 * use the feature without worrying about clobbering its previous state.
813 * Copy-on-read stays enabled until all users have called to disable it.
815 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
820 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
822 assert(bs
->copy_on_read
> 0);
827 * Returns the flags that a temporary snapshot should get, based on the
828 * originally requested flags (the originally requested image will have flags
829 * like a backing file)
831 static int bdrv_temp_snapshot_flags(int flags
)
833 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
837 * Returns the flags that bs->file should get, based on the given flags for
840 static int bdrv_inherited_flags(int flags
)
842 /* Enable protocol handling, disable format probing for bs->file */
843 flags
|= BDRV_O_PROTOCOL
;
845 /* Our block drivers take care to send flushes and respect unmap policy,
846 * so we can enable both unconditionally on lower layers. */
847 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
849 /* Clear flags that only apply to the top layer */
850 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
856 * Returns the flags that bs->backing_hd should get, based on the given flags
859 static int bdrv_backing_flags(int flags
)
861 /* backing files always opened read-only */
862 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
864 /* snapshot=on is handled on the top layer */
865 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
870 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
872 int open_flags
= flags
| BDRV_O_CACHE_WB
;
875 * Clear flags that are internal to the block layer before opening the
878 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_PROTOCOL
);
881 * Snapshots should be writable.
883 if (flags
& BDRV_O_TEMPORARY
) {
884 open_flags
|= BDRV_O_RDWR
;
890 static void bdrv_assign_node_name(BlockDriverState
*bs
,
891 const char *node_name
,
898 /* Check for empty string or invalid characters */
899 if (!id_wellformed(node_name
)) {
900 error_setg(errp
, "Invalid node name");
904 /* takes care of avoiding namespaces collisions */
905 if (blk_by_name(node_name
)) {
906 error_setg(errp
, "node-name=%s is conflicting with a device id",
911 /* takes care of avoiding duplicates node names */
912 if (bdrv_find_node(node_name
)) {
913 error_setg(errp
, "Duplicate node name");
917 /* copy node name into the bs and insert it into the graph list */
918 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
919 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
923 * Common part for opening disk images and files
925 * Removes all processed options from *options.
927 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
928 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
931 const char *filename
;
932 const char *node_name
= NULL
;
933 Error
*local_err
= NULL
;
936 assert(bs
->file
== NULL
);
937 assert(options
!= NULL
&& bs
->options
!= options
);
940 filename
= file
->filename
;
942 filename
= qdict_get_try_str(options
, "filename");
945 if (drv
->bdrv_needs_filename
&& !filename
) {
946 error_setg(errp
, "The '%s' block driver requires a file name",
951 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
953 node_name
= qdict_get_try_str(options
, "node-name");
954 bdrv_assign_node_name(bs
, node_name
, &local_err
);
956 error_propagate(errp
, local_err
);
959 qdict_del(options
, "node-name");
961 /* bdrv_open() with directly using a protocol as drv. This layer is already
962 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
963 * and return immediately. */
964 if (file
!= NULL
&& drv
->bdrv_file_open
) {
969 bs
->open_flags
= flags
;
970 bs
->guest_block_size
= 512;
971 bs
->request_alignment
= 512;
972 bs
->zero_beyond_eof
= true;
973 open_flags
= bdrv_open_flags(bs
, flags
);
974 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
976 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
978 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
979 ? "Driver '%s' can only be used for read-only devices"
980 : "Driver '%s' is not whitelisted",
985 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
986 if (flags
& BDRV_O_COPY_ON_READ
) {
987 if (!bs
->read_only
) {
988 bdrv_enable_copy_on_read(bs
);
990 error_setg(errp
, "Can't use copy-on-read on read-only device");
995 if (filename
!= NULL
) {
996 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
998 bs
->filename
[0] = '\0';
1000 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
), bs
->filename
);
1003 bs
->opaque
= g_malloc0(drv
->instance_size
);
1005 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
1007 /* Open the image, either directly or using a protocol */
1008 if (drv
->bdrv_file_open
) {
1009 assert(file
== NULL
);
1010 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
1011 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
1014 error_setg(errp
, "Can't use '%s' as a block driver for the "
1015 "protocol level", drv
->format_name
);
1020 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
1025 error_propagate(errp
, local_err
);
1026 } else if (bs
->filename
[0]) {
1027 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
1029 error_setg_errno(errp
, -ret
, "Could not open image");
1034 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
1036 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
1040 bdrv_refresh_limits(bs
, &local_err
);
1042 error_propagate(errp
, local_err
);
1047 assert(bdrv_opt_mem_align(bs
) != 0);
1048 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1059 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1061 QObject
*options_obj
;
1065 ret
= strstart(filename
, "json:", &filename
);
1068 options_obj
= qobject_from_json(filename
);
1070 error_setg(errp
, "Could not parse the JSON options");
1074 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1075 qobject_decref(options_obj
);
1076 error_setg(errp
, "Invalid JSON object given");
1080 options
= qobject_to_qdict(options_obj
);
1081 qdict_flatten(options
);
1087 * Fills in default options for opening images and converts the legacy
1088 * filename/flags pair to option QDict entries.
1090 static int bdrv_fill_options(QDict
**options
, const char **pfilename
, int flags
,
1091 BlockDriver
*drv
, Error
**errp
)
1093 const char *filename
= *pfilename
;
1094 const char *drvname
;
1095 bool protocol
= flags
& BDRV_O_PROTOCOL
;
1096 bool parse_filename
= false;
1097 Error
*local_err
= NULL
;
1099 /* Parse json: pseudo-protocol */
1100 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1101 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1103 error_propagate(errp
, local_err
);
1107 /* Options given in the filename have lower priority than options
1108 * specified directly */
1109 qdict_join(*options
, json_options
, false);
1110 QDECREF(json_options
);
1111 *pfilename
= filename
= NULL
;
1114 /* Fetch the file name from the options QDict if necessary */
1115 if (protocol
&& filename
) {
1116 if (!qdict_haskey(*options
, "filename")) {
1117 qdict_put(*options
, "filename", qstring_from_str(filename
));
1118 parse_filename
= true;
1120 error_setg(errp
, "Can't specify 'file' and 'filename' options at "
1126 /* Find the right block driver */
1127 filename
= qdict_get_try_str(*options
, "filename");
1128 drvname
= qdict_get_try_str(*options
, "driver");
1132 error_setg(errp
, "Driver specified twice");
1135 drvname
= drv
->format_name
;
1136 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1138 if (!drvname
&& protocol
) {
1140 drv
= bdrv_find_protocol(filename
, parse_filename
, errp
);
1145 drvname
= drv
->format_name
;
1146 qdict_put(*options
, "driver", qstring_from_str(drvname
));
1148 error_setg(errp
, "Must specify either driver or file");
1151 } else if (drvname
) {
1152 drv
= bdrv_find_format(drvname
);
1154 error_setg(errp
, "Unknown driver '%s'", drvname
);
1160 assert(drv
|| !protocol
);
1162 /* Driver-specific filename parsing */
1163 if (drv
&& drv
->bdrv_parse_filename
&& parse_filename
) {
1164 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1166 error_propagate(errp
, local_err
);
1170 if (!drv
->bdrv_needs_filename
) {
1171 qdict_del(*options
, "filename");
1178 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1181 if (bs
->backing_hd
) {
1182 assert(bs
->backing_blocker
);
1183 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1184 } else if (backing_hd
) {
1185 error_setg(&bs
->backing_blocker
,
1186 "device is used as backing hd of '%s'",
1187 bdrv_get_device_name(bs
));
1190 bs
->backing_hd
= backing_hd
;
1192 error_free(bs
->backing_blocker
);
1193 bs
->backing_blocker
= NULL
;
1196 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1197 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1198 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1199 backing_hd
->drv
? backing_hd
->drv
->format_name
: "");
1201 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1202 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1203 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
,
1204 bs
->backing_blocker
);
1206 bdrv_refresh_limits(bs
, NULL
);
1210 * Opens the backing file for a BlockDriverState if not yet open
1212 * options is a QDict of options to pass to the block drivers, or NULL for an
1213 * empty set of options. The reference to the QDict is transferred to this
1214 * function (even on failure), so if the caller intends to reuse the dictionary,
1215 * it needs to use QINCREF() before calling bdrv_file_open.
1217 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1219 char *backing_filename
= g_malloc0(PATH_MAX
);
1221 BlockDriverState
*backing_hd
;
1222 Error
*local_err
= NULL
;
1224 if (bs
->backing_hd
!= NULL
) {
1229 /* NULL means an empty set of options */
1230 if (options
== NULL
) {
1231 options
= qdict_new();
1234 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1235 if (qdict_haskey(options
, "file.filename")) {
1236 backing_filename
[0] = '\0';
1237 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1241 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
,
1245 error_propagate(errp
, local_err
);
1251 if (!bs
->drv
|| !bs
->drv
->supports_backing
) {
1253 error_setg(errp
, "Driver doesn't support backing files");
1258 backing_hd
= bdrv_new();
1260 if (bs
->backing_format
[0] != '\0' && !qdict_haskey(options
, "driver")) {
1261 qdict_put(options
, "driver", qstring_from_str(bs
->backing_format
));
1264 assert(bs
->backing_hd
== NULL
);
1265 ret
= bdrv_open(&backing_hd
,
1266 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1267 bdrv_backing_flags(bs
->open_flags
), NULL
, &local_err
);
1269 bdrv_unref(backing_hd
);
1271 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1272 error_setg(errp
, "Could not open backing file: %s",
1273 error_get_pretty(local_err
));
1274 error_free(local_err
);
1277 bdrv_set_backing_hd(bs
, backing_hd
);
1280 g_free(backing_filename
);
1285 * Opens a disk image whose options are given as BlockdevRef in another block
1288 * If allow_none is true, no image will be opened if filename is false and no
1289 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1291 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1292 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1293 * itself, all options starting with "${bdref_key}." are considered part of the
1296 * The BlockdevRef will be removed from the options QDict.
1298 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1300 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1301 QDict
*options
, const char *bdref_key
, int flags
,
1302 bool allow_none
, Error
**errp
)
1304 QDict
*image_options
;
1306 char *bdref_key_dot
;
1307 const char *reference
;
1310 assert(*pbs
== NULL
);
1312 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1313 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1314 g_free(bdref_key_dot
);
1316 reference
= qdict_get_try_str(options
, bdref_key
);
1317 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1321 error_setg(errp
, "A block device must be specified for \"%s\"",
1325 QDECREF(image_options
);
1329 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1332 qdict_del(options
, bdref_key
);
1336 int bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1338 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1339 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1341 QemuOpts
*opts
= NULL
;
1342 QDict
*snapshot_options
;
1343 BlockDriverState
*bs_snapshot
;
1347 /* if snapshot, we create a temporary backing file and open it
1348 instead of opening 'filename' directly */
1350 /* Get the required size from the image */
1351 total_size
= bdrv_getlength(bs
);
1352 if (total_size
< 0) {
1354 error_setg_errno(errp
, -total_size
, "Could not get image size");
1358 /* Create the temporary image */
1359 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1361 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1365 opts
= qemu_opts_create(bdrv_qcow2
.create_opts
, NULL
, 0,
1367 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
);
1368 ret
= bdrv_create(&bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1369 qemu_opts_del(opts
);
1371 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1372 "'%s': %s", tmp_filename
,
1373 error_get_pretty(local_err
));
1374 error_free(local_err
);
1378 /* Prepare a new options QDict for the temporary file */
1379 snapshot_options
= qdict_new();
1380 qdict_put(snapshot_options
, "file.driver",
1381 qstring_from_str("file"));
1382 qdict_put(snapshot_options
, "file.filename",
1383 qstring_from_str(tmp_filename
));
1385 bs_snapshot
= bdrv_new();
1387 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1388 flags
, &bdrv_qcow2
, &local_err
);
1390 error_propagate(errp
, local_err
);
1394 bdrv_append(bs_snapshot
, bs
);
1397 g_free(tmp_filename
);
1402 * Opens a disk image (raw, qcow2, vmdk, ...)
1404 * options is a QDict of options to pass to the block drivers, or NULL for an
1405 * empty set of options. The reference to the QDict belongs to the block layer
1406 * after the call (even on failure), so if the caller intends to reuse the
1407 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1409 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1410 * If it is not NULL, the referenced BDS will be reused.
1412 * The reference parameter may be used to specify an existing block device which
1413 * should be opened. If specified, neither options nor a filename may be given,
1414 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1416 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1417 const char *reference
, QDict
*options
, int flags
,
1418 BlockDriver
*drv
, Error
**errp
)
1421 BlockDriverState
*file
= NULL
, *bs
;
1422 const char *drvname
;
1423 Error
*local_err
= NULL
;
1424 int snapshot_flags
= 0;
1429 bool options_non_empty
= options
? qdict_size(options
) : false;
1433 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1434 "another block device");
1438 if (filename
|| options_non_empty
) {
1439 error_setg(errp
, "Cannot reference an existing block device with "
1440 "additional options or a new filename");
1444 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1459 /* NULL means an empty set of options */
1460 if (options
== NULL
) {
1461 options
= qdict_new();
1464 ret
= bdrv_fill_options(&options
, &filename
, flags
, drv
, &local_err
);
1469 /* Find the right image format driver */
1471 drvname
= qdict_get_try_str(options
, "driver");
1473 drv
= bdrv_find_format(drvname
);
1474 qdict_del(options
, "driver");
1476 error_setg(errp
, "Unknown driver: '%s'", drvname
);
1482 assert(drvname
|| !(flags
& BDRV_O_PROTOCOL
));
1483 if (drv
&& !drv
->bdrv_file_open
) {
1484 /* If the user explicitly wants a format driver here, we'll need to add
1485 * another layer for the protocol in bs->file */
1486 flags
&= ~BDRV_O_PROTOCOL
;
1489 bs
->options
= options
;
1490 options
= qdict_clone_shallow(options
);
1492 /* Open image file without format layer */
1493 if ((flags
& BDRV_O_PROTOCOL
) == 0) {
1494 if (flags
& BDRV_O_RDWR
) {
1495 flags
|= BDRV_O_ALLOW_RDWR
;
1497 if (flags
& BDRV_O_SNAPSHOT
) {
1498 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1499 flags
= bdrv_backing_flags(flags
);
1502 assert(file
== NULL
);
1503 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1504 bdrv_inherited_flags(flags
),
1511 /* Image format probing */
1514 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1519 error_setg(errp
, "Must specify either driver or file");
1524 /* Open the image */
1525 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1530 if (file
&& (bs
->file
!= file
)) {
1535 /* If there is a backing file, use it */
1536 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1537 QDict
*backing_options
;
1539 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1540 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1542 goto close_and_fail
;
1546 bdrv_refresh_filename(bs
);
1548 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1549 * temporary snapshot afterwards. */
1550 if (snapshot_flags
) {
1551 ret
= bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1553 goto close_and_fail
;
1557 /* Check if any unknown options were used */
1558 if (options
&& (qdict_size(options
) != 0)) {
1559 const QDictEntry
*entry
= qdict_first(options
);
1560 if (flags
& BDRV_O_PROTOCOL
) {
1561 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1562 "'%s'", drv
->format_name
, entry
->key
);
1564 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1565 "support the option '%s'", drv
->format_name
,
1566 bdrv_get_device_name(bs
), entry
->key
);
1570 goto close_and_fail
;
1573 if (!bdrv_key_required(bs
)) {
1575 blk_dev_change_media_cb(bs
->blk
, true);
1577 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1578 && !runstate_check(RUN_STATE_INMIGRATE
)
1579 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1581 "Guest must be stopped for opening of encrypted image");
1583 goto close_and_fail
;
1594 QDECREF(bs
->options
);
1598 /* If *pbs is NULL, a new BDS has been created in this function and
1599 needs to be freed now. Otherwise, it does not need to be closed,
1600 since it has not really been opened yet. */
1604 error_propagate(errp
, local_err
);
1609 /* See fail path, but now the BDS has to be always closed */
1617 error_propagate(errp
, local_err
);
1622 typedef struct BlockReopenQueueEntry
{
1624 BDRVReopenState state
;
1625 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1626 } BlockReopenQueueEntry
;
1629 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1630 * reopen of multiple devices.
1632 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1633 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1634 * be created and initialized. This newly created BlockReopenQueue should be
1635 * passed back in for subsequent calls that are intended to be of the same
1638 * bs is the BlockDriverState to add to the reopen queue.
1640 * flags contains the open flags for the associated bs
1642 * returns a pointer to bs_queue, which is either the newly allocated
1643 * bs_queue, or the existing bs_queue being used.
1646 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1647 BlockDriverState
*bs
, int flags
)
1651 BlockReopenQueueEntry
*bs_entry
;
1652 if (bs_queue
== NULL
) {
1653 bs_queue
= g_new0(BlockReopenQueue
, 1);
1654 QSIMPLEQ_INIT(bs_queue
);
1657 /* bdrv_open() masks this flag out */
1658 flags
&= ~BDRV_O_PROTOCOL
;
1661 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1664 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1665 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1667 bs_entry
->state
.bs
= bs
;
1668 bs_entry
->state
.flags
= flags
;
1674 * Reopen multiple BlockDriverStates atomically & transactionally.
1676 * The queue passed in (bs_queue) must have been built up previous
1677 * via bdrv_reopen_queue().
1679 * Reopens all BDS specified in the queue, with the appropriate
1680 * flags. All devices are prepared for reopen, and failure of any
1681 * device will cause all device changes to be abandonded, and intermediate
1684 * If all devices prepare successfully, then the changes are committed
1688 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1691 BlockReopenQueueEntry
*bs_entry
, *next
;
1692 Error
*local_err
= NULL
;
1694 assert(bs_queue
!= NULL
);
1698 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1699 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1700 error_propagate(errp
, local_err
);
1703 bs_entry
->prepared
= true;
1706 /* If we reach this point, we have success and just need to apply the
1709 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1710 bdrv_reopen_commit(&bs_entry
->state
);
1716 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1717 if (ret
&& bs_entry
->prepared
) {
1718 bdrv_reopen_abort(&bs_entry
->state
);
1727 /* Reopen a single BlockDriverState with the specified flags. */
1728 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1731 Error
*local_err
= NULL
;
1732 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1734 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1735 if (local_err
!= NULL
) {
1736 error_propagate(errp
, local_err
);
1743 * Prepares a BlockDriverState for reopen. All changes are staged in the
1744 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1745 * the block driver layer .bdrv_reopen_prepare()
1747 * bs is the BlockDriverState to reopen
1748 * flags are the new open flags
1749 * queue is the reopen queue
1751 * Returns 0 on success, non-zero on error. On error errp will be set
1754 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1755 * It is the responsibility of the caller to then call the abort() or
1756 * commit() for any other BDS that have been left in a prepare() state
1759 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1763 Error
*local_err
= NULL
;
1766 assert(reopen_state
!= NULL
);
1767 assert(reopen_state
->bs
->drv
!= NULL
);
1768 drv
= reopen_state
->bs
->drv
;
1770 /* if we are to stay read-only, do not allow permission change
1772 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1773 reopen_state
->flags
& BDRV_O_RDWR
) {
1774 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1775 bdrv_get_device_name(reopen_state
->bs
));
1780 ret
= bdrv_flush(reopen_state
->bs
);
1782 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1787 if (drv
->bdrv_reopen_prepare
) {
1788 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1790 if (local_err
!= NULL
) {
1791 error_propagate(errp
, local_err
);
1793 error_setg(errp
, "failed while preparing to reopen image '%s'",
1794 reopen_state
->bs
->filename
);
1799 /* It is currently mandatory to have a bdrv_reopen_prepare()
1800 * handler for each supported drv. */
1801 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1802 drv
->format_name
, bdrv_get_device_name(reopen_state
->bs
),
1803 "reopening of file");
1815 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1816 * makes them final by swapping the staging BlockDriverState contents into
1817 * the active BlockDriverState contents.
1819 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1823 assert(reopen_state
!= NULL
);
1824 drv
= reopen_state
->bs
->drv
;
1825 assert(drv
!= NULL
);
1827 /* If there are any driver level actions to take */
1828 if (drv
->bdrv_reopen_commit
) {
1829 drv
->bdrv_reopen_commit(reopen_state
);
1832 /* set BDS specific flags now */
1833 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1834 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1836 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1838 bdrv_refresh_limits(reopen_state
->bs
, NULL
);
1842 * Abort the reopen, and delete and free the staged changes in
1845 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1849 assert(reopen_state
!= NULL
);
1850 drv
= reopen_state
->bs
->drv
;
1851 assert(drv
!= NULL
);
1853 if (drv
->bdrv_reopen_abort
) {
1854 drv
->bdrv_reopen_abort(reopen_state
);
1859 void bdrv_close(BlockDriverState
*bs
)
1861 BdrvAioNotifier
*ban
, *ban_next
;
1864 block_job_cancel_sync(bs
->job
);
1866 bdrv_drain_all(); /* complete I/O */
1868 bdrv_drain_all(); /* in case flush left pending I/O */
1869 notifier_list_notify(&bs
->close_notifiers
, bs
);
1872 if (bs
->backing_hd
) {
1873 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1874 bdrv_set_backing_hd(bs
, NULL
);
1875 bdrv_unref(backing_hd
);
1877 bs
->drv
->bdrv_close(bs
);
1881 bs
->copy_on_read
= 0;
1882 bs
->backing_file
[0] = '\0';
1883 bs
->backing_format
[0] = '\0';
1884 bs
->total_sectors
= 0;
1888 bs
->zero_beyond_eof
= false;
1889 QDECREF(bs
->options
);
1891 QDECREF(bs
->full_open_options
);
1892 bs
->full_open_options
= NULL
;
1894 if (bs
->file
!= NULL
) {
1895 bdrv_unref(bs
->file
);
1901 blk_dev_change_media_cb(bs
->blk
, false);
1904 /*throttling disk I/O limits*/
1905 if (bs
->io_limits_enabled
) {
1906 bdrv_io_limits_disable(bs
);
1909 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
1912 QLIST_INIT(&bs
->aio_notifiers
);
1915 void bdrv_close_all(void)
1917 BlockDriverState
*bs
;
1919 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1920 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1922 aio_context_acquire(aio_context
);
1924 aio_context_release(aio_context
);
1928 /* Check if any requests are in-flight (including throttled requests) */
1929 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1931 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1934 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1937 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1940 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1943 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1949 static bool bdrv_drain_one(BlockDriverState
*bs
)
1953 bdrv_flush_io_queue(bs
);
1954 bdrv_start_throttled_reqs(bs
);
1955 bs_busy
= bdrv_requests_pending(bs
);
1956 bs_busy
|= aio_poll(bdrv_get_aio_context(bs
), bs_busy
);
1961 * Wait for pending requests to complete on a single BlockDriverState subtree
1963 * See the warning in bdrv_drain_all(). This function can only be called if
1964 * you are sure nothing can generate I/O because you have op blockers
1967 * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState
1970 void bdrv_drain(BlockDriverState
*bs
)
1972 while (bdrv_drain_one(bs
)) {
1973 /* Keep iterating */
1978 * Wait for pending requests to complete across all BlockDriverStates
1980 * This function does not flush data to disk, use bdrv_flush_all() for that
1981 * after calling this function.
1983 * Note that completion of an asynchronous I/O operation can trigger any
1984 * number of other I/O operations on other devices---for example a coroutine
1985 * can be arbitrarily complex and a constant flow of I/O can come until the
1986 * coroutine is complete. Because of this, it is not possible to have a
1987 * function to drain a single device's I/O queue.
1989 void bdrv_drain_all(void)
1991 /* Always run first iteration so any pending completion BHs run */
1993 BlockDriverState
*bs
;
1998 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1999 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2001 aio_context_acquire(aio_context
);
2002 busy
|= bdrv_drain_one(bs
);
2003 aio_context_release(aio_context
);
2008 /* make a BlockDriverState anonymous by removing from bdrv_state and
2009 * graph_bdrv_state list.
2010 Also, NULL terminate the device_name to prevent double remove */
2011 void bdrv_make_anon(BlockDriverState
*bs
)
2014 * Take care to remove bs from bdrv_states only when it's actually
2015 * in it. Note that bs->device_list.tqe_prev is initially null,
2016 * and gets set to non-null by QTAILQ_INSERT_TAIL(). Establish
2017 * the useful invariant "bs in bdrv_states iff bs->tqe_prev" by
2018 * resetting it to null on remove.
2020 if (bs
->device_list
.tqe_prev
) {
2021 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
2022 bs
->device_list
.tqe_prev
= NULL
;
2024 if (bs
->node_name
[0] != '\0') {
2025 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
2027 bs
->node_name
[0] = '\0';
2030 static void bdrv_rebind(BlockDriverState
*bs
)
2032 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
2033 bs
->drv
->bdrv_rebind(bs
);
2037 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
2038 BlockDriverState
*bs_src
)
2040 /* move some fields that need to stay attached to the device */
2043 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
2044 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
2046 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
2048 /* i/o throttled req */
2049 memcpy(&bs_dest
->throttle_state
,
2050 &bs_src
->throttle_state
,
2051 sizeof(ThrottleState
));
2052 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
2053 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
2054 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
2057 bs_dest
->on_read_error
= bs_src
->on_read_error
;
2058 bs_dest
->on_write_error
= bs_src
->on_write_error
;
2061 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
2062 bs_dest
->iostatus
= bs_src
->iostatus
;
2065 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
2067 /* reference count */
2068 bs_dest
->refcnt
= bs_src
->refcnt
;
2071 bs_dest
->job
= bs_src
->job
;
2073 /* keep the same entry in bdrv_states */
2074 bs_dest
->device_list
= bs_src
->device_list
;
2075 bs_dest
->blk
= bs_src
->blk
;
2077 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
2078 sizeof(bs_dest
->op_blockers
));
2082 * Swap bs contents for two image chains while they are live,
2083 * while keeping required fields on the BlockDriverState that is
2084 * actually attached to a device.
2086 * This will modify the BlockDriverState fields, and swap contents
2087 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2089 * bs_new must not be attached to a BlockBackend.
2091 * This function does not create any image files.
2093 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2095 BlockDriverState tmp
;
2097 /* The code needs to swap the node_name but simply swapping node_list won't
2098 * work so first remove the nodes from the graph list, do the swap then
2099 * insert them back if needed.
2101 if (bs_new
->node_name
[0] != '\0') {
2102 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2104 if (bs_old
->node_name
[0] != '\0') {
2105 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2108 /* bs_new must be unattached and shouldn't have anything fancy enabled */
2109 assert(!bs_new
->blk
);
2110 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2111 assert(bs_new
->job
== NULL
);
2112 assert(bs_new
->io_limits_enabled
== false);
2113 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2119 /* there are some fields that should not be swapped, move them back */
2120 bdrv_move_feature_fields(&tmp
, bs_old
);
2121 bdrv_move_feature_fields(bs_old
, bs_new
);
2122 bdrv_move_feature_fields(bs_new
, &tmp
);
2124 /* bs_new must remain unattached */
2125 assert(!bs_new
->blk
);
2127 /* Check a few fields that should remain attached to the device */
2128 assert(bs_new
->job
== NULL
);
2129 assert(bs_new
->io_limits_enabled
== false);
2130 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2132 /* insert the nodes back into the graph node list if needed */
2133 if (bs_new
->node_name
[0] != '\0') {
2134 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2136 if (bs_old
->node_name
[0] != '\0') {
2137 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2140 bdrv_rebind(bs_new
);
2141 bdrv_rebind(bs_old
);
2145 * Add new bs contents at the top of an image chain while the chain is
2146 * live, while keeping required fields on the top layer.
2148 * This will modify the BlockDriverState fields, and swap contents
2149 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2151 * bs_new must not be attached to a BlockBackend.
2153 * This function does not create any image files.
2155 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2157 bdrv_swap(bs_new
, bs_top
);
2159 /* The contents of 'tmp' will become bs_top, as we are
2160 * swapping bs_new and bs_top contents. */
2161 bdrv_set_backing_hd(bs_top
, bs_new
);
2164 static void bdrv_delete(BlockDriverState
*bs
)
2167 assert(bdrv_op_blocker_is_empty(bs
));
2168 assert(!bs
->refcnt
);
2169 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2173 /* remove from list, if necessary */
2180 * Run consistency checks on an image
2182 * Returns 0 if the check could be completed (it doesn't mean that the image is
2183 * free of errors) or -errno when an internal error occurred. The results of the
2184 * check are stored in res.
2186 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2188 if (bs
->drv
== NULL
) {
2191 if (bs
->drv
->bdrv_check
== NULL
) {
2195 memset(res
, 0, sizeof(*res
));
2196 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2199 #define COMMIT_BUF_SECTORS 2048
2201 /* commit COW file into the raw image */
2202 int bdrv_commit(BlockDriverState
*bs
)
2204 BlockDriver
*drv
= bs
->drv
;
2205 int64_t sector
, total_sectors
, length
, backing_length
;
2206 int n
, ro
, open_flags
;
2208 uint8_t *buf
= NULL
;
2213 if (!bs
->backing_hd
) {
2217 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT_SOURCE
, NULL
) ||
2218 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT_TARGET
, NULL
)) {
2222 ro
= bs
->backing_hd
->read_only
;
2223 open_flags
= bs
->backing_hd
->open_flags
;
2226 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2231 length
= bdrv_getlength(bs
);
2237 backing_length
= bdrv_getlength(bs
->backing_hd
);
2238 if (backing_length
< 0) {
2239 ret
= backing_length
;
2243 /* If our top snapshot is larger than the backing file image,
2244 * grow the backing file image if possible. If not possible,
2245 * we must return an error */
2246 if (length
> backing_length
) {
2247 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2253 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2255 /* qemu_try_blockalign() for bs will choose an alignment that works for
2256 * bs->backing_hd as well, so no need to compare the alignment manually. */
2257 buf
= qemu_try_blockalign(bs
, COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2263 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2264 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2269 ret
= bdrv_read(bs
, sector
, buf
, n
);
2274 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2281 if (drv
->bdrv_make_empty
) {
2282 ret
= drv
->bdrv_make_empty(bs
);
2290 * Make sure all data we wrote to the backing device is actually
2293 if (bs
->backing_hd
) {
2294 bdrv_flush(bs
->backing_hd
);
2302 /* ignoring error return here */
2303 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2309 int bdrv_commit_all(void)
2311 BlockDriverState
*bs
;
2313 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2314 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2316 aio_context_acquire(aio_context
);
2317 if (bs
->drv
&& bs
->backing_hd
) {
2318 int ret
= bdrv_commit(bs
);
2320 aio_context_release(aio_context
);
2324 aio_context_release(aio_context
);
2330 * Remove an active request from the tracked requests list
2332 * This function should be called when a tracked request is completing.
2334 static void tracked_request_end(BdrvTrackedRequest
*req
)
2336 if (req
->serialising
) {
2337 req
->bs
->serialising_in_flight
--;
2340 QLIST_REMOVE(req
, list
);
2341 qemu_co_queue_restart_all(&req
->wait_queue
);
2345 * Add an active request to the tracked requests list
2347 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2348 BlockDriverState
*bs
,
2350 unsigned int bytes
, bool is_write
)
2352 *req
= (BdrvTrackedRequest
){
2356 .is_write
= is_write
,
2357 .co
= qemu_coroutine_self(),
2358 .serialising
= false,
2359 .overlap_offset
= offset
,
2360 .overlap_bytes
= bytes
,
2363 qemu_co_queue_init(&req
->wait_queue
);
2365 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2368 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2370 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2371 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2374 if (!req
->serialising
) {
2375 req
->bs
->serialising_in_flight
++;
2376 req
->serialising
= true;
2379 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2380 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2384 * Round a region to cluster boundaries
2386 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2387 int64_t sector_num
, int nb_sectors
,
2388 int64_t *cluster_sector_num
,
2389 int *cluster_nb_sectors
)
2391 BlockDriverInfo bdi
;
2393 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2394 *cluster_sector_num
= sector_num
;
2395 *cluster_nb_sectors
= nb_sectors
;
2397 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2398 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2399 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2404 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2406 BlockDriverInfo bdi
;
2409 ret
= bdrv_get_info(bs
, &bdi
);
2410 if (ret
< 0 || bdi
.cluster_size
== 0) {
2411 return bs
->request_alignment
;
2413 return bdi
.cluster_size
;
2417 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2418 int64_t offset
, unsigned int bytes
)
2421 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2425 if (req
->overlap_offset
>= offset
+ bytes
) {
2431 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2433 BlockDriverState
*bs
= self
->bs
;
2434 BdrvTrackedRequest
*req
;
2436 bool waited
= false;
2438 if (!bs
->serialising_in_flight
) {
2444 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2445 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2448 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2449 self
->overlap_bytes
))
2451 /* Hitting this means there was a reentrant request, for
2452 * example, a block driver issuing nested requests. This must
2453 * never happen since it means deadlock.
2455 assert(qemu_coroutine_self() != req
->co
);
2457 /* If the request is already (indirectly) waiting for us, or
2458 * will wait for us as soon as it wakes up, then just go on
2459 * (instead of producing a deadlock in the former case). */
2460 if (!req
->waiting_for
) {
2461 self
->waiting_for
= req
;
2462 qemu_co_queue_wait(&req
->wait_queue
);
2463 self
->waiting_for
= NULL
;
2478 * -EINVAL - backing format specified, but no file
2479 * -ENOSPC - can't update the backing file because no space is left in the
2481 * -ENOTSUP - format driver doesn't support changing the backing file
2483 int bdrv_change_backing_file(BlockDriverState
*bs
,
2484 const char *backing_file
, const char *backing_fmt
)
2486 BlockDriver
*drv
= bs
->drv
;
2489 /* Backing file format doesn't make sense without a backing file */
2490 if (backing_fmt
&& !backing_file
) {
2494 if (drv
->bdrv_change_backing_file
!= NULL
) {
2495 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2501 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2502 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2508 * Finds the image layer in the chain that has 'bs' as its backing file.
2510 * active is the current topmost image.
2512 * Returns NULL if bs is not found in active's image chain,
2513 * or if active == bs.
2515 * Returns the bottommost base image if bs == NULL.
2517 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2518 BlockDriverState
*bs
)
2520 while (active
&& bs
!= active
->backing_hd
) {
2521 active
= active
->backing_hd
;
2527 /* Given a BDS, searches for the base layer. */
2528 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
2530 return bdrv_find_overlay(bs
, NULL
);
2533 typedef struct BlkIntermediateStates
{
2534 BlockDriverState
*bs
;
2535 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2536 } BlkIntermediateStates
;
2540 * Drops images above 'base' up to and including 'top', and sets the image
2541 * above 'top' to have base as its backing file.
2543 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2544 * information in 'bs' can be properly updated.
2546 * E.g., this will convert the following chain:
2547 * bottom <- base <- intermediate <- top <- active
2551 * bottom <- base <- active
2553 * It is allowed for bottom==base, in which case it converts:
2555 * base <- intermediate <- top <- active
2561 * If backing_file_str is non-NULL, it will be used when modifying top's
2562 * overlay image metadata.
2565 * if active == top, that is considered an error
2568 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2569 BlockDriverState
*base
, const char *backing_file_str
)
2571 BlockDriverState
*intermediate
;
2572 BlockDriverState
*base_bs
= NULL
;
2573 BlockDriverState
*new_top_bs
= NULL
;
2574 BlkIntermediateStates
*intermediate_state
, *next
;
2577 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2578 QSIMPLEQ_INIT(&states_to_delete
);
2580 if (!top
->drv
|| !base
->drv
) {
2584 new_top_bs
= bdrv_find_overlay(active
, top
);
2586 if (new_top_bs
== NULL
) {
2587 /* we could not find the image above 'top', this is an error */
2591 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2592 * to do, no intermediate images */
2593 if (new_top_bs
->backing_hd
== base
) {
2600 /* now we will go down through the list, and add each BDS we find
2601 * into our deletion queue, until we hit the 'base'
2603 while (intermediate
) {
2604 intermediate_state
= g_new0(BlkIntermediateStates
, 1);
2605 intermediate_state
->bs
= intermediate
;
2606 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2608 if (intermediate
->backing_hd
== base
) {
2609 base_bs
= intermediate
->backing_hd
;
2612 intermediate
= intermediate
->backing_hd
;
2614 if (base_bs
== NULL
) {
2615 /* something went wrong, we did not end at the base. safely
2616 * unravel everything, and exit with error */
2620 /* success - we can delete the intermediate states, and link top->base */
2621 backing_file_str
= backing_file_str
? backing_file_str
: base_bs
->filename
;
2622 ret
= bdrv_change_backing_file(new_top_bs
, backing_file_str
,
2623 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2627 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2629 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2630 /* so that bdrv_close() does not recursively close the chain */
2631 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2632 bdrv_unref(intermediate_state
->bs
);
2637 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2638 g_free(intermediate_state
);
2644 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2647 if (size
> BDRV_REQUEST_MAX_SECTORS
<< BDRV_SECTOR_BITS
) {
2651 if (!bdrv_is_inserted(bs
)) {
2662 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2665 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2669 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2670 nb_sectors
* BDRV_SECTOR_SIZE
);
2673 typedef struct RwCo
{
2674 BlockDriverState
*bs
;
2679 BdrvRequestFlags flags
;
2682 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2684 RwCo
*rwco
= opaque
;
2686 if (!rwco
->is_write
) {
2687 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2688 rwco
->qiov
->size
, rwco
->qiov
,
2691 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2692 rwco
->qiov
->size
, rwco
->qiov
,
2698 * Process a vectored synchronous request using coroutines
2700 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2701 QEMUIOVector
*qiov
, bool is_write
,
2702 BdrvRequestFlags flags
)
2709 .is_write
= is_write
,
2715 * In sync call context, when the vcpu is blocked, this throttling timer
2716 * will not fire; so the I/O throttling function has to be disabled here
2717 * if it has been enabled.
2719 if (bs
->io_limits_enabled
) {
2720 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2721 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2722 bdrv_io_limits_disable(bs
);
2725 if (qemu_in_coroutine()) {
2726 /* Fast-path if already in coroutine context */
2727 bdrv_rw_co_entry(&rwco
);
2729 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2731 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2732 qemu_coroutine_enter(co
, &rwco
);
2733 while (rwco
.ret
== NOT_DONE
) {
2734 aio_poll(aio_context
, true);
2741 * Process a synchronous request using coroutines
2743 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2744 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2747 struct iovec iov
= {
2748 .iov_base
= (void *)buf
,
2749 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2752 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
2756 qemu_iovec_init_external(&qiov
, &iov
, 1);
2757 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2758 &qiov
, is_write
, flags
);
2761 /* return < 0 if error. See bdrv_write() for the return codes */
2762 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2763 uint8_t *buf
, int nb_sectors
)
2765 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2768 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2769 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2770 uint8_t *buf
, int nb_sectors
)
2775 enabled
= bs
->io_limits_enabled
;
2776 bs
->io_limits_enabled
= false;
2777 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2778 bs
->io_limits_enabled
= enabled
;
2782 /* Return < 0 if error. Important errors are:
2783 -EIO generic I/O error (may happen for all errors)
2784 -ENOMEDIUM No media inserted.
2785 -EINVAL Invalid sector number or nb_sectors
2786 -EACCES Trying to write a read-only device
2788 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2789 const uint8_t *buf
, int nb_sectors
)
2791 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2794 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2795 int nb_sectors
, BdrvRequestFlags flags
)
2797 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2798 BDRV_REQ_ZERO_WRITE
| flags
);
2802 * Completely zero out a block device with the help of bdrv_write_zeroes.
2803 * The operation is sped up by checking the block status and only writing
2804 * zeroes to the device if they currently do not return zeroes. Optional
2805 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2807 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2809 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2811 int64_t target_sectors
, ret
, nb_sectors
, sector_num
= 0;
2814 target_sectors
= bdrv_nb_sectors(bs
);
2815 if (target_sectors
< 0) {
2816 return target_sectors
;
2820 nb_sectors
= MIN(target_sectors
- sector_num
, BDRV_REQUEST_MAX_SECTORS
);
2821 if (nb_sectors
<= 0) {
2824 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2826 error_report("error getting block status at sector %" PRId64
": %s",
2827 sector_num
, strerror(-ret
));
2830 if (ret
& BDRV_BLOCK_ZERO
) {
2834 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2836 error_report("error writing zeroes at sector %" PRId64
": %s",
2837 sector_num
, strerror(-ret
));
2844 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2847 struct iovec iov
= {
2848 .iov_base
= (void *)buf
,
2857 qemu_iovec_init_external(&qiov
, &iov
, 1);
2858 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2866 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2870 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2878 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2879 const void *buf
, int bytes
)
2882 struct iovec iov
= {
2883 .iov_base
= (void *) buf
,
2891 qemu_iovec_init_external(&qiov
, &iov
, 1);
2892 return bdrv_pwritev(bs
, offset
, &qiov
);
2896 * Writes to the file and ensures that no writes are reordered across this
2897 * request (acts as a barrier)
2899 * Returns 0 on success, -errno in error cases.
2901 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2902 const void *buf
, int count
)
2906 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2911 /* No flush needed for cache modes that already do it */
2912 if (bs
->enable_write_cache
) {
2919 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2920 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2922 /* Perform I/O through a temporary buffer so that users who scribble over
2923 * their read buffer while the operation is in progress do not end up
2924 * modifying the image file. This is critical for zero-copy guest I/O
2925 * where anything might happen inside guest memory.
2927 void *bounce_buffer
;
2929 BlockDriver
*drv
= bs
->drv
;
2931 QEMUIOVector bounce_qiov
;
2932 int64_t cluster_sector_num
;
2933 int cluster_nb_sectors
;
2937 /* Cover entire cluster so no additional backing file I/O is required when
2938 * allocating cluster in the image file.
2940 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2941 &cluster_sector_num
, &cluster_nb_sectors
);
2943 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2944 cluster_sector_num
, cluster_nb_sectors
);
2946 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2947 iov
.iov_base
= bounce_buffer
= qemu_try_blockalign(bs
, iov
.iov_len
);
2948 if (bounce_buffer
== NULL
) {
2953 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2955 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2961 if (drv
->bdrv_co_write_zeroes
&&
2962 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2963 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2964 cluster_nb_sectors
, 0);
2966 /* This does not change the data on the disk, it is not necessary
2967 * to flush even in cache=writethrough mode.
2969 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2974 /* It might be okay to ignore write errors for guest requests. If this
2975 * is a deliberate copy-on-read then we don't want to ignore the error.
2976 * Simply report it in all cases.
2981 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2982 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2983 nb_sectors
* BDRV_SECTOR_SIZE
);
2986 qemu_vfree(bounce_buffer
);
2991 * Forwards an already correctly aligned request to the BlockDriver. This
2992 * handles copy on read and zeroing after EOF; any other features must be
2993 * implemented by the caller.
2995 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
2996 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
2997 int64_t align
, QEMUIOVector
*qiov
, int flags
)
2999 BlockDriver
*drv
= bs
->drv
;
3002 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3003 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3005 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3006 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3007 assert(!qiov
|| bytes
== qiov
->size
);
3009 /* Handle Copy on Read and associated serialisation */
3010 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3011 /* If we touch the same cluster it counts as an overlap. This
3012 * guarantees that allocating writes will be serialized and not race
3013 * with each other for the same cluster. For example, in copy-on-read
3014 * it ensures that the CoR read and write operations are atomic and
3015 * guest writes cannot interleave between them. */
3016 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3019 wait_serialising_requests(req
);
3021 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3024 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3029 if (!ret
|| pnum
!= nb_sectors
) {
3030 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3035 /* Forward the request to the BlockDriver */
3036 if (!bs
->zero_beyond_eof
) {
3037 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3039 /* Read zeros after EOF */
3040 int64_t total_sectors
, max_nb_sectors
;
3042 total_sectors
= bdrv_nb_sectors(bs
);
3043 if (total_sectors
< 0) {
3044 ret
= total_sectors
;
3048 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3049 align
>> BDRV_SECTOR_BITS
);
3050 if (nb_sectors
< max_nb_sectors
) {
3051 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3052 } else if (max_nb_sectors
> 0) {
3053 QEMUIOVector local_qiov
;
3055 qemu_iovec_init(&local_qiov
, qiov
->niov
);
3056 qemu_iovec_concat(&local_qiov
, qiov
, 0,
3057 max_nb_sectors
* BDRV_SECTOR_SIZE
);
3059 ret
= drv
->bdrv_co_readv(bs
, sector_num
, max_nb_sectors
,
3062 qemu_iovec_destroy(&local_qiov
);
3067 /* Reading beyond end of file is supposed to produce zeroes */
3068 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3069 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3070 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3072 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3081 * Handle a read request in coroutine context
3083 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3084 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3085 BdrvRequestFlags flags
)
3087 BlockDriver
*drv
= bs
->drv
;
3088 BdrvTrackedRequest req
;
3090 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3091 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3092 uint8_t *head_buf
= NULL
;
3093 uint8_t *tail_buf
= NULL
;
3094 QEMUIOVector local_qiov
;
3095 bool use_local_qiov
= false;
3101 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3105 if (bs
->copy_on_read
) {
3106 flags
|= BDRV_REQ_COPY_ON_READ
;
3109 /* throttling disk I/O */
3110 if (bs
->io_limits_enabled
) {
3111 bdrv_io_limits_intercept(bs
, bytes
, false);
3114 /* Align read if necessary by padding qiov */
3115 if (offset
& (align
- 1)) {
3116 head_buf
= qemu_blockalign(bs
, align
);
3117 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3118 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3119 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3120 use_local_qiov
= true;
3122 bytes
+= offset
& (align
- 1);
3123 offset
= offset
& ~(align
- 1);
3126 if ((offset
+ bytes
) & (align
- 1)) {
3127 if (!use_local_qiov
) {
3128 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3129 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3130 use_local_qiov
= true;
3132 tail_buf
= qemu_blockalign(bs
, align
);
3133 qemu_iovec_add(&local_qiov
, tail_buf
,
3134 align
- ((offset
+ bytes
) & (align
- 1)));
3136 bytes
= ROUND_UP(bytes
, align
);
3139 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3140 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3141 use_local_qiov
? &local_qiov
: qiov
,
3143 tracked_request_end(&req
);
3145 if (use_local_qiov
) {
3146 qemu_iovec_destroy(&local_qiov
);
3147 qemu_vfree(head_buf
);
3148 qemu_vfree(tail_buf
);
3154 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3155 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3156 BdrvRequestFlags flags
)
3158 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3162 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3163 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3166 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3167 int nb_sectors
, QEMUIOVector
*qiov
)
3169 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3171 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3174 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3175 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3177 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3179 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3180 BDRV_REQ_COPY_ON_READ
);
3183 #define MAX_WRITE_ZEROES_BOUNCE_BUFFER 32768
3185 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3186 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3188 BlockDriver
*drv
= bs
->drv
;
3190 struct iovec iov
= {0};
3193 int max_write_zeroes
= MIN_NON_ZERO(bs
->bl
.max_write_zeroes
,
3194 BDRV_REQUEST_MAX_SECTORS
);
3196 while (nb_sectors
> 0 && !ret
) {
3197 int num
= nb_sectors
;
3199 /* Align request. Block drivers can expect the "bulk" of the request
3202 if (bs
->bl
.write_zeroes_alignment
3203 && num
> bs
->bl
.write_zeroes_alignment
) {
3204 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3205 /* Make a small request up to the first aligned sector. */
3206 num
= bs
->bl
.write_zeroes_alignment
;
3207 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3208 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3209 /* Shorten the request to the last aligned sector. num cannot
3210 * underflow because num > bs->bl.write_zeroes_alignment.
3212 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3216 /* limit request size */
3217 if (num
> max_write_zeroes
) {
3218 num
= max_write_zeroes
;
3222 /* First try the efficient write zeroes operation */
3223 if (drv
->bdrv_co_write_zeroes
) {
3224 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3227 if (ret
== -ENOTSUP
) {
3228 /* Fall back to bounce buffer if write zeroes is unsupported */
3229 int max_xfer_len
= MIN_NON_ZERO(bs
->bl
.max_transfer_length
,
3230 MAX_WRITE_ZEROES_BOUNCE_BUFFER
);
3231 num
= MIN(num
, max_xfer_len
);
3232 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3233 if (iov
.iov_base
== NULL
) {
3234 iov
.iov_base
= qemu_try_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3235 if (iov
.iov_base
== NULL
) {
3239 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3241 qemu_iovec_init_external(&qiov
, &iov
, 1);
3243 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3245 /* Keep bounce buffer around if it is big enough for all
3246 * all future requests.
3248 if (num
< max_xfer_len
) {
3249 qemu_vfree(iov
.iov_base
);
3250 iov
.iov_base
= NULL
;
3259 qemu_vfree(iov
.iov_base
);
3264 * Forwards an already correctly aligned write request to the BlockDriver.
3266 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3267 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3268 QEMUIOVector
*qiov
, int flags
)
3270 BlockDriver
*drv
= bs
->drv
;
3274 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3275 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3277 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3278 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3279 assert(!qiov
|| bytes
== qiov
->size
);
3281 waited
= wait_serialising_requests(req
);
3282 assert(!waited
|| !req
->serialising
);
3283 assert(req
->overlap_offset
<= offset
);
3284 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3286 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3288 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3289 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3290 qemu_iovec_is_zero(qiov
)) {
3291 flags
|= BDRV_REQ_ZERO_WRITE
;
3292 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3293 flags
|= BDRV_REQ_MAY_UNMAP
;
3298 /* Do nothing, write notifier decided to fail this request */
3299 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3300 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3301 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3303 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3304 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3306 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3308 if (ret
== 0 && !bs
->enable_write_cache
) {
3309 ret
= bdrv_co_flush(bs
);
3312 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3314 block_acct_highest_sector(&bs
->stats
, sector_num
, nb_sectors
);
3317 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3324 * Handle a write request in coroutine context
3326 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3327 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3328 BdrvRequestFlags flags
)
3330 BdrvTrackedRequest req
;
3331 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3332 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3333 uint8_t *head_buf
= NULL
;
3334 uint8_t *tail_buf
= NULL
;
3335 QEMUIOVector local_qiov
;
3336 bool use_local_qiov
= false;
3342 if (bs
->read_only
) {
3345 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3349 /* throttling disk I/O */
3350 if (bs
->io_limits_enabled
) {
3351 bdrv_io_limits_intercept(bs
, bytes
, true);
3355 * Align write if necessary by performing a read-modify-write cycle.
3356 * Pad qiov with the read parts and be sure to have a tracked request not
3357 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3359 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3361 if (offset
& (align
- 1)) {
3362 QEMUIOVector head_qiov
;
3363 struct iovec head_iov
;
3365 mark_request_serialising(&req
, align
);
3366 wait_serialising_requests(&req
);
3368 head_buf
= qemu_blockalign(bs
, align
);
3369 head_iov
= (struct iovec
) {
3370 .iov_base
= head_buf
,
3373 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3375 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3376 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3377 align
, &head_qiov
, 0);
3381 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3383 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3384 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3385 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3386 use_local_qiov
= true;
3388 bytes
+= offset
& (align
- 1);
3389 offset
= offset
& ~(align
- 1);
3392 if ((offset
+ bytes
) & (align
- 1)) {
3393 QEMUIOVector tail_qiov
;
3394 struct iovec tail_iov
;
3398 mark_request_serialising(&req
, align
);
3399 waited
= wait_serialising_requests(&req
);
3400 assert(!waited
|| !use_local_qiov
);
3402 tail_buf
= qemu_blockalign(bs
, align
);
3403 tail_iov
= (struct iovec
) {
3404 .iov_base
= tail_buf
,
3407 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3409 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3410 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3411 align
, &tail_qiov
, 0);
3415 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3417 if (!use_local_qiov
) {
3418 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3419 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3420 use_local_qiov
= true;
3423 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3424 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3426 bytes
= ROUND_UP(bytes
, align
);
3429 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3430 use_local_qiov
? &local_qiov
: qiov
,
3434 tracked_request_end(&req
);
3436 if (use_local_qiov
) {
3437 qemu_iovec_destroy(&local_qiov
);
3439 qemu_vfree(head_buf
);
3440 qemu_vfree(tail_buf
);
3445 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3446 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3447 BdrvRequestFlags flags
)
3449 if (nb_sectors
< 0 || nb_sectors
> BDRV_REQUEST_MAX_SECTORS
) {
3453 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3454 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3457 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3458 int nb_sectors
, QEMUIOVector
*qiov
)
3460 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3462 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3465 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3466 int64_t sector_num
, int nb_sectors
,
3467 BdrvRequestFlags flags
)
3469 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3471 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3472 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3475 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3476 BDRV_REQ_ZERO_WRITE
| flags
);
3480 * Truncate file to 'offset' bytes (needed only for file protocols)
3482 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3484 BlockDriver
*drv
= bs
->drv
;
3488 if (!drv
->bdrv_truncate
)
3493 ret
= drv
->bdrv_truncate(bs
, offset
);
3495 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3497 blk_dev_resize_cb(bs
->blk
);
3504 * Length of a allocated file in bytes. Sparse files are counted by actual
3505 * allocated space. Return < 0 if error or unknown.
3507 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3509 BlockDriver
*drv
= bs
->drv
;
3513 if (drv
->bdrv_get_allocated_file_size
) {
3514 return drv
->bdrv_get_allocated_file_size(bs
);
3517 return bdrv_get_allocated_file_size(bs
->file
);
3523 * Return number of sectors on success, -errno on error.
3525 int64_t bdrv_nb_sectors(BlockDriverState
*bs
)
3527 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
;
3542 * Return length in bytes on success, -errno on error.
3543 * The length is always a multiple of BDRV_SECTOR_SIZE.
3545 int64_t bdrv_getlength(BlockDriverState
*bs
)
3547 int64_t ret
= bdrv_nb_sectors(bs
);
3549 return ret
< 0 ? ret
: ret
* BDRV_SECTOR_SIZE
;
3552 /* return 0 as number of sectors if no device present or error */
3553 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3555 int64_t nb_sectors
= bdrv_nb_sectors(bs
);
3557 *nb_sectors_ptr
= nb_sectors
< 0 ? 0 : nb_sectors
;
3560 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3561 BlockdevOnError on_write_error
)
3563 bs
->on_read_error
= on_read_error
;
3564 bs
->on_write_error
= on_write_error
;
3567 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3569 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3572 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3574 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3577 case BLOCKDEV_ON_ERROR_ENOSPC
:
3578 return (error
== ENOSPC
) ?
3579 BLOCK_ERROR_ACTION_STOP
: BLOCK_ERROR_ACTION_REPORT
;
3580 case BLOCKDEV_ON_ERROR_STOP
:
3581 return BLOCK_ERROR_ACTION_STOP
;
3582 case BLOCKDEV_ON_ERROR_REPORT
:
3583 return BLOCK_ERROR_ACTION_REPORT
;
3584 case BLOCKDEV_ON_ERROR_IGNORE
:
3585 return BLOCK_ERROR_ACTION_IGNORE
;
3591 static void send_qmp_error_event(BlockDriverState
*bs
,
3592 BlockErrorAction action
,
3593 bool is_read
, int error
)
3595 IoOperationType optype
;
3597 optype
= is_read
? IO_OPERATION_TYPE_READ
: IO_OPERATION_TYPE_WRITE
;
3598 qapi_event_send_block_io_error(bdrv_get_device_name(bs
), optype
, action
,
3599 bdrv_iostatus_is_enabled(bs
),
3600 error
== ENOSPC
, strerror(error
),
3604 /* This is done by device models because, while the block layer knows
3605 * about the error, it does not know whether an operation comes from
3606 * the device or the block layer (from a job, for example).
3608 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3609 bool is_read
, int error
)
3613 if (action
== BLOCK_ERROR_ACTION_STOP
) {
3614 /* First set the iostatus, so that "info block" returns an iostatus
3615 * that matches the events raised so far (an additional error iostatus
3616 * is fine, but not a lost one).
3618 bdrv_iostatus_set_err(bs
, error
);
3620 /* Then raise the request to stop the VM and the event.
3621 * qemu_system_vmstop_request_prepare has two effects. First,
3622 * it ensures that the STOP event always comes after the
3623 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3624 * can observe the STOP event and do a "cont" before the STOP
3625 * event is issued, the VM will not stop. In this case, vm_start()
3626 * also ensures that the STOP/RESUME pair of events is emitted.
3628 qemu_system_vmstop_request_prepare();
3629 send_qmp_error_event(bs
, action
, is_read
, error
);
3630 qemu_system_vmstop_request(RUN_STATE_IO_ERROR
);
3632 send_qmp_error_event(bs
, action
, is_read
, error
);
3636 int bdrv_is_read_only(BlockDriverState
*bs
)
3638 return bs
->read_only
;
3641 int bdrv_is_sg(BlockDriverState
*bs
)
3646 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3648 return bs
->enable_write_cache
;
3651 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3653 bs
->enable_write_cache
= wce
;
3655 /* so a reopen() will preserve wce */
3657 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3659 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3663 int bdrv_is_encrypted(BlockDriverState
*bs
)
3665 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3667 return bs
->encrypted
;
3670 int bdrv_key_required(BlockDriverState
*bs
)
3672 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3674 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3676 return (bs
->encrypted
&& !bs
->valid_key
);
3679 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3682 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3683 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3689 if (!bs
->encrypted
) {
3691 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3694 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3697 } else if (!bs
->valid_key
) {
3700 /* call the change callback now, we skipped it on open */
3701 blk_dev_change_media_cb(bs
->blk
, true);
3708 * Provide an encryption key for @bs.
3709 * If @key is non-null:
3710 * If @bs is not encrypted, fail.
3711 * Else if the key is invalid, fail.
3712 * Else set @bs's key to @key, replacing the existing key, if any.
3714 * If @bs is encrypted and still lacks a key, fail.
3716 * On failure, store an error object through @errp if non-null.
3718 void bdrv_add_key(BlockDriverState
*bs
, const char *key
, Error
**errp
)
3721 if (!bdrv_is_encrypted(bs
)) {
3722 error_setg(errp
, "Device '%s' is not encrypted",
3723 bdrv_get_device_name(bs
));
3724 } else if (bdrv_set_key(bs
, key
) < 0) {
3725 error_set(errp
, QERR_INVALID_PASSWORD
);
3728 if (bdrv_key_required(bs
)) {
3729 error_set(errp
, ERROR_CLASS_DEVICE_ENCRYPTED
,
3730 "'%s' (%s) is encrypted",
3731 bdrv_get_device_name(bs
),
3732 bdrv_get_encrypted_filename(bs
));
3737 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3739 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3742 static int qsort_strcmp(const void *a
, const void *b
)
3744 return strcmp(a
, b
);
3747 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3753 const char **formats
= NULL
;
3755 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3756 if (drv
->format_name
) {
3759 while (formats
&& i
&& !found
) {
3760 found
= !strcmp(formats
[--i
], drv
->format_name
);
3764 formats
= g_renew(const char *, formats
, count
+ 1);
3765 formats
[count
++] = drv
->format_name
;
3770 qsort(formats
, count
, sizeof(formats
[0]), qsort_strcmp
);
3772 for (i
= 0; i
< count
; i
++) {
3773 it(opaque
, formats
[i
]);
3779 /* This function is to find block backend bs */
3780 /* TODO convert callers to blk_by_name(), then remove */
3781 BlockDriverState
*bdrv_find(const char *name
)
3783 BlockBackend
*blk
= blk_by_name(name
);
3785 return blk
? blk_bs(blk
) : NULL
;
3788 /* This function is to find a node in the bs graph */
3789 BlockDriverState
*bdrv_find_node(const char *node_name
)
3791 BlockDriverState
*bs
;
3795 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3796 if (!strcmp(node_name
, bs
->node_name
)) {
3803 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3804 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3806 BlockDeviceInfoList
*list
, *entry
;
3807 BlockDriverState
*bs
;
3810 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3811 entry
= g_malloc0(sizeof(*entry
));
3812 entry
->value
= bdrv_block_device_info(bs
);
3820 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3821 const char *node_name
,
3825 BlockDriverState
*bs
;
3828 blk
= blk_by_name(device
);
3836 bs
= bdrv_find_node(node_name
);
3843 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3844 device
? device
: "",
3845 node_name
? node_name
: "");
3849 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3850 * return false. If either argument is NULL, return false. */
3851 bool bdrv_chain_contains(BlockDriverState
*top
, BlockDriverState
*base
)
3853 while (top
&& top
!= base
) {
3854 top
= top
->backing_hd
;
3860 BlockDriverState
*bdrv_next_node(BlockDriverState
*bs
)
3863 return QTAILQ_FIRST(&graph_bdrv_states
);
3865 return QTAILQ_NEXT(bs
, node_list
);
3868 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3871 return QTAILQ_FIRST(&bdrv_states
);
3873 return QTAILQ_NEXT(bs
, device_list
);
3876 const char *bdrv_get_node_name(const BlockDriverState
*bs
)
3878 return bs
->node_name
;
3881 /* TODO check what callers really want: bs->node_name or blk_name() */
3882 const char *bdrv_get_device_name(const BlockDriverState
*bs
)
3884 return bs
->blk
? blk_name(bs
->blk
) : "";
3887 int bdrv_get_flags(BlockDriverState
*bs
)
3889 return bs
->open_flags
;
3892 int bdrv_flush_all(void)
3894 BlockDriverState
*bs
;
3897 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3898 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
3901 aio_context_acquire(aio_context
);
3902 ret
= bdrv_flush(bs
);
3903 if (ret
< 0 && !result
) {
3906 aio_context_release(aio_context
);
3912 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3917 int bdrv_has_zero_init(BlockDriverState
*bs
)
3921 /* If BS is a copy on write image, it is initialized to
3922 the contents of the base image, which may not be zeroes. */
3923 if (bs
->backing_hd
) {
3926 if (bs
->drv
->bdrv_has_zero_init
) {
3927 return bs
->drv
->bdrv_has_zero_init(bs
);
3934 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3936 BlockDriverInfo bdi
;
3938 if (bs
->backing_hd
) {
3942 if (bdrv_get_info(bs
, &bdi
) == 0) {
3943 return bdi
.unallocated_blocks_are_zero
;
3949 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3951 BlockDriverInfo bdi
;
3953 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3957 if (bdrv_get_info(bs
, &bdi
) == 0) {
3958 return bdi
.can_write_zeroes_with_unmap
;
3964 typedef struct BdrvCoGetBlockStatusData
{
3965 BlockDriverState
*bs
;
3966 BlockDriverState
*base
;
3972 } BdrvCoGetBlockStatusData
;
3975 * Returns the allocation status of the specified sectors.
3976 * Drivers not implementing the functionality are assumed to not support
3977 * backing files, hence all their sectors are reported as allocated.
3979 * If 'sector_num' is beyond the end of the disk image the return value is 0
3980 * and 'pnum' is set to 0.
3982 * 'pnum' is set to the number of sectors (including and immediately following
3983 * the specified sector) that are known to be in the same
3984 * allocated/unallocated state.
3986 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3987 * beyond the end of the disk image it will be clamped.
3989 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
3991 int nb_sectors
, int *pnum
)
3993 int64_t total_sectors
;
3997 total_sectors
= bdrv_nb_sectors(bs
);
3998 if (total_sectors
< 0) {
3999 return total_sectors
;
4002 if (sector_num
>= total_sectors
) {
4007 n
= total_sectors
- sector_num
;
4008 if (n
< nb_sectors
) {
4012 if (!bs
->drv
->bdrv_co_get_block_status
) {
4014 ret
= BDRV_BLOCK_DATA
| BDRV_BLOCK_ALLOCATED
;
4015 if (bs
->drv
->protocol_name
) {
4016 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
4021 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4027 if (ret
& BDRV_BLOCK_RAW
) {
4028 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
4029 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4033 if (ret
& (BDRV_BLOCK_DATA
| BDRV_BLOCK_ZERO
)) {
4034 ret
|= BDRV_BLOCK_ALLOCATED
;
4037 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
4038 if (bdrv_unallocated_blocks_are_zero(bs
)) {
4039 ret
|= BDRV_BLOCK_ZERO
;
4040 } else if (bs
->backing_hd
) {
4041 BlockDriverState
*bs2
= bs
->backing_hd
;
4042 int64_t nb_sectors2
= bdrv_nb_sectors(bs2
);
4043 if (nb_sectors2
>= 0 && sector_num
>= nb_sectors2
) {
4044 ret
|= BDRV_BLOCK_ZERO
;
4050 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
4051 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
4054 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
4057 /* Ignore errors. This is just providing extra information, it
4058 * is useful but not necessary.
4061 /* !file_pnum indicates an offset at or beyond the EOF; it is
4062 * perfectly valid for the format block driver to point to such
4063 * offsets, so catch it and mark everything as zero */
4064 ret
|= BDRV_BLOCK_ZERO
;
4066 /* Limit request to the range reported by the protocol driver */
4068 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
4076 /* Coroutine wrapper for bdrv_get_block_status() */
4077 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
4079 BdrvCoGetBlockStatusData
*data
= opaque
;
4080 BlockDriverState
*bs
= data
->bs
;
4082 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
4088 * Synchronous wrapper around bdrv_co_get_block_status().
4090 * See bdrv_co_get_block_status() for details.
4092 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
4093 int nb_sectors
, int *pnum
)
4096 BdrvCoGetBlockStatusData data
= {
4098 .sector_num
= sector_num
,
4099 .nb_sectors
= nb_sectors
,
4104 if (qemu_in_coroutine()) {
4105 /* Fast-path if already in coroutine context */
4106 bdrv_get_block_status_co_entry(&data
);
4108 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
4110 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
4111 qemu_coroutine_enter(co
, &data
);
4112 while (!data
.done
) {
4113 aio_poll(aio_context
, true);
4119 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
4120 int nb_sectors
, int *pnum
)
4122 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
4126 return !!(ret
& BDRV_BLOCK_ALLOCATED
);
4130 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4132 * Return true if the given sector is allocated in any image between
4133 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4134 * sector is allocated in any image of the chain. Return false otherwise.
4136 * 'pnum' is set to the number of sectors (including and immediately following
4137 * the specified sector) that are known to be in the same
4138 * allocated/unallocated state.
4141 int bdrv_is_allocated_above(BlockDriverState
*top
,
4142 BlockDriverState
*base
,
4144 int nb_sectors
, int *pnum
)
4146 BlockDriverState
*intermediate
;
4147 int ret
, n
= nb_sectors
;
4150 while (intermediate
&& intermediate
!= base
) {
4152 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
4162 * [sector_num, nb_sectors] is unallocated on top but intermediate
4165 * [sector_num+x, nr_sectors] allocated.
4167 if (n
> pnum_inter
&&
4168 (intermediate
== top
||
4169 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
4173 intermediate
= intermediate
->backing_hd
;
4180 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
4182 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
4183 return bs
->backing_file
;
4184 else if (bs
->encrypted
)
4185 return bs
->filename
;
4190 void bdrv_get_backing_filename(BlockDriverState
*bs
,
4191 char *filename
, int filename_size
)
4193 pstrcpy(filename
, filename_size
, bs
->backing_file
);
4196 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
4197 const uint8_t *buf
, int nb_sectors
)
4199 BlockDriver
*drv
= bs
->drv
;
4202 if (!drv
->bdrv_write_compressed
)
4204 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
4207 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
4209 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
4212 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
4214 BlockDriver
*drv
= bs
->drv
;
4217 if (!drv
->bdrv_get_info
)
4219 memset(bdi
, 0, sizeof(*bdi
));
4220 return drv
->bdrv_get_info(bs
, bdi
);
4223 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
4225 BlockDriver
*drv
= bs
->drv
;
4226 if (drv
&& drv
->bdrv_get_specific_info
) {
4227 return drv
->bdrv_get_specific_info(bs
);
4232 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4233 int64_t pos
, int size
)
4236 struct iovec iov
= {
4237 .iov_base
= (void *) buf
,
4241 qemu_iovec_init_external(&qiov
, &iov
, 1);
4242 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4245 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4247 BlockDriver
*drv
= bs
->drv
;
4251 } else if (drv
->bdrv_save_vmstate
) {
4252 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4253 } else if (bs
->file
) {
4254 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4260 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4261 int64_t pos
, int size
)
4263 BlockDriver
*drv
= bs
->drv
;
4266 if (drv
->bdrv_load_vmstate
)
4267 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4269 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4273 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4275 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4279 bs
->drv
->bdrv_debug_event(bs
, event
);
4282 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4285 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4289 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4290 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4296 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4298 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4302 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4303 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4309 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4311 while (bs
&& (!bs
->drv
|| !bs
->drv
->bdrv_debug_resume
)) {
4315 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4316 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4322 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4324 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4328 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4329 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4335 int bdrv_is_snapshot(BlockDriverState
*bs
)
4337 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4340 /* backing_file can either be relative, or absolute, or a protocol. If it is
4341 * relative, it must be relative to the chain. So, passing in bs->filename
4342 * from a BDS as backing_file should not be done, as that may be relative to
4343 * the CWD rather than the chain. */
4344 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4345 const char *backing_file
)
4347 char *filename_full
= NULL
;
4348 char *backing_file_full
= NULL
;
4349 char *filename_tmp
= NULL
;
4350 int is_protocol
= 0;
4351 BlockDriverState
*curr_bs
= NULL
;
4352 BlockDriverState
*retval
= NULL
;
4354 if (!bs
|| !bs
->drv
|| !backing_file
) {
4358 filename_full
= g_malloc(PATH_MAX
);
4359 backing_file_full
= g_malloc(PATH_MAX
);
4360 filename_tmp
= g_malloc(PATH_MAX
);
4362 is_protocol
= path_has_protocol(backing_file
);
4364 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4366 /* If either of the filename paths is actually a protocol, then
4367 * compare unmodified paths; otherwise make paths relative */
4368 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4369 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4370 retval
= curr_bs
->backing_hd
;
4374 /* If not an absolute filename path, make it relative to the current
4375 * image's filename path */
4376 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4379 /* We are going to compare absolute pathnames */
4380 if (!realpath(filename_tmp
, filename_full
)) {
4384 /* We need to make sure the backing filename we are comparing against
4385 * is relative to the current image filename (or absolute) */
4386 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4387 curr_bs
->backing_file
);
4389 if (!realpath(filename_tmp
, backing_file_full
)) {
4393 if (strcmp(backing_file_full
, filename_full
) == 0) {
4394 retval
= curr_bs
->backing_hd
;
4400 g_free(filename_full
);
4401 g_free(backing_file_full
);
4402 g_free(filename_tmp
);
4406 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4412 if (!bs
->backing_hd
) {
4416 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4419 /**************************************************************/
4422 BlockAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4423 QEMUIOVector
*qiov
, int nb_sectors
,
4424 BlockCompletionFunc
*cb
, void *opaque
)
4426 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4428 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4432 BlockAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4433 QEMUIOVector
*qiov
, int nb_sectors
,
4434 BlockCompletionFunc
*cb
, void *opaque
)
4436 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4438 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4442 BlockAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4443 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4444 BlockCompletionFunc
*cb
, void *opaque
)
4446 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4448 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4449 BDRV_REQ_ZERO_WRITE
| flags
,
4454 typedef struct MultiwriteCB
{
4459 BlockCompletionFunc
*cb
;
4461 QEMUIOVector
*free_qiov
;
4465 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4469 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4470 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4471 if (mcb
->callbacks
[i
].free_qiov
) {
4472 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4474 g_free(mcb
->callbacks
[i
].free_qiov
);
4478 static void multiwrite_cb(void *opaque
, int ret
)
4480 MultiwriteCB
*mcb
= opaque
;
4482 trace_multiwrite_cb(mcb
, ret
);
4484 if (ret
< 0 && !mcb
->error
) {
4488 mcb
->num_requests
--;
4489 if (mcb
->num_requests
== 0) {
4490 multiwrite_user_cb(mcb
);
4495 static int multiwrite_req_compare(const void *a
, const void *b
)
4497 const BlockRequest
*req1
= a
, *req2
= b
;
4500 * Note that we can't simply subtract req2->sector from req1->sector
4501 * here as that could overflow the return value.
4503 if (req1
->sector
> req2
->sector
) {
4505 } else if (req1
->sector
< req2
->sector
) {
4513 * Takes a bunch of requests and tries to merge them. Returns the number of
4514 * requests that remain after merging.
4516 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4517 int num_reqs
, MultiwriteCB
*mcb
)
4521 // Sort requests by start sector
4522 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4524 // Check if adjacent requests touch the same clusters. If so, combine them,
4525 // filling up gaps with zero sectors.
4527 for (i
= 1; i
< num_reqs
; i
++) {
4529 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4531 // Handle exactly sequential writes and overlapping writes.
4532 if (reqs
[i
].sector
<= oldreq_last
) {
4536 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4540 if (bs
->bl
.max_transfer_length
&& reqs
[outidx
].nb_sectors
+
4541 reqs
[i
].nb_sectors
> bs
->bl
.max_transfer_length
) {
4547 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4548 qemu_iovec_init(qiov
,
4549 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4551 // Add the first request to the merged one. If the requests are
4552 // overlapping, drop the last sectors of the first request.
4553 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4554 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4556 // We should need to add any zeros between the two requests
4557 assert (reqs
[i
].sector
<= oldreq_last
);
4559 // Add the second request
4560 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4562 // Add tail of first request, if necessary
4563 if (qiov
->size
< reqs
[outidx
].qiov
->size
) {
4564 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, qiov
->size
,
4565 reqs
[outidx
].qiov
->size
- qiov
->size
);
4568 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4569 reqs
[outidx
].qiov
= qiov
;
4571 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4574 reqs
[outidx
].sector
= reqs
[i
].sector
;
4575 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4576 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4580 block_acct_merge_done(&bs
->stats
, BLOCK_ACCT_WRITE
, num_reqs
- outidx
- 1);
4586 * Submit multiple AIO write requests at once.
4588 * On success, the function returns 0 and all requests in the reqs array have
4589 * been submitted. In error case this function returns -1, and any of the
4590 * requests may or may not be submitted yet. In particular, this means that the
4591 * callback will be called for some of the requests, for others it won't. The
4592 * caller must check the error field of the BlockRequest to wait for the right
4593 * callbacks (if error != 0, no callback will be called).
4595 * The implementation may modify the contents of the reqs array, e.g. to merge
4596 * requests. However, the fields opaque and error are left unmodified as they
4597 * are used to signal failure for a single request to the caller.
4599 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4604 /* don't submit writes if we don't have a medium */
4605 if (bs
->drv
== NULL
) {
4606 for (i
= 0; i
< num_reqs
; i
++) {
4607 reqs
[i
].error
= -ENOMEDIUM
;
4612 if (num_reqs
== 0) {
4616 // Create MultiwriteCB structure
4617 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4618 mcb
->num_requests
= 0;
4619 mcb
->num_callbacks
= num_reqs
;
4621 for (i
= 0; i
< num_reqs
; i
++) {
4622 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4623 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4626 // Check for mergable requests
4627 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4629 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4631 /* Run the aio requests. */
4632 mcb
->num_requests
= num_reqs
;
4633 for (i
= 0; i
< num_reqs
; i
++) {
4634 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4635 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4643 void bdrv_aio_cancel(BlockAIOCB
*acb
)
4646 bdrv_aio_cancel_async(acb
);
4647 while (acb
->refcnt
> 1) {
4648 if (acb
->aiocb_info
->get_aio_context
) {
4649 aio_poll(acb
->aiocb_info
->get_aio_context(acb
), true);
4650 } else if (acb
->bs
) {
4651 aio_poll(bdrv_get_aio_context(acb
->bs
), true);
4656 qemu_aio_unref(acb
);
4659 /* Async version of aio cancel. The caller is not blocked if the acb implements
4660 * cancel_async, otherwise we do nothing and let the request normally complete.
4661 * In either case the completion callback must be called. */
4662 void bdrv_aio_cancel_async(BlockAIOCB
*acb
)
4664 if (acb
->aiocb_info
->cancel_async
) {
4665 acb
->aiocb_info
->cancel_async(acb
);
4669 /**************************************************************/
4670 /* async block device emulation */
4672 typedef struct BlockAIOCBSync
{
4676 /* vector translation state */
4682 static const AIOCBInfo bdrv_em_aiocb_info
= {
4683 .aiocb_size
= sizeof(BlockAIOCBSync
),
4686 static void bdrv_aio_bh_cb(void *opaque
)
4688 BlockAIOCBSync
*acb
= opaque
;
4690 if (!acb
->is_write
&& acb
->ret
>= 0) {
4691 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4693 qemu_vfree(acb
->bounce
);
4694 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4695 qemu_bh_delete(acb
->bh
);
4697 qemu_aio_unref(acb
);
4700 static BlockAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4704 BlockCompletionFunc
*cb
,
4709 BlockAIOCBSync
*acb
;
4711 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4712 acb
->is_write
= is_write
;
4714 acb
->bounce
= qemu_try_blockalign(bs
, qiov
->size
);
4715 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_aio_bh_cb
, acb
);
4717 if (acb
->bounce
== NULL
) {
4719 } else if (is_write
) {
4720 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4721 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4723 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4726 qemu_bh_schedule(acb
->bh
);
4728 return &acb
->common
;
4731 static BlockAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4732 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4733 BlockCompletionFunc
*cb
, void *opaque
)
4735 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4738 static BlockAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4739 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4740 BlockCompletionFunc
*cb
, void *opaque
)
4742 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4746 typedef struct BlockAIOCBCoroutine
{
4752 } BlockAIOCBCoroutine
;
4754 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4755 .aiocb_size
= sizeof(BlockAIOCBCoroutine
),
4758 static void bdrv_co_em_bh(void *opaque
)
4760 BlockAIOCBCoroutine
*acb
= opaque
;
4762 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4764 qemu_bh_delete(acb
->bh
);
4765 qemu_aio_unref(acb
);
4768 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4769 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4771 BlockAIOCBCoroutine
*acb
= opaque
;
4772 BlockDriverState
*bs
= acb
->common
.bs
;
4774 if (!acb
->is_write
) {
4775 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4776 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4778 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4779 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4782 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4783 qemu_bh_schedule(acb
->bh
);
4786 static BlockAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4790 BdrvRequestFlags flags
,
4791 BlockCompletionFunc
*cb
,
4796 BlockAIOCBCoroutine
*acb
;
4798 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4799 acb
->req
.sector
= sector_num
;
4800 acb
->req
.nb_sectors
= nb_sectors
;
4801 acb
->req
.qiov
= qiov
;
4802 acb
->req
.flags
= flags
;
4803 acb
->is_write
= is_write
;
4805 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4806 qemu_coroutine_enter(co
, acb
);
4808 return &acb
->common
;
4811 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4813 BlockAIOCBCoroutine
*acb
= opaque
;
4814 BlockDriverState
*bs
= acb
->common
.bs
;
4816 acb
->req
.error
= bdrv_co_flush(bs
);
4817 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4818 qemu_bh_schedule(acb
->bh
);
4821 BlockAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4822 BlockCompletionFunc
*cb
, void *opaque
)
4824 trace_bdrv_aio_flush(bs
, opaque
);
4827 BlockAIOCBCoroutine
*acb
;
4829 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4831 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4832 qemu_coroutine_enter(co
, acb
);
4834 return &acb
->common
;
4837 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4839 BlockAIOCBCoroutine
*acb
= opaque
;
4840 BlockDriverState
*bs
= acb
->common
.bs
;
4842 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4843 acb
->bh
= aio_bh_new(bdrv_get_aio_context(bs
), bdrv_co_em_bh
, acb
);
4844 qemu_bh_schedule(acb
->bh
);
4847 BlockAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4848 int64_t sector_num
, int nb_sectors
,
4849 BlockCompletionFunc
*cb
, void *opaque
)
4852 BlockAIOCBCoroutine
*acb
;
4854 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4856 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4857 acb
->req
.sector
= sector_num
;
4858 acb
->req
.nb_sectors
= nb_sectors
;
4859 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4860 qemu_coroutine_enter(co
, acb
);
4862 return &acb
->common
;
4865 void bdrv_init(void)
4867 module_call_init(MODULE_INIT_BLOCK
);
4870 void bdrv_init_with_whitelist(void)
4872 use_bdrv_whitelist
= 1;
4876 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4877 BlockCompletionFunc
*cb
, void *opaque
)
4881 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4882 acb
->aiocb_info
= aiocb_info
;
4885 acb
->opaque
= opaque
;
4890 void qemu_aio_ref(void *p
)
4892 BlockAIOCB
*acb
= p
;
4896 void qemu_aio_unref(void *p
)
4898 BlockAIOCB
*acb
= p
;
4899 assert(acb
->refcnt
> 0);
4900 if (--acb
->refcnt
== 0) {
4901 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4905 /**************************************************************/
4906 /* Coroutine block device emulation */
4908 typedef struct CoroutineIOCompletion
{
4909 Coroutine
*coroutine
;
4911 } CoroutineIOCompletion
;
4913 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4915 CoroutineIOCompletion
*co
= opaque
;
4918 qemu_coroutine_enter(co
->coroutine
, NULL
);
4921 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4922 int nb_sectors
, QEMUIOVector
*iov
,
4925 CoroutineIOCompletion co
= {
4926 .coroutine
= qemu_coroutine_self(),
4931 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4932 bdrv_co_io_em_complete
, &co
);
4934 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4935 bdrv_co_io_em_complete
, &co
);
4938 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4942 qemu_coroutine_yield();
4947 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4948 int64_t sector_num
, int nb_sectors
,
4951 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4954 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4955 int64_t sector_num
, int nb_sectors
,
4958 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4961 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4963 RwCo
*rwco
= opaque
;
4965 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4968 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4972 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4976 /* Write back cached data to the OS even with cache=unsafe */
4977 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4978 if (bs
->drv
->bdrv_co_flush_to_os
) {
4979 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4985 /* But don't actually force it to the disk with cache=unsafe */
4986 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4990 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
4991 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4992 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4993 } else if (bs
->drv
->bdrv_aio_flush
) {
4995 CoroutineIOCompletion co
= {
4996 .coroutine
= qemu_coroutine_self(),
4999 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
5003 qemu_coroutine_yield();
5008 * Some block drivers always operate in either writethrough or unsafe
5009 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
5010 * know how the server works (because the behaviour is hardcoded or
5011 * depends on server-side configuration), so we can't ensure that
5012 * everything is safe on disk. Returning an error doesn't work because
5013 * that would break guests even if the server operates in writethrough
5016 * Let's hope the user knows what he's doing.
5024 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
5025 * in the case of cache=unsafe, so there are no useless flushes.
5028 return bdrv_co_flush(bs
->file
);
5031 void bdrv_invalidate_cache(BlockDriverState
*bs
, Error
**errp
)
5033 Error
*local_err
= NULL
;
5040 if (!(bs
->open_flags
& BDRV_O_INCOMING
)) {
5043 bs
->open_flags
&= ~BDRV_O_INCOMING
;
5045 if (bs
->drv
->bdrv_invalidate_cache
) {
5046 bs
->drv
->bdrv_invalidate_cache(bs
, &local_err
);
5047 } else if (bs
->file
) {
5048 bdrv_invalidate_cache(bs
->file
, &local_err
);
5051 error_propagate(errp
, local_err
);
5055 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
5057 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
5062 void bdrv_invalidate_cache_all(Error
**errp
)
5064 BlockDriverState
*bs
;
5065 Error
*local_err
= NULL
;
5067 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5068 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5070 aio_context_acquire(aio_context
);
5071 bdrv_invalidate_cache(bs
, &local_err
);
5072 aio_context_release(aio_context
);
5074 error_propagate(errp
, local_err
);
5080 int bdrv_flush(BlockDriverState
*bs
)
5088 if (qemu_in_coroutine()) {
5089 /* Fast-path if already in coroutine context */
5090 bdrv_flush_co_entry(&rwco
);
5092 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5094 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
5095 qemu_coroutine_enter(co
, &rwco
);
5096 while (rwco
.ret
== NOT_DONE
) {
5097 aio_poll(aio_context
, true);
5104 typedef struct DiscardCo
{
5105 BlockDriverState
*bs
;
5110 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
5112 DiscardCo
*rwco
= opaque
;
5114 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
5117 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
5124 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
5126 } else if (bs
->read_only
) {
5130 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
5132 /* Do nothing if disabled. */
5133 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
5137 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
5141 max_discard
= MIN_NON_ZERO(bs
->bl
.max_discard
, BDRV_REQUEST_MAX_SECTORS
);
5142 while (nb_sectors
> 0) {
5144 int num
= nb_sectors
;
5147 if (bs
->bl
.discard_alignment
&&
5148 num
>= bs
->bl
.discard_alignment
&&
5149 sector_num
% bs
->bl
.discard_alignment
) {
5150 if (num
> bs
->bl
.discard_alignment
) {
5151 num
= bs
->bl
.discard_alignment
;
5153 num
-= sector_num
% bs
->bl
.discard_alignment
;
5156 /* limit request size */
5157 if (num
> max_discard
) {
5161 if (bs
->drv
->bdrv_co_discard
) {
5162 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
5165 CoroutineIOCompletion co
= {
5166 .coroutine
= qemu_coroutine_self(),
5169 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
5170 bdrv_co_io_em_complete
, &co
);
5174 qemu_coroutine_yield();
5178 if (ret
&& ret
!= -ENOTSUP
) {
5188 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
5193 .sector_num
= sector_num
,
5194 .nb_sectors
= nb_sectors
,
5198 if (qemu_in_coroutine()) {
5199 /* Fast-path if already in coroutine context */
5200 bdrv_discard_co_entry(&rwco
);
5202 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
5204 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
5205 qemu_coroutine_enter(co
, &rwco
);
5206 while (rwco
.ret
== NOT_DONE
) {
5207 aio_poll(aio_context
, true);
5214 /**************************************************************/
5215 /* removable device support */
5218 * Return TRUE if the media is present
5220 int bdrv_is_inserted(BlockDriverState
*bs
)
5222 BlockDriver
*drv
= bs
->drv
;
5226 if (!drv
->bdrv_is_inserted
)
5228 return drv
->bdrv_is_inserted(bs
);
5232 * Return whether the media changed since the last call to this
5233 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5235 int bdrv_media_changed(BlockDriverState
*bs
)
5237 BlockDriver
*drv
= bs
->drv
;
5239 if (drv
&& drv
->bdrv_media_changed
) {
5240 return drv
->bdrv_media_changed(bs
);
5246 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5248 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
5250 BlockDriver
*drv
= bs
->drv
;
5251 const char *device_name
;
5253 if (drv
&& drv
->bdrv_eject
) {
5254 drv
->bdrv_eject(bs
, eject_flag
);
5257 device_name
= bdrv_get_device_name(bs
);
5258 if (device_name
[0] != '\0') {
5259 qapi_event_send_device_tray_moved(device_name
,
5260 eject_flag
, &error_abort
);
5265 * Lock or unlock the media (if it is locked, the user won't be able
5266 * to eject it manually).
5268 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5270 BlockDriver
*drv
= bs
->drv
;
5272 trace_bdrv_lock_medium(bs
, locked
);
5274 if (drv
&& drv
->bdrv_lock_medium
) {
5275 drv
->bdrv_lock_medium(bs
, locked
);
5279 /* needed for generic scsi interface */
5281 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5283 BlockDriver
*drv
= bs
->drv
;
5285 if (drv
&& drv
->bdrv_ioctl
)
5286 return drv
->bdrv_ioctl(bs
, req
, buf
);
5290 BlockAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5291 unsigned long int req
, void *buf
,
5292 BlockCompletionFunc
*cb
, void *opaque
)
5294 BlockDriver
*drv
= bs
->drv
;
5296 if (drv
&& drv
->bdrv_aio_ioctl
)
5297 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5301 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5303 bs
->guest_block_size
= align
;
5306 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5308 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5311 void *qemu_blockalign0(BlockDriverState
*bs
, size_t size
)
5313 return memset(qemu_blockalign(bs
, size
), 0, size
);
5316 void *qemu_try_blockalign(BlockDriverState
*bs
, size_t size
)
5318 size_t align
= bdrv_opt_mem_align(bs
);
5320 /* Ensure that NULL is never returned on success */
5326 return qemu_try_memalign(align
, size
);
5329 void *qemu_try_blockalign0(BlockDriverState
*bs
, size_t size
)
5331 void *mem
= qemu_try_blockalign(bs
, size
);
5334 memset(mem
, 0, size
);
5341 * Check if all memory in this vector is sector aligned.
5343 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5346 size_t alignment
= bdrv_opt_mem_align(bs
);
5348 for (i
= 0; i
< qiov
->niov
; i
++) {
5349 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5352 if (qiov
->iov
[i
].iov_len
% alignment
) {
5360 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
,
5363 int64_t bitmap_size
;
5364 BdrvDirtyBitmap
*bitmap
;
5366 assert((granularity
& (granularity
- 1)) == 0);
5368 granularity
>>= BDRV_SECTOR_BITS
;
5369 assert(granularity
);
5370 bitmap_size
= bdrv_nb_sectors(bs
);
5371 if (bitmap_size
< 0) {
5372 error_setg_errno(errp
, -bitmap_size
, "could not get length of device");
5373 errno
= -bitmap_size
;
5376 bitmap
= g_new0(BdrvDirtyBitmap
, 1);
5377 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
5378 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5382 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5384 BdrvDirtyBitmap
*bm
, *next
;
5385 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5387 QLIST_REMOVE(bitmap
, list
);
5388 hbitmap_free(bitmap
->bitmap
);
5395 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5397 BdrvDirtyBitmap
*bm
;
5398 BlockDirtyInfoList
*list
= NULL
;
5399 BlockDirtyInfoList
**plist
= &list
;
5401 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5402 BlockDirtyInfo
*info
= g_new0(BlockDirtyInfo
, 1);
5403 BlockDirtyInfoList
*entry
= g_new0(BlockDirtyInfoList
, 1);
5404 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5406 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5407 entry
->value
= info
;
5409 plist
= &entry
->next
;
5415 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5418 return hbitmap_get(bitmap
->bitmap
, sector
);
5424 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5425 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5427 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5430 void bdrv_set_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5431 int64_t cur_sector
, int nr_sectors
)
5433 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5436 void bdrv_reset_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
,
5437 int64_t cur_sector
, int nr_sectors
)
5439 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5442 static void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5445 BdrvDirtyBitmap
*bitmap
;
5446 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5447 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5451 static void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5454 BdrvDirtyBitmap
*bitmap
;
5455 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5456 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5460 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5462 return hbitmap_count(bitmap
->bitmap
);
5465 /* Get a reference to bs */
5466 void bdrv_ref(BlockDriverState
*bs
)
5471 /* Release a previously grabbed reference to bs.
5472 * If after releasing, reference count is zero, the BlockDriverState is
5474 void bdrv_unref(BlockDriverState
*bs
)
5479 assert(bs
->refcnt
> 0);
5480 if (--bs
->refcnt
== 0) {
5485 struct BdrvOpBlocker
{
5487 QLIST_ENTRY(BdrvOpBlocker
) list
;
5490 bool bdrv_op_is_blocked(BlockDriverState
*bs
, BlockOpType op
, Error
**errp
)
5492 BdrvOpBlocker
*blocker
;
5493 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5494 if (!QLIST_EMPTY(&bs
->op_blockers
[op
])) {
5495 blocker
= QLIST_FIRST(&bs
->op_blockers
[op
]);
5497 error_setg(errp
, "Device '%s' is busy: %s",
5498 bdrv_get_device_name(bs
),
5499 error_get_pretty(blocker
->reason
));
5506 void bdrv_op_block(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5508 BdrvOpBlocker
*blocker
;
5509 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5511 blocker
= g_new0(BdrvOpBlocker
, 1);
5512 blocker
->reason
= reason
;
5513 QLIST_INSERT_HEAD(&bs
->op_blockers
[op
], blocker
, list
);
5516 void bdrv_op_unblock(BlockDriverState
*bs
, BlockOpType op
, Error
*reason
)
5518 BdrvOpBlocker
*blocker
, *next
;
5519 assert((int) op
>= 0 && op
< BLOCK_OP_TYPE_MAX
);
5520 QLIST_FOREACH_SAFE(blocker
, &bs
->op_blockers
[op
], list
, next
) {
5521 if (blocker
->reason
== reason
) {
5522 QLIST_REMOVE(blocker
, list
);
5528 void bdrv_op_block_all(BlockDriverState
*bs
, Error
*reason
)
5531 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5532 bdrv_op_block(bs
, i
, reason
);
5536 void bdrv_op_unblock_all(BlockDriverState
*bs
, Error
*reason
)
5539 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5540 bdrv_op_unblock(bs
, i
, reason
);
5544 bool bdrv_op_blocker_is_empty(BlockDriverState
*bs
)
5548 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
5549 if (!QLIST_EMPTY(&bs
->op_blockers
[i
])) {
5556 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5558 bs
->iostatus_enabled
= true;
5559 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5562 /* The I/O status is only enabled if the drive explicitly
5563 * enables it _and_ the VM is configured to stop on errors */
5564 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5566 return (bs
->iostatus_enabled
&&
5567 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5568 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5569 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5572 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5574 bs
->iostatus_enabled
= false;
5577 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5579 if (bdrv_iostatus_is_enabled(bs
)) {
5580 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5582 block_job_iostatus_reset(bs
->job
);
5587 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5589 assert(bdrv_iostatus_is_enabled(bs
));
5590 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5591 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5592 BLOCK_DEVICE_IO_STATUS_FAILED
;
5596 void bdrv_img_create(const char *filename
, const char *fmt
,
5597 const char *base_filename
, const char *base_fmt
,
5598 char *options
, uint64_t img_size
, int flags
,
5599 Error
**errp
, bool quiet
)
5601 QemuOptsList
*create_opts
= NULL
;
5602 QemuOpts
*opts
= NULL
;
5603 const char *backing_fmt
, *backing_file
;
5605 BlockDriver
*drv
, *proto_drv
;
5606 BlockDriver
*backing_drv
= NULL
;
5607 Error
*local_err
= NULL
;
5610 /* Find driver and parse its options */
5611 drv
= bdrv_find_format(fmt
);
5613 error_setg(errp
, "Unknown file format '%s'", fmt
);
5617 proto_drv
= bdrv_find_protocol(filename
, true, errp
);
5622 if (!drv
->create_opts
) {
5623 error_setg(errp
, "Format driver '%s' does not support image creation",
5628 if (!proto_drv
->create_opts
) {
5629 error_setg(errp
, "Protocol driver '%s' does not support image creation",
5630 proto_drv
->format_name
);
5634 create_opts
= qemu_opts_append(create_opts
, drv
->create_opts
);
5635 create_opts
= qemu_opts_append(create_opts
, proto_drv
->create_opts
);
5637 /* Create parameter list with default values */
5638 opts
= qemu_opts_create(create_opts
, NULL
, 0, &error_abort
);
5639 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, img_size
);
5641 /* Parse -o options */
5643 if (qemu_opts_do_parse(opts
, options
, NULL
) != 0) {
5644 error_setg(errp
, "Invalid options for file format '%s'", fmt
);
5649 if (base_filename
) {
5650 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FILE
, base_filename
)) {
5651 error_setg(errp
, "Backing file not supported for file format '%s'",
5658 if (qemu_opt_set(opts
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
5659 error_setg(errp
, "Backing file format not supported for file "
5660 "format '%s'", fmt
);
5665 backing_file
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FILE
);
5667 if (!strcmp(filename
, backing_file
)) {
5668 error_setg(errp
, "Error: Trying to create an image with the "
5669 "same filename as the backing file");
5674 backing_fmt
= qemu_opt_get(opts
, BLOCK_OPT_BACKING_FMT
);
5676 backing_drv
= bdrv_find_format(backing_fmt
);
5678 error_setg(errp
, "Unknown backing file format '%s'",
5684 // The size for the image must always be specified, with one exception:
5685 // If we are using a backing file, we can obtain the size from there
5686 size
= qemu_opt_get_size(opts
, BLOCK_OPT_SIZE
, 0);
5689 BlockDriverState
*bs
;
5690 char *full_backing
= g_new0(char, PATH_MAX
);
5694 bdrv_get_full_backing_filename_from_filename(filename
, backing_file
,
5695 full_backing
, PATH_MAX
,
5698 g_free(full_backing
);
5702 /* backing files always opened read-only */
5704 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5707 ret
= bdrv_open(&bs
, full_backing
, NULL
, NULL
, back_flags
,
5708 backing_drv
, &local_err
);
5709 g_free(full_backing
);
5713 size
= bdrv_getlength(bs
);
5715 error_setg_errno(errp
, -size
, "Could not get size of '%s'",
5721 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, size
);
5725 error_setg(errp
, "Image creation needs a size parameter");
5731 printf("Formatting '%s', fmt=%s", filename
, fmt
);
5732 qemu_opts_print(opts
, " ");
5736 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
5738 if (ret
== -EFBIG
) {
5739 /* This is generally a better message than whatever the driver would
5740 * deliver (especially because of the cluster_size_hint), since that
5741 * is most probably not much different from "image too large". */
5742 const char *cluster_size_hint
= "";
5743 if (qemu_opt_get_size(opts
, BLOCK_OPT_CLUSTER_SIZE
, 0)) {
5744 cluster_size_hint
= " (try using a larger cluster size)";
5746 error_setg(errp
, "The image size is too large for file format '%s'"
5747 "%s", fmt
, cluster_size_hint
);
5748 error_free(local_err
);
5753 qemu_opts_del(opts
);
5754 qemu_opts_free(create_opts
);
5756 error_propagate(errp
, local_err
);
5760 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5762 return bs
->aio_context
;
5765 void bdrv_detach_aio_context(BlockDriverState
*bs
)
5767 BdrvAioNotifier
*baf
;
5773 QLIST_FOREACH(baf
, &bs
->aio_notifiers
, list
) {
5774 baf
->detach_aio_context(baf
->opaque
);
5777 if (bs
->io_limits_enabled
) {
5778 throttle_detach_aio_context(&bs
->throttle_state
);
5780 if (bs
->drv
->bdrv_detach_aio_context
) {
5781 bs
->drv
->bdrv_detach_aio_context(bs
);
5784 bdrv_detach_aio_context(bs
->file
);
5786 if (bs
->backing_hd
) {
5787 bdrv_detach_aio_context(bs
->backing_hd
);
5790 bs
->aio_context
= NULL
;
5793 void bdrv_attach_aio_context(BlockDriverState
*bs
,
5794 AioContext
*new_context
)
5796 BdrvAioNotifier
*ban
;
5802 bs
->aio_context
= new_context
;
5804 if (bs
->backing_hd
) {
5805 bdrv_attach_aio_context(bs
->backing_hd
, new_context
);
5808 bdrv_attach_aio_context(bs
->file
, new_context
);
5810 if (bs
->drv
->bdrv_attach_aio_context
) {
5811 bs
->drv
->bdrv_attach_aio_context(bs
, new_context
);
5813 if (bs
->io_limits_enabled
) {
5814 throttle_attach_aio_context(&bs
->throttle_state
, new_context
);
5817 QLIST_FOREACH(ban
, &bs
->aio_notifiers
, list
) {
5818 ban
->attached_aio_context(new_context
, ban
->opaque
);
5822 void bdrv_set_aio_context(BlockDriverState
*bs
, AioContext
*new_context
)
5824 bdrv_drain_all(); /* ensure there are no in-flight requests */
5826 bdrv_detach_aio_context(bs
);
5828 /* This function executes in the old AioContext so acquire the new one in
5829 * case it runs in a different thread.
5831 aio_context_acquire(new_context
);
5832 bdrv_attach_aio_context(bs
, new_context
);
5833 aio_context_release(new_context
);
5836 void bdrv_add_aio_context_notifier(BlockDriverState
*bs
,
5837 void (*attached_aio_context
)(AioContext
*new_context
, void *opaque
),
5838 void (*detach_aio_context
)(void *opaque
), void *opaque
)
5840 BdrvAioNotifier
*ban
= g_new(BdrvAioNotifier
, 1);
5841 *ban
= (BdrvAioNotifier
){
5842 .attached_aio_context
= attached_aio_context
,
5843 .detach_aio_context
= detach_aio_context
,
5847 QLIST_INSERT_HEAD(&bs
->aio_notifiers
, ban
, list
);
5850 void bdrv_remove_aio_context_notifier(BlockDriverState
*bs
,
5851 void (*attached_aio_context
)(AioContext
*,
5853 void (*detach_aio_context
)(void *),
5856 BdrvAioNotifier
*ban
, *ban_next
;
5858 QLIST_FOREACH_SAFE(ban
, &bs
->aio_notifiers
, list
, ban_next
) {
5859 if (ban
->attached_aio_context
== attached_aio_context
&&
5860 ban
->detach_aio_context
== detach_aio_context
&&
5861 ban
->opaque
== opaque
)
5863 QLIST_REMOVE(ban
, list
);
5873 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
5874 NotifierWithReturn
*notifier
)
5876 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
5879 int bdrv_amend_options(BlockDriverState
*bs
, QemuOpts
*opts
,
5880 BlockDriverAmendStatusCB
*status_cb
)
5882 if (!bs
->drv
->bdrv_amend_options
) {
5885 return bs
->drv
->bdrv_amend_options(bs
, opts
, status_cb
);
5888 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5889 * of block filter and by bdrv_is_first_non_filter.
5890 * It is used to test if the given bs is the candidate or recurse more in the
5893 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
5894 BlockDriverState
*candidate
)
5896 /* return false if basic checks fails */
5897 if (!bs
|| !bs
->drv
) {
5901 /* the code reached a non block filter driver -> check if the bs is
5902 * the same as the candidate. It's the recursion termination condition.
5904 if (!bs
->drv
->is_filter
) {
5905 return bs
== candidate
;
5907 /* Down this path the driver is a block filter driver */
5909 /* If the block filter recursion method is defined use it to recurse down
5912 if (bs
->drv
->bdrv_recurse_is_first_non_filter
) {
5913 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
5916 /* the driver is a block filter but don't allow to recurse -> return false
5921 /* This function checks if the candidate is the first non filter bs down it's
5922 * bs chain. Since we don't have pointers to parents it explore all bs chains
5923 * from the top. Some filters can choose not to pass down the recursion.
5925 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
5927 BlockDriverState
*bs
;
5929 /* walk down the bs forest recursively */
5930 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5933 /* try to recurse in this top level bs */
5934 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
5936 /* candidate is the first non filter */
5945 BlockDriverState
*check_to_replace_node(const char *node_name
, Error
**errp
)
5947 BlockDriverState
*to_replace_bs
= bdrv_find_node(node_name
);
5948 AioContext
*aio_context
;
5950 if (!to_replace_bs
) {
5951 error_setg(errp
, "Node name '%s' not found", node_name
);
5955 aio_context
= bdrv_get_aio_context(to_replace_bs
);
5956 aio_context_acquire(aio_context
);
5958 if (bdrv_op_is_blocked(to_replace_bs
, BLOCK_OP_TYPE_REPLACE
, errp
)) {
5959 to_replace_bs
= NULL
;
5963 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5964 * most non filter in order to prevent data corruption.
5965 * Another benefit is that this tests exclude backing files which are
5966 * blocked by the backing blockers.
5968 if (!bdrv_is_first_non_filter(to_replace_bs
)) {
5969 error_setg(errp
, "Only top most non filter can be replaced");
5970 to_replace_bs
= NULL
;
5975 aio_context_release(aio_context
);
5976 return to_replace_bs
;
5979 void bdrv_io_plug(BlockDriverState
*bs
)
5981 BlockDriver
*drv
= bs
->drv
;
5982 if (drv
&& drv
->bdrv_io_plug
) {
5983 drv
->bdrv_io_plug(bs
);
5984 } else if (bs
->file
) {
5985 bdrv_io_plug(bs
->file
);
5989 void bdrv_io_unplug(BlockDriverState
*bs
)
5991 BlockDriver
*drv
= bs
->drv
;
5992 if (drv
&& drv
->bdrv_io_unplug
) {
5993 drv
->bdrv_io_unplug(bs
);
5994 } else if (bs
->file
) {
5995 bdrv_io_unplug(bs
->file
);
5999 void bdrv_flush_io_queue(BlockDriverState
*bs
)
6001 BlockDriver
*drv
= bs
->drv
;
6002 if (drv
&& drv
->bdrv_flush_io_queue
) {
6003 drv
->bdrv_flush_io_queue(bs
);
6004 } else if (bs
->file
) {
6005 bdrv_flush_io_queue(bs
->file
);
6009 static bool append_open_options(QDict
*d
, BlockDriverState
*bs
)
6011 const QDictEntry
*entry
;
6012 bool found_any
= false;
6014 for (entry
= qdict_first(bs
->options
); entry
;
6015 entry
= qdict_next(bs
->options
, entry
))
6017 /* Only take options for this level and exclude all non-driver-specific
6019 if (!strchr(qdict_entry_key(entry
), '.') &&
6020 strcmp(qdict_entry_key(entry
), "node-name"))
6022 qobject_incref(qdict_entry_value(entry
));
6023 qdict_put_obj(d
, qdict_entry_key(entry
), qdict_entry_value(entry
));
6031 /* Updates the following BDS fields:
6032 * - exact_filename: A filename which may be used for opening a block device
6033 * which (mostly) equals the given BDS (even without any
6034 * other options; so reading and writing must return the same
6035 * results, but caching etc. may be different)
6036 * - full_open_options: Options which, when given when opening a block device
6037 * (without a filename), result in a BDS (mostly)
6038 * equalling the given one
6039 * - filename: If exact_filename is set, it is copied here. Otherwise,
6040 * full_open_options is converted to a JSON object, prefixed with
6041 * "json:" (for use through the JSON pseudo protocol) and put here.
6043 void bdrv_refresh_filename(BlockDriverState
*bs
)
6045 BlockDriver
*drv
= bs
->drv
;
6052 /* This BDS's file name will most probably depend on its file's name, so
6053 * refresh that first */
6055 bdrv_refresh_filename(bs
->file
);
6058 if (drv
->bdrv_refresh_filename
) {
6059 /* Obsolete information is of no use here, so drop the old file name
6060 * information before refreshing it */
6061 bs
->exact_filename
[0] = '\0';
6062 if (bs
->full_open_options
) {
6063 QDECREF(bs
->full_open_options
);
6064 bs
->full_open_options
= NULL
;
6067 drv
->bdrv_refresh_filename(bs
);
6068 } else if (bs
->file
) {
6069 /* Try to reconstruct valid information from the underlying file */
6070 bool has_open_options
;
6072 bs
->exact_filename
[0] = '\0';
6073 if (bs
->full_open_options
) {
6074 QDECREF(bs
->full_open_options
);
6075 bs
->full_open_options
= NULL
;
6079 has_open_options
= append_open_options(opts
, bs
);
6081 /* If no specific options have been given for this BDS, the filename of
6082 * the underlying file should suffice for this one as well */
6083 if (bs
->file
->exact_filename
[0] && !has_open_options
) {
6084 strcpy(bs
->exact_filename
, bs
->file
->exact_filename
);
6086 /* Reconstructing the full options QDict is simple for most format block
6087 * drivers, as long as the full options are known for the underlying
6088 * file BDS. The full options QDict of that file BDS should somehow
6089 * contain a representation of the filename, therefore the following
6090 * suffices without querying the (exact_)filename of this BDS. */
6091 if (bs
->file
->full_open_options
) {
6092 qdict_put_obj(opts
, "driver",
6093 QOBJECT(qstring_from_str(drv
->format_name
)));
6094 QINCREF(bs
->file
->full_open_options
);
6095 qdict_put_obj(opts
, "file", QOBJECT(bs
->file
->full_open_options
));
6097 bs
->full_open_options
= opts
;
6101 } else if (!bs
->full_open_options
&& qdict_size(bs
->options
)) {
6102 /* There is no underlying file BDS (at least referenced by BDS.file),
6103 * so the full options QDict should be equal to the options given
6104 * specifically for this block device when it was opened (plus the
6105 * driver specification).
6106 * Because those options don't change, there is no need to update
6107 * full_open_options when it's already set. */
6110 append_open_options(opts
, bs
);
6111 qdict_put_obj(opts
, "driver",
6112 QOBJECT(qstring_from_str(drv
->format_name
)));
6114 if (bs
->exact_filename
[0]) {
6115 /* This may not work for all block protocol drivers (some may
6116 * require this filename to be parsed), but we have to find some
6117 * default solution here, so just include it. If some block driver
6118 * does not support pure options without any filename at all or
6119 * needs some special format of the options QDict, it needs to
6120 * implement the driver-specific bdrv_refresh_filename() function.
6122 qdict_put_obj(opts
, "filename",
6123 QOBJECT(qstring_from_str(bs
->exact_filename
)));
6126 bs
->full_open_options
= opts
;
6129 if (bs
->exact_filename
[0]) {
6130 pstrcpy(bs
->filename
, sizeof(bs
->filename
), bs
->exact_filename
);
6131 } else if (bs
->full_open_options
) {
6132 QString
*json
= qobject_to_json(QOBJECT(bs
->full_open_options
));
6133 snprintf(bs
->filename
, sizeof(bs
->filename
), "json:%s",
6134 qstring_get_str(json
));
6139 /* This accessor function purpose is to allow the device models to access the
6140 * BlockAcctStats structure embedded inside a BlockDriverState without being
6141 * aware of the BlockDriverState structure layout.
6142 * It will go away when the BlockAcctStats structure will be moved inside
6143 * the device models.
6145 BlockAcctStats
*bdrv_get_stats(BlockDriverState
*bs
)