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 "monitor/monitor.h"
28 #include "block/block_int.h"
29 #include "block/blockjob.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qjson.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
39 #include <sys/types.h>
41 #include <sys/ioctl.h>
42 #include <sys/queue.h>
52 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
55 BDRV_REQ_COPY_ON_READ
= 0x1,
56 BDRV_REQ_ZERO_WRITE
= 0x2,
57 BDRV_REQ_BACKUP_ONLY
= 0x4,
60 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
61 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
62 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
63 BlockDriverCompletionFunc
*cb
, void *opaque
);
64 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
65 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
66 BlockDriverCompletionFunc
*cb
, void *opaque
);
67 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
68 int64_t sector_num
, int nb_sectors
,
70 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
71 int64_t sector_num
, int nb_sectors
,
73 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
74 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
75 BdrvRequestFlags flags
);
76 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
77 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
78 BdrvRequestFlags flags
);
79 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
83 BlockDriverCompletionFunc
*cb
,
86 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
87 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
88 int64_t sector_num
, int nb_sectors
);
90 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
91 bool is_write
, double elapsed_time
, uint64_t *wait
);
92 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
93 double elapsed_time
, uint64_t *wait
);
94 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
95 bool is_write
, int64_t *wait
);
97 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
98 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
100 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
101 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
103 /* The device to use for VM snapshots */
104 static BlockDriverState
*bs_snapshots
;
106 /* If non-zero, use only whitelisted block drivers */
107 static int use_bdrv_whitelist
;
110 static int is_windows_drive_prefix(const char *filename
)
112 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
113 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
117 int is_windows_drive(const char *filename
)
119 if (is_windows_drive_prefix(filename
) &&
122 if (strstart(filename
, "\\\\.\\", NULL
) ||
123 strstart(filename
, "//./", NULL
))
129 /* throttling disk I/O limits */
130 void bdrv_io_limits_disable(BlockDriverState
*bs
)
132 bs
->io_limits_enabled
= false;
134 while (qemu_co_queue_next(&bs
->throttled_reqs
));
136 if (bs
->block_timer
) {
137 qemu_del_timer(bs
->block_timer
);
138 qemu_free_timer(bs
->block_timer
);
139 bs
->block_timer
= NULL
;
145 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
148 static void bdrv_block_timer(void *opaque
)
150 BlockDriverState
*bs
= opaque
;
152 qemu_co_queue_next(&bs
->throttled_reqs
);
155 void bdrv_io_limits_enable(BlockDriverState
*bs
)
157 qemu_co_queue_init(&bs
->throttled_reqs
);
158 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
159 bs
->io_limits_enabled
= true;
162 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
164 BlockIOLimit
*io_limits
= &bs
->io_limits
;
165 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
166 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
167 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
168 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
169 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
170 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
173 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
174 bool is_write
, int nb_sectors
)
176 int64_t wait_time
= -1;
178 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
179 qemu_co_queue_wait(&bs
->throttled_reqs
);
182 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
183 * throttled requests will not be dequeued until the current request is
184 * allowed to be serviced. So if the current request still exceeds the
185 * limits, it will be inserted to the head. All requests followed it will
186 * be still in throttled_reqs queue.
189 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
190 qemu_mod_timer(bs
->block_timer
,
191 wait_time
+ qemu_get_clock_ns(vm_clock
));
192 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
195 qemu_co_queue_next(&bs
->throttled_reqs
);
198 /* check if the path starts with "<protocol>:" */
199 static int path_has_protocol(const char *path
)
204 if (is_windows_drive(path
) ||
205 is_windows_drive_prefix(path
)) {
208 p
= path
+ strcspn(path
, ":/\\");
210 p
= path
+ strcspn(path
, ":/");
216 int path_is_absolute(const char *path
)
219 /* specific case for names like: "\\.\d:" */
220 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
223 return (*path
== '/' || *path
== '\\');
225 return (*path
== '/');
229 /* if filename is absolute, just copy it to dest. Otherwise, build a
230 path to it by considering it is relative to base_path. URL are
232 void path_combine(char *dest
, int dest_size
,
233 const char *base_path
,
234 const char *filename
)
241 if (path_is_absolute(filename
)) {
242 pstrcpy(dest
, dest_size
, filename
);
244 p
= strchr(base_path
, ':');
249 p1
= strrchr(base_path
, '/');
253 p2
= strrchr(base_path
, '\\');
265 if (len
> dest_size
- 1)
267 memcpy(dest
, base_path
, len
);
269 pstrcat(dest
, dest_size
, filename
);
273 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
275 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
276 pstrcpy(dest
, sz
, bs
->backing_file
);
278 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
282 void bdrv_register(BlockDriver
*bdrv
)
284 /* Block drivers without coroutine functions need emulation */
285 if (!bdrv
->bdrv_co_readv
) {
286 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
287 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
289 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
290 * the block driver lacks aio we need to emulate that too.
292 if (!bdrv
->bdrv_aio_readv
) {
293 /* add AIO emulation layer */
294 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
295 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
299 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
302 /* create a new block device (by default it is empty) */
303 BlockDriverState
*bdrv_new(const char *device_name
)
305 BlockDriverState
*bs
;
307 bs
= g_malloc0(sizeof(BlockDriverState
));
308 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
309 if (device_name
[0] != '\0') {
310 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
312 bdrv_iostatus_disable(bs
);
313 notifier_list_init(&bs
->close_notifiers
);
318 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
320 notifier_list_add(&bs
->close_notifiers
, notify
);
323 BlockDriver
*bdrv_find_format(const char *format_name
)
326 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
327 if (!strcmp(drv1
->format_name
, format_name
)) {
334 static int bdrv_is_whitelisted(BlockDriver
*drv
)
336 static const char *whitelist
[] = {
337 CONFIG_BDRV_WHITELIST
342 return 1; /* no whitelist, anything goes */
344 for (p
= whitelist
; *p
; p
++) {
345 if (!strcmp(drv
->format_name
, *p
)) {
352 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
)
354 BlockDriver
*drv
= bdrv_find_format(format_name
);
355 return drv
&& bdrv_is_whitelisted(drv
) ? drv
: NULL
;
358 typedef struct CreateCo
{
361 QEMUOptionParameter
*options
;
365 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
367 CreateCo
*cco
= opaque
;
370 cco
->ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
);
373 int bdrv_create(BlockDriver
*drv
, const char* filename
,
374 QEMUOptionParameter
*options
)
381 .filename
= g_strdup(filename
),
386 if (!drv
->bdrv_create
) {
391 if (qemu_in_coroutine()) {
392 /* Fast-path if already in coroutine context */
393 bdrv_create_co_entry(&cco
);
395 co
= qemu_coroutine_create(bdrv_create_co_entry
);
396 qemu_coroutine_enter(co
, &cco
);
397 while (cco
.ret
== NOT_DONE
) {
405 g_free(cco
.filename
);
409 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
413 drv
= bdrv_find_protocol(filename
);
418 return bdrv_create(drv
, filename
, options
);
422 * Create a uniquely-named empty temporary file.
423 * Return 0 upon success, otherwise a negative errno value.
425 int get_tmp_filename(char *filename
, int size
)
428 char temp_dir
[MAX_PATH
];
429 /* GetTempFileName requires that its output buffer (4th param)
430 have length MAX_PATH or greater. */
431 assert(size
>= MAX_PATH
);
432 return (GetTempPath(MAX_PATH
, temp_dir
)
433 && GetTempFileName(temp_dir
, "qem", 0, filename
)
434 ? 0 : -GetLastError());
438 tmpdir
= getenv("TMPDIR");
441 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
444 fd
= mkstemp(filename
);
448 if (close(fd
) != 0) {
457 * Detect host devices. By convention, /dev/cdrom[N] is always
458 * recognized as a host CDROM.
460 static BlockDriver
*find_hdev_driver(const char *filename
)
462 int score_max
= 0, score
;
463 BlockDriver
*drv
= NULL
, *d
;
465 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
466 if (d
->bdrv_probe_device
) {
467 score
= d
->bdrv_probe_device(filename
);
468 if (score
> score_max
) {
478 BlockDriver
*bdrv_find_protocol(const char *filename
)
485 /* TODO Drivers without bdrv_file_open must be specified explicitly */
488 * XXX(hch): we really should not let host device detection
489 * override an explicit protocol specification, but moving this
490 * later breaks access to device names with colons in them.
491 * Thanks to the brain-dead persistent naming schemes on udev-
492 * based Linux systems those actually are quite common.
494 drv1
= find_hdev_driver(filename
);
499 if (!path_has_protocol(filename
)) {
500 return bdrv_find_format("file");
502 p
= strchr(filename
, ':');
505 if (len
> sizeof(protocol
) - 1)
506 len
= sizeof(protocol
) - 1;
507 memcpy(protocol
, filename
, len
);
508 protocol
[len
] = '\0';
509 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
510 if (drv1
->protocol_name
&&
511 !strcmp(drv1
->protocol_name
, protocol
)) {
518 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
521 int score
, score_max
;
522 BlockDriver
*drv1
, *drv
;
526 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
527 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
528 drv
= bdrv_find_format("raw");
536 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
544 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
545 if (drv1
->bdrv_probe
) {
546 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
547 if (score
> score_max
) {
561 * Set the current 'total_sectors' value
563 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
565 BlockDriver
*drv
= bs
->drv
;
567 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
571 /* query actual device if possible, otherwise just trust the hint */
572 if (drv
->bdrv_getlength
) {
573 int64_t length
= drv
->bdrv_getlength(bs
);
577 hint
= length
>> BDRV_SECTOR_BITS
;
580 bs
->total_sectors
= hint
;
585 * Set open flags for a given cache mode
587 * Return 0 on success, -1 if the cache mode was invalid.
589 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
591 *flags
&= ~BDRV_O_CACHE_MASK
;
593 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
594 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
595 } else if (!strcmp(mode
, "directsync")) {
596 *flags
|= BDRV_O_NOCACHE
;
597 } else if (!strcmp(mode
, "writeback")) {
598 *flags
|= BDRV_O_CACHE_WB
;
599 } else if (!strcmp(mode
, "unsafe")) {
600 *flags
|= BDRV_O_CACHE_WB
;
601 *flags
|= BDRV_O_NO_FLUSH
;
602 } else if (!strcmp(mode
, "writethrough")) {
603 /* this is the default */
612 * The copy-on-read flag is actually a reference count so multiple users may
613 * use the feature without worrying about clobbering its previous state.
614 * Copy-on-read stays enabled until all users have called to disable it.
616 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
621 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
623 assert(bs
->copy_on_read
> 0);
627 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
629 int open_flags
= flags
| BDRV_O_CACHE_WB
;
632 * Clear flags that are internal to the block layer before opening the
635 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
638 * Snapshots should be writable.
640 if (bs
->is_temporary
) {
641 open_flags
|= BDRV_O_RDWR
;
648 * Common part for opening disk images and files
650 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
651 const char *filename
,
652 int flags
, BlockDriver
*drv
)
657 assert(bs
->file
== NULL
);
659 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
661 bs
->open_flags
= flags
;
662 bs
->buffer_alignment
= 512;
664 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
665 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
666 bdrv_enable_copy_on_read(bs
);
669 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
671 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
676 bs
->opaque
= g_malloc0(drv
->instance_size
);
678 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
679 open_flags
= bdrv_open_flags(bs
, flags
);
681 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
683 /* Open the image, either directly or using a protocol */
684 if (drv
->bdrv_file_open
) {
689 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
692 assert(file
!= NULL
);
694 ret
= drv
->bdrv_open(bs
, open_flags
);
701 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
707 if (bs
->is_temporary
) {
722 * Opens a file using a protocol (file, host_device, nbd, ...)
724 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
726 BlockDriverState
*bs
;
730 drv
= bdrv_find_protocol(filename
);
736 ret
= bdrv_open_common(bs
, NULL
, filename
, flags
, drv
);
746 int bdrv_open_backing_file(BlockDriverState
*bs
)
748 char backing_filename
[PATH_MAX
];
750 BlockDriver
*back_drv
= NULL
;
752 if (bs
->backing_hd
!= NULL
) {
756 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
757 if (bs
->backing_file
[0] == '\0') {
761 bs
->backing_hd
= bdrv_new("");
762 bdrv_get_full_backing_filename(bs
, backing_filename
,
763 sizeof(backing_filename
));
765 if (bs
->backing_format
[0] != '\0') {
766 back_drv
= bdrv_find_format(bs
->backing_format
);
769 /* backing files always opened read-only */
770 back_flags
= bs
->open_flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
);
772 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, back_flags
, back_drv
);
774 bdrv_delete(bs
->backing_hd
);
775 bs
->backing_hd
= NULL
;
776 bs
->open_flags
|= BDRV_O_NO_BACKING
;
783 * Opens a disk image (raw, qcow2, vmdk, ...)
785 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int flags
,
789 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
790 char tmp_filename
[PATH_MAX
+ 1];
791 BlockDriverState
*file
= NULL
;
793 if (flags
& BDRV_O_SNAPSHOT
) {
794 BlockDriverState
*bs1
;
797 BlockDriver
*bdrv_qcow2
;
798 QEMUOptionParameter
*options
;
799 char backing_filename
[PATH_MAX
];
801 /* if snapshot, we create a temporary backing file and open it
802 instead of opening 'filename' directly */
804 /* if there is a backing file, use it */
806 ret
= bdrv_open(bs1
, filename
, 0, drv
);
811 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
813 if (bs1
->drv
&& bs1
->drv
->protocol_name
)
818 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
823 /* Real path is meaningless for protocols */
825 snprintf(backing_filename
, sizeof(backing_filename
),
827 else if (!realpath(filename
, backing_filename
))
830 bdrv_qcow2
= bdrv_find_format("qcow2");
831 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
833 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
834 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
836 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
840 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
841 free_option_parameters(options
);
846 filename
= tmp_filename
;
848 bs
->is_temporary
= 1;
851 /* Open image file without format layer */
852 if (flags
& BDRV_O_RDWR
) {
853 flags
|= BDRV_O_ALLOW_RDWR
;
856 ret
= bdrv_file_open(&file
, filename
, bdrv_open_flags(bs
, flags
));
861 /* Find the right image format driver */
863 ret
= find_image_format(file
, filename
, &drv
);
867 goto unlink_and_fail
;
871 ret
= bdrv_open_common(bs
, file
, filename
, flags
, drv
);
873 goto unlink_and_fail
;
876 if (bs
->file
!= file
) {
881 /* If there is a backing file, use it */
882 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
883 ret
= bdrv_open_backing_file(bs
);
890 if (!bdrv_key_required(bs
)) {
891 bdrv_dev_change_media_cb(bs
, true);
894 /* throttling disk I/O limits */
895 if (bs
->io_limits_enabled
) {
896 bdrv_io_limits_enable(bs
);
905 if (bs
->is_temporary
) {
911 typedef struct BlockReopenQueueEntry
{
913 BDRVReopenState state
;
914 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
915 } BlockReopenQueueEntry
;
918 * Adds a BlockDriverState to a simple queue for an atomic, transactional
919 * reopen of multiple devices.
921 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
922 * already performed, or alternatively may be NULL a new BlockReopenQueue will
923 * be created and initialized. This newly created BlockReopenQueue should be
924 * passed back in for subsequent calls that are intended to be of the same
927 * bs is the BlockDriverState to add to the reopen queue.
929 * flags contains the open flags for the associated bs
931 * returns a pointer to bs_queue, which is either the newly allocated
932 * bs_queue, or the existing bs_queue being used.
935 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
936 BlockDriverState
*bs
, int flags
)
940 BlockReopenQueueEntry
*bs_entry
;
941 if (bs_queue
== NULL
) {
942 bs_queue
= g_new0(BlockReopenQueue
, 1);
943 QSIMPLEQ_INIT(bs_queue
);
947 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
950 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
951 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
953 bs_entry
->state
.bs
= bs
;
954 bs_entry
->state
.flags
= flags
;
960 * Reopen multiple BlockDriverStates atomically & transactionally.
962 * The queue passed in (bs_queue) must have been built up previous
963 * via bdrv_reopen_queue().
965 * Reopens all BDS specified in the queue, with the appropriate
966 * flags. All devices are prepared for reopen, and failure of any
967 * device will cause all device changes to be abandonded, and intermediate
970 * If all devices prepare successfully, then the changes are committed
974 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
977 BlockReopenQueueEntry
*bs_entry
, *next
;
978 Error
*local_err
= NULL
;
980 assert(bs_queue
!= NULL
);
984 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
985 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
986 error_propagate(errp
, local_err
);
989 bs_entry
->prepared
= true;
992 /* If we reach this point, we have success and just need to apply the
995 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
996 bdrv_reopen_commit(&bs_entry
->state
);
1002 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1003 if (ret
&& bs_entry
->prepared
) {
1004 bdrv_reopen_abort(&bs_entry
->state
);
1013 /* Reopen a single BlockDriverState with the specified flags. */
1014 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1017 Error
*local_err
= NULL
;
1018 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1020 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1021 if (local_err
!= NULL
) {
1022 error_propagate(errp
, local_err
);
1029 * Prepares a BlockDriverState for reopen. All changes are staged in the
1030 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1031 * the block driver layer .bdrv_reopen_prepare()
1033 * bs is the BlockDriverState to reopen
1034 * flags are the new open flags
1035 * queue is the reopen queue
1037 * Returns 0 on success, non-zero on error. On error errp will be set
1040 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1041 * It is the responsibility of the caller to then call the abort() or
1042 * commit() for any other BDS that have been left in a prepare() state
1045 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1049 Error
*local_err
= NULL
;
1052 assert(reopen_state
!= NULL
);
1053 assert(reopen_state
->bs
->drv
!= NULL
);
1054 drv
= reopen_state
->bs
->drv
;
1056 /* if we are to stay read-only, do not allow permission change
1058 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1059 reopen_state
->flags
& BDRV_O_RDWR
) {
1060 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1061 reopen_state
->bs
->device_name
);
1066 ret
= bdrv_flush(reopen_state
->bs
);
1068 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1073 if (drv
->bdrv_reopen_prepare
) {
1074 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1076 if (local_err
!= NULL
) {
1077 error_propagate(errp
, local_err
);
1079 error_set(errp
, QERR_OPEN_FILE_FAILED
,
1080 reopen_state
->bs
->filename
);
1085 /* It is currently mandatory to have a bdrv_reopen_prepare()
1086 * handler for each supported drv. */
1087 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1088 drv
->format_name
, reopen_state
->bs
->device_name
,
1089 "reopening of file");
1101 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1102 * makes them final by swapping the staging BlockDriverState contents into
1103 * the active BlockDriverState contents.
1105 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1109 assert(reopen_state
!= NULL
);
1110 drv
= reopen_state
->bs
->drv
;
1111 assert(drv
!= NULL
);
1113 /* If there are any driver level actions to take */
1114 if (drv
->bdrv_reopen_commit
) {
1115 drv
->bdrv_reopen_commit(reopen_state
);
1118 /* set BDS specific flags now */
1119 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1120 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1122 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1126 * Abort the reopen, and delete and free the staged changes in
1129 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1133 assert(reopen_state
!= NULL
);
1134 drv
= reopen_state
->bs
->drv
;
1135 assert(drv
!= NULL
);
1137 if (drv
->bdrv_reopen_abort
) {
1138 drv
->bdrv_reopen_abort(reopen_state
);
1143 void bdrv_close(BlockDriverState
*bs
)
1147 block_job_cancel_sync(bs
->job
);
1150 notifier_list_notify(&bs
->close_notifiers
, bs
);
1153 if (bs
== bs_snapshots
) {
1154 bs_snapshots
= NULL
;
1156 if (bs
->backing_hd
) {
1157 bdrv_delete(bs
->backing_hd
);
1158 bs
->backing_hd
= NULL
;
1160 bs
->drv
->bdrv_close(bs
);
1163 if (bs
->is_temporary
) {
1164 unlink(bs
->filename
);
1169 bs
->copy_on_read
= 0;
1170 bs
->backing_file
[0] = '\0';
1171 bs
->backing_format
[0] = '\0';
1172 bs
->total_sectors
= 0;
1178 if (bs
->file
!= NULL
) {
1179 bdrv_delete(bs
->file
);
1184 bdrv_dev_change_media_cb(bs
, false);
1186 /*throttling disk I/O limits*/
1187 if (bs
->io_limits_enabled
) {
1188 bdrv_io_limits_disable(bs
);
1192 void bdrv_close_all(void)
1194 BlockDriverState
*bs
;
1196 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1202 * Wait for pending requests to complete across all BlockDriverStates
1204 * This function does not flush data to disk, use bdrv_flush_all() for that
1205 * after calling this function.
1207 * Note that completion of an asynchronous I/O operation can trigger any
1208 * number of other I/O operations on other devices---for example a coroutine
1209 * can be arbitrarily complex and a constant flow of I/O can come until the
1210 * coroutine is complete. Because of this, it is not possible to have a
1211 * function to drain a single device's I/O queue.
1213 void bdrv_drain_all(void)
1215 BlockDriverState
*bs
;
1219 busy
= qemu_aio_wait();
1221 /* FIXME: We do not have timer support here, so this is effectively
1224 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1225 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
1226 qemu_co_queue_restart_all(&bs
->throttled_reqs
);
1232 /* If requests are still pending there is a bug somewhere */
1233 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1234 assert(QLIST_EMPTY(&bs
->tracked_requests
));
1235 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
1239 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1240 Also, NULL terminate the device_name to prevent double remove */
1241 void bdrv_make_anon(BlockDriverState
*bs
)
1243 if (bs
->device_name
[0] != '\0') {
1244 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
1246 bs
->device_name
[0] = '\0';
1249 static void bdrv_rebind(BlockDriverState
*bs
)
1251 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1252 bs
->drv
->bdrv_rebind(bs
);
1256 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1257 BlockDriverState
*bs_src
)
1259 /* move some fields that need to stay attached to the device */
1260 bs_dest
->open_flags
= bs_src
->open_flags
;
1263 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1264 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1265 bs_dest
->dev
= bs_src
->dev
;
1266 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
1267 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1269 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1271 /* i/o timing parameters */
1272 bs_dest
->slice_time
= bs_src
->slice_time
;
1273 bs_dest
->slice_start
= bs_src
->slice_start
;
1274 bs_dest
->slice_end
= bs_src
->slice_end
;
1275 bs_dest
->io_limits
= bs_src
->io_limits
;
1276 bs_dest
->io_base
= bs_src
->io_base
;
1277 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
1278 bs_dest
->block_timer
= bs_src
->block_timer
;
1279 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1282 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1283 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1286 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1287 bs_dest
->iostatus
= bs_src
->iostatus
;
1290 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1293 bs_dest
->in_use
= bs_src
->in_use
;
1294 bs_dest
->job
= bs_src
->job
;
1296 /* keep the same entry in bdrv_states */
1297 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1298 bs_src
->device_name
);
1299 bs_dest
->list
= bs_src
->list
;
1303 * Swap bs contents for two image chains while they are live,
1304 * while keeping required fields on the BlockDriverState that is
1305 * actually attached to a device.
1307 * This will modify the BlockDriverState fields, and swap contents
1308 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1310 * bs_new is required to be anonymous.
1312 * This function does not create any image files.
1314 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1316 BlockDriverState tmp
;
1318 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1319 assert(bs_new
->device_name
[0] == '\0');
1320 assert(bs_new
->dirty_bitmap
== NULL
);
1321 assert(bs_new
->job
== NULL
);
1322 assert(bs_new
->dev
== NULL
);
1323 assert(bs_new
->in_use
== 0);
1324 assert(bs_new
->io_limits_enabled
== false);
1325 assert(bs_new
->block_timer
== NULL
);
1331 /* there are some fields that should not be swapped, move them back */
1332 bdrv_move_feature_fields(&tmp
, bs_old
);
1333 bdrv_move_feature_fields(bs_old
, bs_new
);
1334 bdrv_move_feature_fields(bs_new
, &tmp
);
1336 /* bs_new shouldn't be in bdrv_states even after the swap! */
1337 assert(bs_new
->device_name
[0] == '\0');
1339 /* Check a few fields that should remain attached to the device */
1340 assert(bs_new
->dev
== NULL
);
1341 assert(bs_new
->job
== NULL
);
1342 assert(bs_new
->in_use
== 0);
1343 assert(bs_new
->io_limits_enabled
== false);
1344 assert(bs_new
->block_timer
== NULL
);
1346 bdrv_rebind(bs_new
);
1347 bdrv_rebind(bs_old
);
1351 * Add new bs contents at the top of an image chain while the chain is
1352 * live, while keeping required fields on the top layer.
1354 * This will modify the BlockDriverState fields, and swap contents
1355 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1357 * bs_new is required to be anonymous.
1359 * This function does not create any image files.
1361 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1363 bdrv_swap(bs_new
, bs_top
);
1365 /* The contents of 'tmp' will become bs_top, as we are
1366 * swapping bs_new and bs_top contents. */
1367 bs_top
->backing_hd
= bs_new
;
1368 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1369 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1371 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1372 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1375 void bdrv_delete(BlockDriverState
*bs
)
1379 assert(!bs
->in_use
);
1381 /* remove from list, if necessary */
1386 assert(bs
!= bs_snapshots
);
1390 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1391 /* TODO change to DeviceState *dev when all users are qdevified */
1397 bdrv_iostatus_reset(bs
);
1401 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1402 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1404 if (bdrv_attach_dev(bs
, dev
) < 0) {
1409 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1410 /* TODO change to DeviceState *dev when all users are qdevified */
1412 assert(bs
->dev
== dev
);
1415 bs
->dev_opaque
= NULL
;
1416 bs
->buffer_alignment
= 512;
1419 /* TODO change to return DeviceState * when all users are qdevified */
1420 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1425 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1429 bs
->dev_opaque
= opaque
;
1430 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1431 bs_snapshots
= NULL
;
1435 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1436 enum MonitorEvent ev
,
1437 BlockErrorAction action
, bool is_read
)
1440 const char *action_str
;
1443 case BDRV_ACTION_REPORT
:
1444 action_str
= "report";
1446 case BDRV_ACTION_IGNORE
:
1447 action_str
= "ignore";
1449 case BDRV_ACTION_STOP
:
1450 action_str
= "stop";
1456 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1459 is_read
? "read" : "write");
1460 monitor_protocol_event(ev
, data
);
1462 qobject_decref(data
);
1465 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1469 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1470 bdrv_get_device_name(bs
), ejected
);
1471 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1473 qobject_decref(data
);
1476 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1478 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1479 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1480 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1481 if (tray_was_closed
) {
1483 bdrv_emit_qmp_eject_event(bs
, true);
1487 bdrv_emit_qmp_eject_event(bs
, false);
1492 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1494 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1497 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1499 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1500 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1504 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1506 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1507 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1512 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1514 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1515 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1519 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1521 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1522 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1528 * Run consistency checks on an image
1530 * Returns 0 if the check could be completed (it doesn't mean that the image is
1531 * free of errors) or -errno when an internal error occurred. The results of the
1532 * check are stored in res.
1534 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1536 if (bs
->drv
->bdrv_check
== NULL
) {
1540 memset(res
, 0, sizeof(*res
));
1541 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1544 #define COMMIT_BUF_SECTORS 2048
1546 /* commit COW file into the raw image */
1547 int bdrv_commit(BlockDriverState
*bs
)
1549 BlockDriver
*drv
= bs
->drv
;
1550 int64_t sector
, total_sectors
;
1551 int n
, ro
, open_flags
;
1554 char filename
[PATH_MAX
];
1559 if (!bs
->backing_hd
) {
1563 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1567 ro
= bs
->backing_hd
->read_only
;
1568 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1569 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
1570 open_flags
= bs
->backing_hd
->open_flags
;
1573 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
1578 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1579 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1581 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1582 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1584 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1589 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1596 if (drv
->bdrv_make_empty
) {
1597 ret
= drv
->bdrv_make_empty(bs
);
1602 * Make sure all data we wrote to the backing device is actually
1606 bdrv_flush(bs
->backing_hd
);
1612 /* ignoring error return here */
1613 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
1619 int bdrv_commit_all(void)
1621 BlockDriverState
*bs
;
1623 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1624 int ret
= bdrv_commit(bs
);
1632 struct BdrvTrackedRequest
{
1633 BlockDriverState
*bs
;
1637 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1638 Coroutine
*co
; /* owner, used for deadlock detection */
1639 CoQueue wait_queue
; /* coroutines blocked on this request */
1643 * Remove an active request from the tracked requests list
1645 * This function should be called when a tracked request is completing.
1647 static void tracked_request_end(BdrvTrackedRequest
*req
)
1649 QLIST_REMOVE(req
, list
);
1650 qemu_co_queue_restart_all(&req
->wait_queue
);
1654 * Add an active request to the tracked requests list
1656 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1657 BlockDriverState
*bs
,
1659 int nb_sectors
, bool is_write
)
1661 *req
= (BdrvTrackedRequest
){
1663 .sector_num
= sector_num
,
1664 .nb_sectors
= nb_sectors
,
1665 .is_write
= is_write
,
1666 .co
= qemu_coroutine_self(),
1669 qemu_co_queue_init(&req
->wait_queue
);
1671 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1675 * Round a region to cluster boundaries
1677 void bdrv_round_to_clusters(BlockDriverState
*bs
,
1678 int64_t sector_num
, int nb_sectors
,
1679 int64_t *cluster_sector_num
,
1680 int *cluster_nb_sectors
)
1682 BlockDriverInfo bdi
;
1684 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1685 *cluster_sector_num
= sector_num
;
1686 *cluster_nb_sectors
= nb_sectors
;
1688 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1689 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1690 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1696 * Round a region to job cluster boundaries
1698 static void round_to_job_clusters(BlockDriverState
*bs
,
1699 int64_t sector_num
, int nb_sectors
,
1700 int job_cluster_size
,
1701 int64_t *cluster_sector_num
,
1702 int *cluster_nb_sectors
)
1704 int64_t c
= job_cluster_size
/BDRV_SECTOR_SIZE
;
1706 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1707 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1711 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1712 int64_t sector_num
, int nb_sectors
) {
1714 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1718 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1724 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1727 int job_cluster_size
)
1729 BdrvTrackedRequest
*req
;
1730 int64_t cluster_sector_num
;
1731 int cluster_nb_sectors
;
1734 /* If we touch the same cluster it counts as an overlap. This guarantees
1735 * that allocating writes will be serialized and not race with each other
1736 * for the same cluster. For example, in copy-on-read it ensures that the
1737 * CoR read and write operations are atomic and guest writes cannot
1738 * interleave between them.
1740 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
1741 &cluster_sector_num
, &cluster_nb_sectors
);
1743 if (job_cluster_size
) {
1744 round_to_job_clusters(bs
, sector_num
, nb_sectors
, job_cluster_size
,
1745 &cluster_sector_num
, &cluster_nb_sectors
);
1750 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1751 if (tracked_request_overlaps(req
, cluster_sector_num
,
1752 cluster_nb_sectors
)) {
1753 /* Hitting this means there was a reentrant request, for
1754 * example, a block driver issuing nested requests. This must
1755 * never happen since it means deadlock.
1757 assert(qemu_coroutine_self() != req
->co
);
1759 qemu_co_queue_wait(&req
->wait_queue
);
1770 * -EINVAL - backing format specified, but no file
1771 * -ENOSPC - can't update the backing file because no space is left in the
1773 * -ENOTSUP - format driver doesn't support changing the backing file
1775 int bdrv_change_backing_file(BlockDriverState
*bs
,
1776 const char *backing_file
, const char *backing_fmt
)
1778 BlockDriver
*drv
= bs
->drv
;
1781 /* Backing file format doesn't make sense without a backing file */
1782 if (backing_fmt
&& !backing_file
) {
1786 if (drv
->bdrv_change_backing_file
!= NULL
) {
1787 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1793 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1794 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1800 * Finds the image layer in the chain that has 'bs' as its backing file.
1802 * active is the current topmost image.
1804 * Returns NULL if bs is not found in active's image chain,
1805 * or if active == bs.
1807 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
1808 BlockDriverState
*bs
)
1810 BlockDriverState
*overlay
= NULL
;
1811 BlockDriverState
*intermediate
;
1813 assert(active
!= NULL
);
1816 /* if bs is the same as active, then by definition it has no overlay
1822 intermediate
= active
;
1823 while (intermediate
->backing_hd
) {
1824 if (intermediate
->backing_hd
== bs
) {
1825 overlay
= intermediate
;
1828 intermediate
= intermediate
->backing_hd
;
1834 typedef struct BlkIntermediateStates
{
1835 BlockDriverState
*bs
;
1836 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
1837 } BlkIntermediateStates
;
1841 * Drops images above 'base' up to and including 'top', and sets the image
1842 * above 'top' to have base as its backing file.
1844 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1845 * information in 'bs' can be properly updated.
1847 * E.g., this will convert the following chain:
1848 * bottom <- base <- intermediate <- top <- active
1852 * bottom <- base <- active
1854 * It is allowed for bottom==base, in which case it converts:
1856 * base <- intermediate <- top <- active
1863 * if active == top, that is considered an error
1866 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
1867 BlockDriverState
*base
)
1869 BlockDriverState
*intermediate
;
1870 BlockDriverState
*base_bs
= NULL
;
1871 BlockDriverState
*new_top_bs
= NULL
;
1872 BlkIntermediateStates
*intermediate_state
, *next
;
1875 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
1876 QSIMPLEQ_INIT(&states_to_delete
);
1878 if (!top
->drv
|| !base
->drv
) {
1882 new_top_bs
= bdrv_find_overlay(active
, top
);
1884 if (new_top_bs
== NULL
) {
1885 /* we could not find the image above 'top', this is an error */
1889 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1890 * to do, no intermediate images */
1891 if (new_top_bs
->backing_hd
== base
) {
1898 /* now we will go down through the list, and add each BDS we find
1899 * into our deletion queue, until we hit the 'base'
1901 while (intermediate
) {
1902 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
1903 intermediate_state
->bs
= intermediate
;
1904 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
1906 if (intermediate
->backing_hd
== base
) {
1907 base_bs
= intermediate
->backing_hd
;
1910 intermediate
= intermediate
->backing_hd
;
1912 if (base_bs
== NULL
) {
1913 /* something went wrong, we did not end at the base. safely
1914 * unravel everything, and exit with error */
1918 /* success - we can delete the intermediate states, and link top->base */
1919 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
1920 base_bs
->drv
? base_bs
->drv
->format_name
: "");
1924 new_top_bs
->backing_hd
= base_bs
;
1927 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1928 /* so that bdrv_close() does not recursively close the chain */
1929 intermediate_state
->bs
->backing_hd
= NULL
;
1930 bdrv_delete(intermediate_state
->bs
);
1935 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1936 g_free(intermediate_state
);
1942 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1947 if (!bdrv_is_inserted(bs
))
1953 len
= bdrv_getlength(bs
);
1958 if ((offset
> len
) || (len
- offset
< size
))
1964 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1967 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1968 nb_sectors
* BDRV_SECTOR_SIZE
);
1971 typedef struct RwCo
{
1972 BlockDriverState
*bs
;
1980 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1982 RwCo
*rwco
= opaque
;
1984 if (!rwco
->is_write
) {
1985 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1986 rwco
->nb_sectors
, rwco
->qiov
, 0);
1988 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1989 rwco
->nb_sectors
, rwco
->qiov
, 0);
1994 * Process a synchronous request using coroutines
1996 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1997 int nb_sectors
, bool is_write
)
2000 struct iovec iov
= {
2001 .iov_base
= (void *)buf
,
2002 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2007 .sector_num
= sector_num
,
2008 .nb_sectors
= nb_sectors
,
2010 .is_write
= is_write
,
2014 qemu_iovec_init_external(&qiov
, &iov
, 1);
2017 * In sync call context, when the vcpu is blocked, this throttling timer
2018 * will not fire; so the I/O throttling function has to be disabled here
2019 * if it has been enabled.
2021 if (bs
->io_limits_enabled
) {
2022 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2023 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2024 bdrv_io_limits_disable(bs
);
2027 if (qemu_in_coroutine()) {
2028 /* Fast-path if already in coroutine context */
2029 bdrv_rw_co_entry(&rwco
);
2031 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2032 qemu_coroutine_enter(co
, &rwco
);
2033 while (rwco
.ret
== NOT_DONE
) {
2040 /* return < 0 if error. See bdrv_write() for the return codes */
2041 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2042 uint8_t *buf
, int nb_sectors
)
2044 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
2047 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2048 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2049 uint8_t *buf
, int nb_sectors
)
2054 enabled
= bs
->io_limits_enabled
;
2055 bs
->io_limits_enabled
= false;
2056 ret
= bdrv_read(bs
, 0, buf
, 1);
2057 bs
->io_limits_enabled
= enabled
;
2061 /* Return < 0 if error. Important errors are:
2062 -EIO generic I/O error (may happen for all errors)
2063 -ENOMEDIUM No media inserted.
2064 -EINVAL Invalid sector number or nb_sectors
2065 -EACCES Trying to write a read-only device
2067 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2068 const uint8_t *buf
, int nb_sectors
)
2070 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
2073 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2074 void *buf
, int count1
)
2076 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2077 int len
, nb_sectors
, count
;
2082 /* first read to align to sector start */
2083 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2086 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2088 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2090 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2098 /* read the sectors "in place" */
2099 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2100 if (nb_sectors
> 0) {
2101 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2103 sector_num
+= nb_sectors
;
2104 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2109 /* add data from the last sector */
2111 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2113 memcpy(buf
, tmp_buf
, count
);
2118 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2119 const void *buf
, int count1
)
2121 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2122 int len
, nb_sectors
, count
;
2127 /* first write to align to sector start */
2128 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2131 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2133 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2135 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
2136 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2145 /* write the sectors "in place" */
2146 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2147 if (nb_sectors
> 0) {
2148 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2150 sector_num
+= nb_sectors
;
2151 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2156 /* add data from the last sector */
2158 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2160 memcpy(tmp_buf
, buf
, count
);
2161 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2168 * Writes to the file and ensures that no writes are reordered across this
2169 * request (acts as a barrier)
2171 * Returns 0 on success, -errno in error cases.
2173 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2174 const void *buf
, int count
)
2178 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2183 /* No flush needed for cache modes that already do it */
2184 if (bs
->enable_write_cache
) {
2191 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2192 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2194 /* Perform I/O through a temporary buffer so that users who scribble over
2195 * their read buffer while the operation is in progress do not end up
2196 * modifying the image file. This is critical for zero-copy guest I/O
2197 * where anything might happen inside guest memory.
2199 void *bounce_buffer
;
2201 BlockDriver
*drv
= bs
->drv
;
2203 QEMUIOVector bounce_qiov
;
2204 int64_t cluster_sector_num
;
2205 int cluster_nb_sectors
;
2209 /* Cover entire cluster so no additional backing file I/O is required when
2210 * allocating cluster in the image file.
2212 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2213 &cluster_sector_num
, &cluster_nb_sectors
);
2215 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2216 cluster_sector_num
, cluster_nb_sectors
);
2218 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2219 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2220 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2222 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2228 if (drv
->bdrv_co_write_zeroes
&&
2229 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2230 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2231 cluster_nb_sectors
);
2233 /* This does not change the data on the disk, it is not necessary
2234 * to flush even in cache=writethrough mode.
2236 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2241 /* It might be okay to ignore write errors for guest requests. If this
2242 * is a deliberate copy-on-read then we don't want to ignore the error.
2243 * Simply report it in all cases.
2248 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2249 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2250 nb_sectors
* BDRV_SECTOR_SIZE
);
2253 qemu_vfree(bounce_buffer
);
2258 * Handle a read request in coroutine context
2260 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
2261 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2262 BdrvRequestFlags flags
)
2264 BlockDriver
*drv
= bs
->drv
;
2265 BdrvTrackedRequest req
;
2271 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2275 /* throttling disk read I/O */
2276 if (bs
->io_limits_enabled
) {
2277 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
2280 if (bs
->copy_on_read
) {
2281 flags
|= BDRV_REQ_COPY_ON_READ
;
2283 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2284 bs
->copy_on_read_in_flight
++;
2287 int job_cluster_size
= bs
->job
&& bs
->job
->cluster_size
?
2288 bs
->job
->cluster_size
: 0;
2290 if (bs
->copy_on_read_in_flight
|| job_cluster_size
) {
2291 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
,
2295 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
2297 if (bs
->job
&& bs
->job
->job_type
->before_read
) {
2298 ret
= bs
->job
->job_type
->before_read(bs
, sector_num
, nb_sectors
, qiov
);
2299 if ((ret
< 0) || (flags
& BDRV_REQ_BACKUP_ONLY
)) {
2300 /* Note: We do not return any data to the caller */
2305 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2308 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2313 if (!ret
|| pnum
!= nb_sectors
) {
2314 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2319 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2322 tracked_request_end(&req
);
2324 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2325 bs
->copy_on_read_in_flight
--;
2331 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2332 int nb_sectors
, QEMUIOVector
*qiov
)
2334 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
2336 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
2339 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
2340 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2342 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
2344 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
2345 BDRV_REQ_COPY_ON_READ
);
2348 int coroutine_fn
bdrv_co_backup(BlockDriverState
*bs
,
2349 int64_t sector_num
, int nb_sectors
)
2355 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, NULL
,
2356 BDRV_REQ_BACKUP_ONLY
);
2359 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
2360 int64_t sector_num
, int nb_sectors
)
2362 BlockDriver
*drv
= bs
->drv
;
2367 /* TODO Emulate only part of misaligned requests instead of letting block
2368 * drivers return -ENOTSUP and emulate everything */
2370 /* First try the efficient write zeroes operation */
2371 if (drv
->bdrv_co_write_zeroes
) {
2372 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2373 if (ret
!= -ENOTSUP
) {
2378 /* Fall back to bounce buffer if write zeroes is unsupported */
2379 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
2380 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
2381 memset(iov
.iov_base
, 0, iov
.iov_len
);
2382 qemu_iovec_init_external(&qiov
, &iov
, 1);
2384 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
2386 qemu_vfree(iov
.iov_base
);
2391 * Handle a write request in coroutine context
2393 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
2394 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2395 BdrvRequestFlags flags
)
2397 BlockDriver
*drv
= bs
->drv
;
2398 BdrvTrackedRequest req
;
2404 if (bs
->read_only
) {
2407 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2411 /* throttling disk write I/O */
2412 if (bs
->io_limits_enabled
) {
2413 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2416 int job_cluster_size
= bs
->job
&& bs
->job
->cluster_size
?
2417 bs
->job
->cluster_size
: 0;
2419 if (bs
->copy_on_read_in_flight
|| job_cluster_size
) {
2420 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
,
2424 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2426 if (bs
->job
&& bs
->job
->job_type
->before_write
) {
2427 ret
= bs
->job
->job_type
->before_write(bs
, sector_num
, nb_sectors
, qiov
);
2433 if (flags
& BDRV_REQ_ZERO_WRITE
) {
2434 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2436 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2439 if (ret
== 0 && !bs
->enable_write_cache
) {
2440 ret
= bdrv_co_flush(bs
);
2443 if (bs
->dirty_bitmap
) {
2444 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
2447 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2448 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2452 tracked_request_end(&req
);
2457 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2458 int nb_sectors
, QEMUIOVector
*qiov
)
2460 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2462 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2465 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2466 int64_t sector_num
, int nb_sectors
)
2468 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2470 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2471 BDRV_REQ_ZERO_WRITE
);
2475 * Truncate file to 'offset' bytes (needed only for file protocols)
2477 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2479 BlockDriver
*drv
= bs
->drv
;
2483 if (!drv
->bdrv_truncate
)
2487 if (bdrv_in_use(bs
))
2489 ret
= drv
->bdrv_truncate(bs
, offset
);
2491 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2492 bdrv_dev_resize_cb(bs
);
2498 * Length of a allocated file in bytes. Sparse files are counted by actual
2499 * allocated space. Return < 0 if error or unknown.
2501 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2503 BlockDriver
*drv
= bs
->drv
;
2507 if (drv
->bdrv_get_allocated_file_size
) {
2508 return drv
->bdrv_get_allocated_file_size(bs
);
2511 return bdrv_get_allocated_file_size(bs
->file
);
2517 * Length of a file in bytes. Return < 0 if error or unknown.
2519 int64_t bdrv_getlength(BlockDriverState
*bs
)
2521 BlockDriver
*drv
= bs
->drv
;
2525 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2526 if (drv
->bdrv_getlength
) {
2527 return drv
->bdrv_getlength(bs
);
2530 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2533 /* return 0 as number of sectors if no device present or error */
2534 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2537 length
= bdrv_getlength(bs
);
2541 length
= length
>> BDRV_SECTOR_BITS
;
2542 *nb_sectors_ptr
= length
;
2545 /* throttling disk io limits */
2546 void bdrv_set_io_limits(BlockDriverState
*bs
,
2547 BlockIOLimit
*io_limits
)
2549 bs
->io_limits
= *io_limits
;
2550 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2553 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2554 BlockdevOnError on_write_error
)
2556 bs
->on_read_error
= on_read_error
;
2557 bs
->on_write_error
= on_write_error
;
2560 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2562 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2565 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2567 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2570 case BLOCKDEV_ON_ERROR_ENOSPC
:
2571 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
2572 case BLOCKDEV_ON_ERROR_STOP
:
2573 return BDRV_ACTION_STOP
;
2574 case BLOCKDEV_ON_ERROR_REPORT
:
2575 return BDRV_ACTION_REPORT
;
2576 case BLOCKDEV_ON_ERROR_IGNORE
:
2577 return BDRV_ACTION_IGNORE
;
2583 /* This is done by device models because, while the block layer knows
2584 * about the error, it does not know whether an operation comes from
2585 * the device or the block layer (from a job, for example).
2587 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2588 bool is_read
, int error
)
2591 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
2592 if (action
== BDRV_ACTION_STOP
) {
2593 vm_stop(RUN_STATE_IO_ERROR
);
2594 bdrv_iostatus_set_err(bs
, error
);
2598 int bdrv_is_read_only(BlockDriverState
*bs
)
2600 return bs
->read_only
;
2603 int bdrv_is_sg(BlockDriverState
*bs
)
2608 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2610 return bs
->enable_write_cache
;
2613 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2615 bs
->enable_write_cache
= wce
;
2617 /* so a reopen() will preserve wce */
2619 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2621 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2625 int bdrv_is_encrypted(BlockDriverState
*bs
)
2627 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2629 return bs
->encrypted
;
2632 int bdrv_key_required(BlockDriverState
*bs
)
2634 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2636 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2638 return (bs
->encrypted
&& !bs
->valid_key
);
2641 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2644 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2645 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2651 if (!bs
->encrypted
) {
2653 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2656 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2659 } else if (!bs
->valid_key
) {
2661 /* call the change callback now, we skipped it on open */
2662 bdrv_dev_change_media_cb(bs
, true);
2667 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2669 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2672 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2677 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2678 it(opaque
, drv
->format_name
);
2682 BlockDriverState
*bdrv_find(const char *name
)
2684 BlockDriverState
*bs
;
2686 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2687 if (!strcmp(name
, bs
->device_name
)) {
2694 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2697 return QTAILQ_FIRST(&bdrv_states
);
2699 return QTAILQ_NEXT(bs
, list
);
2702 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2704 BlockDriverState
*bs
;
2706 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2711 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2713 return bs
->device_name
;
2716 int bdrv_get_flags(BlockDriverState
*bs
)
2718 return bs
->open_flags
;
2721 void bdrv_flush_all(void)
2723 BlockDriverState
*bs
;
2725 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2730 int bdrv_has_zero_init(BlockDriverState
*bs
)
2734 if (bs
->drv
->bdrv_has_zero_init
) {
2735 return bs
->drv
->bdrv_has_zero_init(bs
);
2741 typedef struct BdrvCoIsAllocatedData
{
2742 BlockDriverState
*bs
;
2748 } BdrvCoIsAllocatedData
;
2751 * Returns true iff the specified sector is present in the disk image. Drivers
2752 * not implementing the functionality are assumed to not support backing files,
2753 * hence all their sectors are reported as allocated.
2755 * If 'sector_num' is beyond the end of the disk image the return value is 0
2756 * and 'pnum' is set to 0.
2758 * 'pnum' is set to the number of sectors (including and immediately following
2759 * the specified sector) that are known to be in the same
2760 * allocated/unallocated state.
2762 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2763 * beyond the end of the disk image it will be clamped.
2765 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2766 int nb_sectors
, int *pnum
)
2770 if (sector_num
>= bs
->total_sectors
) {
2775 n
= bs
->total_sectors
- sector_num
;
2776 if (n
< nb_sectors
) {
2780 if (!bs
->drv
->bdrv_co_is_allocated
) {
2785 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2788 /* Coroutine wrapper for bdrv_is_allocated() */
2789 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2791 BdrvCoIsAllocatedData
*data
= opaque
;
2792 BlockDriverState
*bs
= data
->bs
;
2794 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2800 * Synchronous wrapper around bdrv_co_is_allocated().
2802 * See bdrv_co_is_allocated() for details.
2804 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2808 BdrvCoIsAllocatedData data
= {
2810 .sector_num
= sector_num
,
2811 .nb_sectors
= nb_sectors
,
2816 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2817 qemu_coroutine_enter(co
, &data
);
2818 while (!data
.done
) {
2825 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2827 * Return true if the given sector is allocated in any image between
2828 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2829 * sector is allocated in any image of the chain. Return false otherwise.
2831 * 'pnum' is set to the number of sectors (including and immediately following
2832 * the specified sector) that are known to be in the same
2833 * allocated/unallocated state.
2836 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2837 BlockDriverState
*base
,
2839 int nb_sectors
, int *pnum
)
2841 BlockDriverState
*intermediate
;
2842 int ret
, n
= nb_sectors
;
2845 while (intermediate
&& intermediate
!= base
) {
2847 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2857 * [sector_num, nb_sectors] is unallocated on top but intermediate
2860 * [sector_num+x, nr_sectors] allocated.
2862 if (n
> pnum_inter
&&
2863 (intermediate
== top
||
2864 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
2868 intermediate
= intermediate
->backing_hd
;
2875 BlockInfo
*bdrv_query_info(BlockDriverState
*bs
)
2877 BlockInfo
*info
= g_malloc0(sizeof(*info
));
2878 info
->device
= g_strdup(bs
->device_name
);
2879 info
->type
= g_strdup("unknown");
2880 info
->locked
= bdrv_dev_is_medium_locked(bs
);
2881 info
->removable
= bdrv_dev_has_removable_media(bs
);
2883 if (bdrv_dev_has_removable_media(bs
)) {
2884 info
->has_tray_open
= true;
2885 info
->tray_open
= bdrv_dev_is_tray_open(bs
);
2888 if (bdrv_iostatus_is_enabled(bs
)) {
2889 info
->has_io_status
= true;
2890 info
->io_status
= bs
->iostatus
;
2893 if (bs
->dirty_bitmap
) {
2894 info
->has_dirty
= true;
2895 info
->dirty
= g_malloc0(sizeof(*info
->dirty
));
2896 info
->dirty
->count
= bdrv_get_dirty_count(bs
) * BDRV_SECTOR_SIZE
;
2897 info
->dirty
->granularity
=
2898 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bs
->dirty_bitmap
));
2902 info
->has_inserted
= true;
2903 info
->inserted
= g_malloc0(sizeof(*info
->inserted
));
2904 info
->inserted
->file
= g_strdup(bs
->filename
);
2905 info
->inserted
->ro
= bs
->read_only
;
2906 info
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2907 info
->inserted
->encrypted
= bs
->encrypted
;
2908 info
->inserted
->encryption_key_missing
= bdrv_key_required(bs
);
2910 if (bs
->backing_file
[0]) {
2911 info
->inserted
->has_backing_file
= true;
2912 info
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2915 info
->inserted
->backing_file_depth
= bdrv_get_backing_file_depth(bs
);
2917 if (bs
->io_limits_enabled
) {
2918 info
->inserted
->bps
=
2919 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2920 info
->inserted
->bps_rd
=
2921 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2922 info
->inserted
->bps_wr
=
2923 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2924 info
->inserted
->iops
=
2925 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2926 info
->inserted
->iops_rd
=
2927 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2928 info
->inserted
->iops_wr
=
2929 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2935 BlockInfoList
*qmp_query_block(Error
**errp
)
2937 BlockInfoList
*head
= NULL
, **p_next
= &head
;
2938 BlockDriverState
*bs
;
2940 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2941 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2942 info
->value
= bdrv_query_info(bs
);
2945 p_next
= &info
->next
;
2951 BlockStats
*bdrv_query_stats(const BlockDriverState
*bs
)
2955 s
= g_malloc0(sizeof(*s
));
2957 if (bs
->device_name
[0]) {
2958 s
->has_device
= true;
2959 s
->device
= g_strdup(bs
->device_name
);
2962 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2963 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2964 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2965 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2966 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2967 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2968 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2969 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2970 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2971 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2974 s
->has_parent
= true;
2975 s
->parent
= bdrv_query_stats(bs
->file
);
2981 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2983 BlockStatsList
*head
= NULL
, **p_next
= &head
;
2984 BlockDriverState
*bs
;
2986 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2987 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2988 info
->value
= bdrv_query_stats(bs
);
2991 p_next
= &info
->next
;
2997 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2999 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3000 return bs
->backing_file
;
3001 else if (bs
->encrypted
)
3002 return bs
->filename
;
3007 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3008 char *filename
, int filename_size
)
3010 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3013 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
3014 const uint8_t *buf
, int nb_sectors
)
3016 BlockDriver
*drv
= bs
->drv
;
3019 if (!drv
->bdrv_write_compressed
)
3021 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
3024 assert(!bs
->dirty_bitmap
);
3026 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
3029 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3031 BlockDriver
*drv
= bs
->drv
;
3034 if (!drv
->bdrv_get_info
)
3036 memset(bdi
, 0, sizeof(*bdi
));
3037 return drv
->bdrv_get_info(bs
, bdi
);
3040 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
3041 int64_t pos
, int size
)
3043 BlockDriver
*drv
= bs
->drv
;
3046 if (drv
->bdrv_save_vmstate
)
3047 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
3049 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
3053 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
3054 int64_t pos
, int size
)
3056 BlockDriver
*drv
= bs
->drv
;
3059 if (drv
->bdrv_load_vmstate
)
3060 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
3062 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
3066 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
3068 BlockDriver
*drv
= bs
->drv
;
3070 if (!drv
|| !drv
->bdrv_debug_event
) {
3074 drv
->bdrv_debug_event(bs
, event
);
3077 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3080 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3084 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3085 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3091 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3093 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_resume
) {
3097 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3098 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3104 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3106 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3110 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3111 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3117 /**************************************************************/
3118 /* handling of snapshots */
3120 int bdrv_can_snapshot(BlockDriverState
*bs
)
3122 BlockDriver
*drv
= bs
->drv
;
3123 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3127 if (!drv
->bdrv_snapshot_create
) {
3128 if (bs
->file
!= NULL
) {
3129 return bdrv_can_snapshot(bs
->file
);
3137 int bdrv_is_snapshot(BlockDriverState
*bs
)
3139 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3142 BlockDriverState
*bdrv_snapshots(void)
3144 BlockDriverState
*bs
;
3147 return bs_snapshots
;
3151 while ((bs
= bdrv_next(bs
))) {
3152 if (bdrv_can_snapshot(bs
)) {
3160 int bdrv_snapshot_create(BlockDriverState
*bs
,
3161 QEMUSnapshotInfo
*sn_info
)
3163 BlockDriver
*drv
= bs
->drv
;
3166 if (drv
->bdrv_snapshot_create
)
3167 return drv
->bdrv_snapshot_create(bs
, sn_info
);
3169 return bdrv_snapshot_create(bs
->file
, sn_info
);
3173 int bdrv_snapshot_goto(BlockDriverState
*bs
,
3174 const char *snapshot_id
)
3176 BlockDriver
*drv
= bs
->drv
;
3181 if (drv
->bdrv_snapshot_goto
)
3182 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
3185 drv
->bdrv_close(bs
);
3186 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
3187 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
3189 bdrv_delete(bs
->file
);
3199 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
3201 BlockDriver
*drv
= bs
->drv
;
3204 if (drv
->bdrv_snapshot_delete
)
3205 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
3207 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
3211 int bdrv_snapshot_list(BlockDriverState
*bs
,
3212 QEMUSnapshotInfo
**psn_info
)
3214 BlockDriver
*drv
= bs
->drv
;
3217 if (drv
->bdrv_snapshot_list
)
3218 return drv
->bdrv_snapshot_list(bs
, psn_info
);
3220 return bdrv_snapshot_list(bs
->file
, psn_info
);
3224 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
3225 const char *snapshot_name
)
3227 BlockDriver
*drv
= bs
->drv
;
3231 if (!bs
->read_only
) {
3234 if (drv
->bdrv_snapshot_load_tmp
) {
3235 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
3240 /* backing_file can either be relative, or absolute, or a protocol. If it is
3241 * relative, it must be relative to the chain. So, passing in bs->filename
3242 * from a BDS as backing_file should not be done, as that may be relative to
3243 * the CWD rather than the chain. */
3244 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3245 const char *backing_file
)
3247 char *filename_full
= NULL
;
3248 char *backing_file_full
= NULL
;
3249 char *filename_tmp
= NULL
;
3250 int is_protocol
= 0;
3251 BlockDriverState
*curr_bs
= NULL
;
3252 BlockDriverState
*retval
= NULL
;
3254 if (!bs
|| !bs
->drv
|| !backing_file
) {
3258 filename_full
= g_malloc(PATH_MAX
);
3259 backing_file_full
= g_malloc(PATH_MAX
);
3260 filename_tmp
= g_malloc(PATH_MAX
);
3262 is_protocol
= path_has_protocol(backing_file
);
3264 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3266 /* If either of the filename paths is actually a protocol, then
3267 * compare unmodified paths; otherwise make paths relative */
3268 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3269 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3270 retval
= curr_bs
->backing_hd
;
3274 /* If not an absolute filename path, make it relative to the current
3275 * image's filename path */
3276 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3279 /* We are going to compare absolute pathnames */
3280 if (!realpath(filename_tmp
, filename_full
)) {
3284 /* We need to make sure the backing filename we are comparing against
3285 * is relative to the current image filename (or absolute) */
3286 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3287 curr_bs
->backing_file
);
3289 if (!realpath(filename_tmp
, backing_file_full
)) {
3293 if (strcmp(backing_file_full
, filename_full
) == 0) {
3294 retval
= curr_bs
->backing_hd
;
3300 g_free(filename_full
);
3301 g_free(backing_file_full
);
3302 g_free(filename_tmp
);
3306 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3312 if (!bs
->backing_hd
) {
3316 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3319 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
3321 BlockDriverState
*curr_bs
= NULL
;
3329 while (curr_bs
->backing_hd
) {
3330 curr_bs
= curr_bs
->backing_hd
;
3335 #define NB_SUFFIXES 4
3337 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
3339 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
3344 snprintf(buf
, buf_size
, "%" PRId64
, size
);
3347 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
3348 if (size
< (10 * base
)) {
3349 snprintf(buf
, buf_size
, "%0.1f%c",
3350 (double)size
/ base
,
3353 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
3354 snprintf(buf
, buf_size
, "%" PRId64
"%c",
3355 ((size
+ (base
>> 1)) / base
),
3365 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
3367 char buf1
[128], date_buf
[128], clock_buf
[128];
3373 snprintf(buf
, buf_size
,
3374 "%-10s%-20s%7s%20s%15s",
3375 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3378 localtime_r(&ti
, &tm
);
3379 strftime(date_buf
, sizeof(date_buf
),
3380 "%Y-%m-%d %H:%M:%S", &tm
);
3381 secs
= sn
->vm_clock_nsec
/ 1000000000;
3382 snprintf(clock_buf
, sizeof(clock_buf
),
3383 "%02d:%02d:%02d.%03d",
3385 (int)((secs
/ 60) % 60),
3387 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
3388 snprintf(buf
, buf_size
,
3389 "%-10s%-20s%7s%20s%15s",
3390 sn
->id_str
, sn
->name
,
3391 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
3398 /**************************************************************/
3401 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3402 QEMUIOVector
*qiov
, int nb_sectors
,
3403 BlockDriverCompletionFunc
*cb
, void *opaque
)
3405 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3407 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3411 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3412 QEMUIOVector
*qiov
, int nb_sectors
,
3413 BlockDriverCompletionFunc
*cb
, void *opaque
)
3415 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3417 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3422 typedef struct MultiwriteCB
{
3427 BlockDriverCompletionFunc
*cb
;
3429 QEMUIOVector
*free_qiov
;
3433 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3437 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3438 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3439 if (mcb
->callbacks
[i
].free_qiov
) {
3440 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3442 g_free(mcb
->callbacks
[i
].free_qiov
);
3446 static void multiwrite_cb(void *opaque
, int ret
)
3448 MultiwriteCB
*mcb
= opaque
;
3450 trace_multiwrite_cb(mcb
, ret
);
3452 if (ret
< 0 && !mcb
->error
) {
3456 mcb
->num_requests
--;
3457 if (mcb
->num_requests
== 0) {
3458 multiwrite_user_cb(mcb
);
3463 static int multiwrite_req_compare(const void *a
, const void *b
)
3465 const BlockRequest
*req1
= a
, *req2
= b
;
3468 * Note that we can't simply subtract req2->sector from req1->sector
3469 * here as that could overflow the return value.
3471 if (req1
->sector
> req2
->sector
) {
3473 } else if (req1
->sector
< req2
->sector
) {
3481 * Takes a bunch of requests and tries to merge them. Returns the number of
3482 * requests that remain after merging.
3484 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3485 int num_reqs
, MultiwriteCB
*mcb
)
3489 // Sort requests by start sector
3490 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3492 // Check if adjacent requests touch the same clusters. If so, combine them,
3493 // filling up gaps with zero sectors.
3495 for (i
= 1; i
< num_reqs
; i
++) {
3497 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3499 // Handle exactly sequential writes and overlapping writes.
3500 if (reqs
[i
].sector
<= oldreq_last
) {
3504 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3510 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3511 qemu_iovec_init(qiov
,
3512 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3514 // Add the first request to the merged one. If the requests are
3515 // overlapping, drop the last sectors of the first request.
3516 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3517 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
3519 // We should need to add any zeros between the two requests
3520 assert (reqs
[i
].sector
<= oldreq_last
);
3522 // Add the second request
3523 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
3525 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3526 reqs
[outidx
].qiov
= qiov
;
3528 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3531 reqs
[outidx
].sector
= reqs
[i
].sector
;
3532 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3533 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3541 * Submit multiple AIO write requests at once.
3543 * On success, the function returns 0 and all requests in the reqs array have
3544 * been submitted. In error case this function returns -1, and any of the
3545 * requests may or may not be submitted yet. In particular, this means that the
3546 * callback will be called for some of the requests, for others it won't. The
3547 * caller must check the error field of the BlockRequest to wait for the right
3548 * callbacks (if error != 0, no callback will be called).
3550 * The implementation may modify the contents of the reqs array, e.g. to merge
3551 * requests. However, the fields opaque and error are left unmodified as they
3552 * are used to signal failure for a single request to the caller.
3554 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3559 /* don't submit writes if we don't have a medium */
3560 if (bs
->drv
== NULL
) {
3561 for (i
= 0; i
< num_reqs
; i
++) {
3562 reqs
[i
].error
= -ENOMEDIUM
;
3567 if (num_reqs
== 0) {
3571 // Create MultiwriteCB structure
3572 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3573 mcb
->num_requests
= 0;
3574 mcb
->num_callbacks
= num_reqs
;
3576 for (i
= 0; i
< num_reqs
; i
++) {
3577 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3578 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3581 // Check for mergable requests
3582 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3584 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3586 /* Run the aio requests. */
3587 mcb
->num_requests
= num_reqs
;
3588 for (i
= 0; i
< num_reqs
; i
++) {
3589 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3590 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3596 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3598 acb
->aiocb_info
->cancel(acb
);
3601 /* block I/O throttling */
3602 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3603 bool is_write
, double elapsed_time
, uint64_t *wait
)
3605 uint64_t bps_limit
= 0;
3606 double bytes_limit
, bytes_base
, bytes_res
;
3607 double slice_time
, wait_time
;
3609 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3610 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3611 } else if (bs
->io_limits
.bps
[is_write
]) {
3612 bps_limit
= bs
->io_limits
.bps
[is_write
];
3621 slice_time
= bs
->slice_end
- bs
->slice_start
;
3622 slice_time
/= (NANOSECONDS_PER_SECOND
);
3623 bytes_limit
= bps_limit
* slice_time
;
3624 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3625 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3626 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3629 /* bytes_base: the bytes of data which have been read/written; and
3630 * it is obtained from the history statistic info.
3631 * bytes_res: the remaining bytes of data which need to be read/written.
3632 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3633 * the total time for completing reading/writting all data.
3635 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3637 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3645 /* Calc approx time to dispatch */
3646 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3648 /* When the I/O rate at runtime exceeds the limits,
3649 * bs->slice_end need to be extended in order that the current statistic
3650 * info can be kept until the timer fire, so it is increased and tuned
3651 * based on the result of experiment.
3653 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3654 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3656 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3662 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3663 double elapsed_time
, uint64_t *wait
)
3665 uint64_t iops_limit
= 0;
3666 double ios_limit
, ios_base
;
3667 double slice_time
, wait_time
;
3669 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3670 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3671 } else if (bs
->io_limits
.iops
[is_write
]) {
3672 iops_limit
= bs
->io_limits
.iops
[is_write
];
3681 slice_time
= bs
->slice_end
- bs
->slice_start
;
3682 slice_time
/= (NANOSECONDS_PER_SECOND
);
3683 ios_limit
= iops_limit
* slice_time
;
3684 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3685 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3686 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3689 if (ios_base
+ 1 <= ios_limit
) {
3697 /* Calc approx time to dispatch */
3698 wait_time
= (ios_base
+ 1) / iops_limit
;
3699 if (wait_time
> elapsed_time
) {
3700 wait_time
= wait_time
- elapsed_time
;
3705 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3706 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3708 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3714 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3715 bool is_write
, int64_t *wait
)
3717 int64_t now
, max_wait
;
3718 uint64_t bps_wait
= 0, iops_wait
= 0;
3719 double elapsed_time
;
3720 int bps_ret
, iops_ret
;
3722 now
= qemu_get_clock_ns(vm_clock
);
3723 if ((bs
->slice_start
< now
)
3724 && (bs
->slice_end
> now
)) {
3725 bs
->slice_end
= now
+ bs
->slice_time
;
3727 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3728 bs
->slice_start
= now
;
3729 bs
->slice_end
= now
+ bs
->slice_time
;
3731 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3732 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3734 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3735 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3738 elapsed_time
= now
- bs
->slice_start
;
3739 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3741 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3742 is_write
, elapsed_time
, &bps_wait
);
3743 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3744 elapsed_time
, &iops_wait
);
3745 if (bps_ret
|| iops_ret
) {
3746 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3751 now
= qemu_get_clock_ns(vm_clock
);
3752 if (bs
->slice_end
< now
+ max_wait
) {
3753 bs
->slice_end
= now
+ max_wait
;
3766 /**************************************************************/
3767 /* async block device emulation */
3769 typedef struct BlockDriverAIOCBSync
{
3770 BlockDriverAIOCB common
;
3773 /* vector translation state */
3777 } BlockDriverAIOCBSync
;
3779 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3781 BlockDriverAIOCBSync
*acb
=
3782 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3783 qemu_bh_delete(acb
->bh
);
3785 qemu_aio_release(acb
);
3788 static const AIOCBInfo bdrv_em_aiocb_info
= {
3789 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3790 .cancel
= bdrv_aio_cancel_em
,
3793 static void bdrv_aio_bh_cb(void *opaque
)
3795 BlockDriverAIOCBSync
*acb
= opaque
;
3798 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3799 qemu_vfree(acb
->bounce
);
3800 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3801 qemu_bh_delete(acb
->bh
);
3803 qemu_aio_release(acb
);
3806 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3810 BlockDriverCompletionFunc
*cb
,
3815 BlockDriverAIOCBSync
*acb
;
3817 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
3818 acb
->is_write
= is_write
;
3820 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3821 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3824 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3825 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3827 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3830 qemu_bh_schedule(acb
->bh
);
3832 return &acb
->common
;
3835 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3836 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3837 BlockDriverCompletionFunc
*cb
, void *opaque
)
3839 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3842 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3843 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3844 BlockDriverCompletionFunc
*cb
, void *opaque
)
3846 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3850 typedef struct BlockDriverAIOCBCoroutine
{
3851 BlockDriverAIOCB common
;
3856 } BlockDriverAIOCBCoroutine
;
3858 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3860 BlockDriverAIOCBCoroutine
*acb
=
3861 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
3870 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
3871 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3872 .cancel
= bdrv_aio_co_cancel_em
,
3875 static void bdrv_co_em_bh(void *opaque
)
3877 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3879 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3885 qemu_bh_delete(acb
->bh
);
3886 qemu_aio_release(acb
);
3889 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3890 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3892 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3893 BlockDriverState
*bs
= acb
->common
.bs
;
3895 if (!acb
->is_write
) {
3896 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3897 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3899 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3900 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3903 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3904 qemu_bh_schedule(acb
->bh
);
3907 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3911 BlockDriverCompletionFunc
*cb
,
3916 BlockDriverAIOCBCoroutine
*acb
;
3918 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3919 acb
->req
.sector
= sector_num
;
3920 acb
->req
.nb_sectors
= nb_sectors
;
3921 acb
->req
.qiov
= qiov
;
3922 acb
->is_write
= is_write
;
3925 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3926 qemu_coroutine_enter(co
, acb
);
3928 return &acb
->common
;
3931 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3933 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3934 BlockDriverState
*bs
= acb
->common
.bs
;
3936 acb
->req
.error
= bdrv_co_flush(bs
);
3937 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3938 qemu_bh_schedule(acb
->bh
);
3941 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3942 BlockDriverCompletionFunc
*cb
, void *opaque
)
3944 trace_bdrv_aio_flush(bs
, opaque
);
3947 BlockDriverAIOCBCoroutine
*acb
;
3949 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3952 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3953 qemu_coroutine_enter(co
, acb
);
3955 return &acb
->common
;
3958 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3960 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3961 BlockDriverState
*bs
= acb
->common
.bs
;
3963 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3964 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3965 qemu_bh_schedule(acb
->bh
);
3968 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3969 int64_t sector_num
, int nb_sectors
,
3970 BlockDriverCompletionFunc
*cb
, void *opaque
)
3973 BlockDriverAIOCBCoroutine
*acb
;
3975 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3977 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3978 acb
->req
.sector
= sector_num
;
3979 acb
->req
.nb_sectors
= nb_sectors
;
3981 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3982 qemu_coroutine_enter(co
, acb
);
3984 return &acb
->common
;
3987 void bdrv_init(void)
3989 module_call_init(MODULE_INIT_BLOCK
);
3992 void bdrv_init_with_whitelist(void)
3994 use_bdrv_whitelist
= 1;
3998 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
3999 BlockDriverCompletionFunc
*cb
, void *opaque
)
4001 BlockDriverAIOCB
*acb
;
4003 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4004 acb
->aiocb_info
= aiocb_info
;
4007 acb
->opaque
= opaque
;
4011 void qemu_aio_release(void *p
)
4013 BlockDriverAIOCB
*acb
= p
;
4014 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4017 /**************************************************************/
4018 /* Coroutine block device emulation */
4020 typedef struct CoroutineIOCompletion
{
4021 Coroutine
*coroutine
;
4023 } CoroutineIOCompletion
;
4025 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4027 CoroutineIOCompletion
*co
= opaque
;
4030 qemu_coroutine_enter(co
->coroutine
, NULL
);
4033 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4034 int nb_sectors
, QEMUIOVector
*iov
,
4037 CoroutineIOCompletion co
= {
4038 .coroutine
= qemu_coroutine_self(),
4040 BlockDriverAIOCB
*acb
;
4043 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4044 bdrv_co_io_em_complete
, &co
);
4046 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4047 bdrv_co_io_em_complete
, &co
);
4050 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4054 qemu_coroutine_yield();
4059 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4060 int64_t sector_num
, int nb_sectors
,
4063 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4066 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4067 int64_t sector_num
, int nb_sectors
,
4070 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4073 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4075 RwCo
*rwco
= opaque
;
4077 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4080 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4084 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4088 /* Write back cached data to the OS even with cache=unsafe */
4089 if (bs
->drv
->bdrv_co_flush_to_os
) {
4090 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4096 /* But don't actually force it to the disk with cache=unsafe */
4097 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4101 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4102 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4103 } else if (bs
->drv
->bdrv_aio_flush
) {
4104 BlockDriverAIOCB
*acb
;
4105 CoroutineIOCompletion co
= {
4106 .coroutine
= qemu_coroutine_self(),
4109 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4113 qemu_coroutine_yield();
4118 * Some block drivers always operate in either writethrough or unsafe
4119 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4120 * know how the server works (because the behaviour is hardcoded or
4121 * depends on server-side configuration), so we can't ensure that
4122 * everything is safe on disk. Returning an error doesn't work because
4123 * that would break guests even if the server operates in writethrough
4126 * Let's hope the user knows what he's doing.
4134 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4135 * in the case of cache=unsafe, so there are no useless flushes.
4138 return bdrv_co_flush(bs
->file
);
4141 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4143 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4144 bs
->drv
->bdrv_invalidate_cache(bs
);
4148 void bdrv_invalidate_cache_all(void)
4150 BlockDriverState
*bs
;
4152 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4153 bdrv_invalidate_cache(bs
);
4157 void bdrv_clear_incoming_migration_all(void)
4159 BlockDriverState
*bs
;
4161 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4162 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4166 int bdrv_flush(BlockDriverState
*bs
)
4174 if (qemu_in_coroutine()) {
4175 /* Fast-path if already in coroutine context */
4176 bdrv_flush_co_entry(&rwco
);
4178 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4179 qemu_coroutine_enter(co
, &rwco
);
4180 while (rwco
.ret
== NOT_DONE
) {
4188 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4190 RwCo
*rwco
= opaque
;
4192 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4195 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4200 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4202 } else if (bs
->read_only
) {
4206 if (bs
->dirty_bitmap
) {
4207 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
4210 if (bs
->drv
->bdrv_co_discard
) {
4211 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
4212 } else if (bs
->drv
->bdrv_aio_discard
) {
4213 BlockDriverAIOCB
*acb
;
4214 CoroutineIOCompletion co
= {
4215 .coroutine
= qemu_coroutine_self(),
4218 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4219 bdrv_co_io_em_complete
, &co
);
4223 qemu_coroutine_yield();
4231 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4236 .sector_num
= sector_num
,
4237 .nb_sectors
= nb_sectors
,
4241 if (qemu_in_coroutine()) {
4242 /* Fast-path if already in coroutine context */
4243 bdrv_discard_co_entry(&rwco
);
4245 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4246 qemu_coroutine_enter(co
, &rwco
);
4247 while (rwco
.ret
== NOT_DONE
) {
4255 /**************************************************************/
4256 /* removable device support */
4259 * Return TRUE if the media is present
4261 int bdrv_is_inserted(BlockDriverState
*bs
)
4263 BlockDriver
*drv
= bs
->drv
;
4267 if (!drv
->bdrv_is_inserted
)
4269 return drv
->bdrv_is_inserted(bs
);
4273 * Return whether the media changed since the last call to this
4274 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4276 int bdrv_media_changed(BlockDriverState
*bs
)
4278 BlockDriver
*drv
= bs
->drv
;
4280 if (drv
&& drv
->bdrv_media_changed
) {
4281 return drv
->bdrv_media_changed(bs
);
4287 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4289 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4291 BlockDriver
*drv
= bs
->drv
;
4293 if (drv
&& drv
->bdrv_eject
) {
4294 drv
->bdrv_eject(bs
, eject_flag
);
4297 if (bs
->device_name
[0] != '\0') {
4298 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4303 * Lock or unlock the media (if it is locked, the user won't be able
4304 * to eject it manually).
4306 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4308 BlockDriver
*drv
= bs
->drv
;
4310 trace_bdrv_lock_medium(bs
, locked
);
4312 if (drv
&& drv
->bdrv_lock_medium
) {
4313 drv
->bdrv_lock_medium(bs
, locked
);
4317 /* needed for generic scsi interface */
4319 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
4321 BlockDriver
*drv
= bs
->drv
;
4323 if (drv
&& drv
->bdrv_ioctl
)
4324 return drv
->bdrv_ioctl(bs
, req
, buf
);
4328 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
4329 unsigned long int req
, void *buf
,
4330 BlockDriverCompletionFunc
*cb
, void *opaque
)
4332 BlockDriver
*drv
= bs
->drv
;
4334 if (drv
&& drv
->bdrv_aio_ioctl
)
4335 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
4339 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
4341 bs
->buffer_alignment
= align
;
4344 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
4346 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
4350 * Check if all memory in this vector is sector aligned.
4352 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
4356 for (i
= 0; i
< qiov
->niov
; i
++) {
4357 if ((uintptr_t) qiov
->iov
[i
].iov_base
% bs
->buffer_alignment
) {
4365 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int granularity
)
4367 int64_t bitmap_size
;
4369 assert((granularity
& (granularity
- 1)) == 0);
4372 granularity
>>= BDRV_SECTOR_BITS
;
4373 assert(!bs
->dirty_bitmap
);
4374 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
);
4375 bs
->dirty_bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
4377 if (bs
->dirty_bitmap
) {
4378 hbitmap_free(bs
->dirty_bitmap
);
4379 bs
->dirty_bitmap
= NULL
;
4384 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4386 if (bs
->dirty_bitmap
) {
4387 return hbitmap_get(bs
->dirty_bitmap
, sector
);
4393 void bdrv_dirty_iter_init(BlockDriverState
*bs
, HBitmapIter
*hbi
)
4395 hbitmap_iter_init(hbi
, bs
->dirty_bitmap
, 0);
4398 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4401 hbitmap_set(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4404 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4407 hbitmap_reset(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4410 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4412 if (bs
->dirty_bitmap
) {
4413 return hbitmap_count(bs
->dirty_bitmap
);
4419 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4421 assert(bs
->in_use
!= in_use
);
4422 bs
->in_use
= in_use
;
4425 int bdrv_in_use(BlockDriverState
*bs
)
4430 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4432 bs
->iostatus_enabled
= true;
4433 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4436 /* The I/O status is only enabled if the drive explicitly
4437 * enables it _and_ the VM is configured to stop on errors */
4438 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4440 return (bs
->iostatus_enabled
&&
4441 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
4442 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
4443 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
4446 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4448 bs
->iostatus_enabled
= false;
4451 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4453 if (bdrv_iostatus_is_enabled(bs
)) {
4454 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4456 block_job_iostatus_reset(bs
->job
);
4461 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4463 assert(bdrv_iostatus_is_enabled(bs
));
4464 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4465 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4466 BLOCK_DEVICE_IO_STATUS_FAILED
;
4471 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4472 enum BlockAcctType type
)
4474 assert(type
< BDRV_MAX_IOTYPE
);
4476 cookie
->bytes
= bytes
;
4477 cookie
->start_time_ns
= get_clock();
4478 cookie
->type
= type
;
4482 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4484 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4486 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4487 bs
->nr_ops
[cookie
->type
]++;
4488 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4491 void bdrv_img_create(const char *filename
, const char *fmt
,
4492 const char *base_filename
, const char *base_fmt
,
4493 char *options
, uint64_t img_size
, int flags
, Error
**errp
)
4495 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4496 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4497 BlockDriverState
*bs
= NULL
;
4498 BlockDriver
*drv
, *proto_drv
;
4499 BlockDriver
*backing_drv
= NULL
;
4502 /* Find driver and parse its options */
4503 drv
= bdrv_find_format(fmt
);
4505 error_setg(errp
, "Unknown file format '%s'", fmt
);
4509 proto_drv
= bdrv_find_protocol(filename
);
4511 error_setg(errp
, "Unknown protocol '%s'", filename
);
4515 create_options
= append_option_parameters(create_options
,
4516 drv
->create_options
);
4517 create_options
= append_option_parameters(create_options
,
4518 proto_drv
->create_options
);
4520 /* Create parameter list with default values */
4521 param
= parse_option_parameters("", create_options
, param
);
4523 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4525 /* Parse -o options */
4527 param
= parse_option_parameters(options
, create_options
, param
);
4528 if (param
== NULL
) {
4529 error_setg(errp
, "Invalid options for file format '%s'.", fmt
);
4534 if (base_filename
) {
4535 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4537 error_setg(errp
, "Backing file not supported for file format '%s'",
4544 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4545 error_setg(errp
, "Backing file format not supported for file "
4546 "format '%s'", fmt
);
4551 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4552 if (backing_file
&& backing_file
->value
.s
) {
4553 if (!strcmp(filename
, backing_file
->value
.s
)) {
4554 error_setg(errp
, "Error: Trying to create an image with the "
4555 "same filename as the backing file");
4560 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4561 if (backing_fmt
&& backing_fmt
->value
.s
) {
4562 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4564 error_setg(errp
, "Unknown backing file format '%s'",
4565 backing_fmt
->value
.s
);
4570 // The size for the image must always be specified, with one exception:
4571 // If we are using a backing file, we can obtain the size from there
4572 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4573 if (size
&& size
->value
.n
== -1) {
4574 if (backing_file
&& backing_file
->value
.s
) {
4579 /* backing files always opened read-only */
4581 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4585 ret
= bdrv_open(bs
, backing_file
->value
.s
, back_flags
, backing_drv
);
4587 error_setg_errno(errp
, -ret
, "Could not open '%s'",
4588 backing_file
->value
.s
);
4591 bdrv_get_geometry(bs
, &size
);
4594 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4595 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4597 error_setg(errp
, "Image creation needs a size parameter");
4602 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4603 print_option_parameters(param
);
4606 ret
= bdrv_create(drv
, filename
, param
);
4608 if (ret
== -ENOTSUP
) {
4609 error_setg(errp
,"Formatting or formatting option not supported for "
4610 "file format '%s'", fmt
);
4611 } else if (ret
== -EFBIG
) {
4612 error_setg(errp
, "The image size is too large for file format '%s'",
4615 error_setg(errp
, "%s: error while creating %s: %s", filename
, fmt
,
4621 free_option_parameters(create_options
);
4622 free_option_parameters(param
);