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,
59 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
60 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
61 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
62 BlockDriverCompletionFunc
*cb
, void *opaque
);
63 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
64 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
65 BlockDriverCompletionFunc
*cb
, void *opaque
);
66 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
67 int64_t sector_num
, int nb_sectors
,
69 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
70 int64_t sector_num
, int nb_sectors
,
72 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
73 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
74 BdrvRequestFlags flags
);
75 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
76 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
77 BdrvRequestFlags flags
);
78 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
82 BlockDriverCompletionFunc
*cb
,
85 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
86 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
87 int64_t sector_num
, int nb_sectors
);
89 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
90 bool is_write
, double elapsed_time
, uint64_t *wait
);
91 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
92 double elapsed_time
, uint64_t *wait
);
93 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
94 bool is_write
, int64_t *wait
);
96 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
97 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
99 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
100 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
102 /* The device to use for VM snapshots */
103 static BlockDriverState
*bs_snapshots
;
105 /* If non-zero, use only whitelisted block drivers */
106 static int use_bdrv_whitelist
;
109 static int is_windows_drive_prefix(const char *filename
)
111 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
112 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
116 int is_windows_drive(const char *filename
)
118 if (is_windows_drive_prefix(filename
) &&
121 if (strstart(filename
, "\\\\.\\", NULL
) ||
122 strstart(filename
, "//./", NULL
))
128 /* throttling disk I/O limits */
129 void bdrv_io_limits_disable(BlockDriverState
*bs
)
131 bs
->io_limits_enabled
= false;
133 while (qemu_co_queue_next(&bs
->throttled_reqs
));
135 if (bs
->block_timer
) {
136 qemu_del_timer(bs
->block_timer
);
137 qemu_free_timer(bs
->block_timer
);
138 bs
->block_timer
= NULL
;
144 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
147 static void bdrv_block_timer(void *opaque
)
149 BlockDriverState
*bs
= opaque
;
151 qemu_co_queue_next(&bs
->throttled_reqs
);
154 void bdrv_io_limits_enable(BlockDriverState
*bs
)
156 qemu_co_queue_init(&bs
->throttled_reqs
);
157 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
158 bs
->io_limits_enabled
= true;
161 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
163 BlockIOLimit
*io_limits
= &bs
->io_limits
;
164 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
165 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
166 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
167 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
168 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
169 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
172 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
173 bool is_write
, int nb_sectors
)
175 int64_t wait_time
= -1;
177 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
178 qemu_co_queue_wait(&bs
->throttled_reqs
);
181 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
182 * throttled requests will not be dequeued until the current request is
183 * allowed to be serviced. So if the current request still exceeds the
184 * limits, it will be inserted to the head. All requests followed it will
185 * be still in throttled_reqs queue.
188 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
189 qemu_mod_timer(bs
->block_timer
,
190 wait_time
+ qemu_get_clock_ns(vm_clock
));
191 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
194 qemu_co_queue_next(&bs
->throttled_reqs
);
197 /* check if the path starts with "<protocol>:" */
198 static int path_has_protocol(const char *path
)
203 if (is_windows_drive(path
) ||
204 is_windows_drive_prefix(path
)) {
207 p
= path
+ strcspn(path
, ":/\\");
209 p
= path
+ strcspn(path
, ":/");
215 int path_is_absolute(const char *path
)
218 /* specific case for names like: "\\.\d:" */
219 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
222 return (*path
== '/' || *path
== '\\');
224 return (*path
== '/');
228 /* if filename is absolute, just copy it to dest. Otherwise, build a
229 path to it by considering it is relative to base_path. URL are
231 void path_combine(char *dest
, int dest_size
,
232 const char *base_path
,
233 const char *filename
)
240 if (path_is_absolute(filename
)) {
241 pstrcpy(dest
, dest_size
, filename
);
243 p
= strchr(base_path
, ':');
248 p1
= strrchr(base_path
, '/');
252 p2
= strrchr(base_path
, '\\');
264 if (len
> dest_size
- 1)
266 memcpy(dest
, base_path
, len
);
268 pstrcat(dest
, dest_size
, filename
);
272 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
274 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
275 pstrcpy(dest
, sz
, bs
->backing_file
);
277 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
281 void bdrv_register(BlockDriver
*bdrv
)
283 /* Block drivers without coroutine functions need emulation */
284 if (!bdrv
->bdrv_co_readv
) {
285 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
286 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
288 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
289 * the block driver lacks aio we need to emulate that too.
291 if (!bdrv
->bdrv_aio_readv
) {
292 /* add AIO emulation layer */
293 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
294 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
298 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
301 /* create a new block device (by default it is empty) */
302 BlockDriverState
*bdrv_new(const char *device_name
)
304 BlockDriverState
*bs
;
306 bs
= g_malloc0(sizeof(BlockDriverState
));
307 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
308 if (device_name
[0] != '\0') {
309 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
311 bdrv_iostatus_disable(bs
);
312 notifier_list_init(&bs
->close_notifiers
);
317 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
319 notifier_list_add(&bs
->close_notifiers
, notify
);
322 BlockDriver
*bdrv_find_format(const char *format_name
)
325 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
326 if (!strcmp(drv1
->format_name
, format_name
)) {
333 static int bdrv_is_whitelisted(BlockDriver
*drv
)
335 static const char *whitelist
[] = {
336 CONFIG_BDRV_WHITELIST
341 return 1; /* no whitelist, anything goes */
343 for (p
= whitelist
; *p
; p
++) {
344 if (!strcmp(drv
->format_name
, *p
)) {
351 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
)
353 BlockDriver
*drv
= bdrv_find_format(format_name
);
354 return drv
&& bdrv_is_whitelisted(drv
) ? drv
: NULL
;
357 typedef struct CreateCo
{
360 QEMUOptionParameter
*options
;
364 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
366 CreateCo
*cco
= opaque
;
369 cco
->ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
);
372 int bdrv_create(BlockDriver
*drv
, const char* filename
,
373 QEMUOptionParameter
*options
)
380 .filename
= g_strdup(filename
),
385 if (!drv
->bdrv_create
) {
390 if (qemu_in_coroutine()) {
391 /* Fast-path if already in coroutine context */
392 bdrv_create_co_entry(&cco
);
394 co
= qemu_coroutine_create(bdrv_create_co_entry
);
395 qemu_coroutine_enter(co
, &cco
);
396 while (cco
.ret
== NOT_DONE
) {
404 g_free(cco
.filename
);
408 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
412 drv
= bdrv_find_protocol(filename
);
417 return bdrv_create(drv
, filename
, options
);
421 * Create a uniquely-named empty temporary file.
422 * Return 0 upon success, otherwise a negative errno value.
424 int get_tmp_filename(char *filename
, int size
)
427 char temp_dir
[MAX_PATH
];
428 /* GetTempFileName requires that its output buffer (4th param)
429 have length MAX_PATH or greater. */
430 assert(size
>= MAX_PATH
);
431 return (GetTempPath(MAX_PATH
, temp_dir
)
432 && GetTempFileName(temp_dir
, "qem", 0, filename
)
433 ? 0 : -GetLastError());
437 tmpdir
= getenv("TMPDIR");
440 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
443 fd
= mkstemp(filename
);
447 if (close(fd
) != 0) {
456 * Detect host devices. By convention, /dev/cdrom[N] is always
457 * recognized as a host CDROM.
459 static BlockDriver
*find_hdev_driver(const char *filename
)
461 int score_max
= 0, score
;
462 BlockDriver
*drv
= NULL
, *d
;
464 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
465 if (d
->bdrv_probe_device
) {
466 score
= d
->bdrv_probe_device(filename
);
467 if (score
> score_max
) {
477 BlockDriver
*bdrv_find_protocol(const char *filename
)
484 /* TODO Drivers without bdrv_file_open must be specified explicitly */
487 * XXX(hch): we really should not let host device detection
488 * override an explicit protocol specification, but moving this
489 * later breaks access to device names with colons in them.
490 * Thanks to the brain-dead persistent naming schemes on udev-
491 * based Linux systems those actually are quite common.
493 drv1
= find_hdev_driver(filename
);
498 if (!path_has_protocol(filename
)) {
499 return bdrv_find_format("file");
501 p
= strchr(filename
, ':');
504 if (len
> sizeof(protocol
) - 1)
505 len
= sizeof(protocol
) - 1;
506 memcpy(protocol
, filename
, len
);
507 protocol
[len
] = '\0';
508 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
509 if (drv1
->protocol_name
&&
510 !strcmp(drv1
->protocol_name
, protocol
)) {
517 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
520 int score
, score_max
;
521 BlockDriver
*drv1
, *drv
;
525 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
526 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
527 drv
= bdrv_find_format("raw");
535 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
543 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
544 if (drv1
->bdrv_probe
) {
545 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
546 if (score
> score_max
) {
560 * Set the current 'total_sectors' value
562 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
564 BlockDriver
*drv
= bs
->drv
;
566 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
570 /* query actual device if possible, otherwise just trust the hint */
571 if (drv
->bdrv_getlength
) {
572 int64_t length
= drv
->bdrv_getlength(bs
);
576 hint
= length
>> BDRV_SECTOR_BITS
;
579 bs
->total_sectors
= hint
;
584 * Set open flags for a given discard mode
586 * Return 0 on success, -1 if the discard mode was invalid.
588 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
590 *flags
&= ~BDRV_O_UNMAP
;
592 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
594 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
595 *flags
|= BDRV_O_UNMAP
;
604 * Set open flags for a given cache mode
606 * Return 0 on success, -1 if the cache mode was invalid.
608 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
610 *flags
&= ~BDRV_O_CACHE_MASK
;
612 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
613 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
614 } else if (!strcmp(mode
, "directsync")) {
615 *flags
|= BDRV_O_NOCACHE
;
616 } else if (!strcmp(mode
, "writeback")) {
617 *flags
|= BDRV_O_CACHE_WB
;
618 } else if (!strcmp(mode
, "unsafe")) {
619 *flags
|= BDRV_O_CACHE_WB
;
620 *flags
|= BDRV_O_NO_FLUSH
;
621 } else if (!strcmp(mode
, "writethrough")) {
622 /* this is the default */
631 * The copy-on-read flag is actually a reference count so multiple users may
632 * use the feature without worrying about clobbering its previous state.
633 * Copy-on-read stays enabled until all users have called to disable it.
635 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
640 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
642 assert(bs
->copy_on_read
> 0);
646 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
648 int open_flags
= flags
| BDRV_O_CACHE_WB
;
651 * Clear flags that are internal to the block layer before opening the
654 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
657 * Snapshots should be writable.
659 if (bs
->is_temporary
) {
660 open_flags
|= BDRV_O_RDWR
;
667 * Common part for opening disk images and files
669 * Removes all processed options from *options.
671 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
672 const char *filename
, QDict
*options
,
673 int flags
, BlockDriver
*drv
)
678 assert(bs
->file
== NULL
);
679 assert(options
== NULL
|| bs
->options
!= options
);
681 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
683 bs
->open_flags
= flags
;
684 bs
->buffer_alignment
= 512;
686 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
687 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
688 bdrv_enable_copy_on_read(bs
);
691 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
693 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
698 bs
->opaque
= g_malloc0(drv
->instance_size
);
700 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
701 open_flags
= bdrv_open_flags(bs
, flags
);
703 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
705 /* Open the image, either directly or using a protocol */
706 if (drv
->bdrv_file_open
) {
711 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
714 assert(file
!= NULL
);
716 ret
= drv
->bdrv_open(bs
, options
, open_flags
);
723 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
729 if (bs
->is_temporary
) {
744 * Opens a file using a protocol (file, host_device, nbd, ...)
746 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
748 BlockDriverState
*bs
;
752 drv
= bdrv_find_protocol(filename
);
758 ret
= bdrv_open_common(bs
, NULL
, filename
, NULL
, flags
, drv
);
768 int bdrv_open_backing_file(BlockDriverState
*bs
)
770 char backing_filename
[PATH_MAX
];
772 BlockDriver
*back_drv
= NULL
;
774 if (bs
->backing_hd
!= NULL
) {
778 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
779 if (bs
->backing_file
[0] == '\0') {
783 bs
->backing_hd
= bdrv_new("");
784 bdrv_get_full_backing_filename(bs
, backing_filename
,
785 sizeof(backing_filename
));
787 if (bs
->backing_format
[0] != '\0') {
788 back_drv
= bdrv_find_format(bs
->backing_format
);
791 /* backing files always opened read-only */
792 back_flags
= bs
->open_flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
);
794 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, NULL
,
795 back_flags
, back_drv
);
797 bdrv_delete(bs
->backing_hd
);
798 bs
->backing_hd
= NULL
;
799 bs
->open_flags
|= BDRV_O_NO_BACKING
;
806 * Opens a disk image (raw, qcow2, vmdk, ...)
808 * options is a QDict of options to pass to the block drivers, or NULL for an
809 * empty set of options. The reference to the QDict belongs to the block layer
810 * after the call (even on failure), so if the caller intends to reuse the
811 * dictionary, it needs to use QINCREF() before calling bdrv_open.
813 int bdrv_open(BlockDriverState
*bs
, const char *filename
, QDict
*options
,
814 int flags
, BlockDriver
*drv
)
817 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
818 char tmp_filename
[PATH_MAX
+ 1];
819 BlockDriverState
*file
= NULL
;
821 /* NULL means an empty set of options */
822 if (options
== NULL
) {
823 options
= qdict_new();
826 bs
->options
= options
;
827 options
= qdict_clone_shallow(options
);
829 /* For snapshot=on, create a temporary qcow2 overlay */
830 if (flags
& BDRV_O_SNAPSHOT
) {
831 BlockDriverState
*bs1
;
833 BlockDriver
*bdrv_qcow2
;
834 QEMUOptionParameter
*options
;
835 char backing_filename
[PATH_MAX
];
837 /* if snapshot, we create a temporary backing file and open it
838 instead of opening 'filename' directly */
840 /* if there is a backing file, use it */
842 ret
= bdrv_open(bs1
, filename
, NULL
, 0, drv
);
847 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
851 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
856 /* Real path is meaningless for protocols */
857 if (path_has_protocol(filename
)) {
858 snprintf(backing_filename
, sizeof(backing_filename
),
860 } else if (!realpath(filename
, backing_filename
)) {
865 bdrv_qcow2
= bdrv_find_format("qcow2");
866 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
868 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
869 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
871 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
875 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
876 free_option_parameters(options
);
881 filename
= tmp_filename
;
883 bs
->is_temporary
= 1;
886 /* Open image file without format layer */
887 if (flags
& BDRV_O_RDWR
) {
888 flags
|= BDRV_O_ALLOW_RDWR
;
891 ret
= bdrv_file_open(&file
, filename
, bdrv_open_flags(bs
, flags
));
896 /* Find the right image format driver */
898 ret
= find_image_format(file
, filename
, &drv
);
902 goto unlink_and_fail
;
906 ret
= bdrv_open_common(bs
, file
, filename
, options
, flags
, drv
);
908 goto unlink_and_fail
;
911 if (bs
->file
!= file
) {
916 /* If there is a backing file, use it */
917 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
918 ret
= bdrv_open_backing_file(bs
);
924 /* Check if any unknown options were used */
925 if (qdict_size(options
) != 0) {
926 const QDictEntry
*entry
= qdict_first(options
);
927 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Block format '%s' used by "
928 "device '%s' doesn't support the option '%s'",
929 drv
->format_name
, bs
->device_name
, entry
->key
);
936 if (!bdrv_key_required(bs
)) {
937 bdrv_dev_change_media_cb(bs
, true);
940 /* throttling disk I/O limits */
941 if (bs
->io_limits_enabled
) {
942 bdrv_io_limits_enable(bs
);
951 if (bs
->is_temporary
) {
955 QDECREF(bs
->options
);
966 typedef struct BlockReopenQueueEntry
{
968 BDRVReopenState state
;
969 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
970 } BlockReopenQueueEntry
;
973 * Adds a BlockDriverState to a simple queue for an atomic, transactional
974 * reopen of multiple devices.
976 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
977 * already performed, or alternatively may be NULL a new BlockReopenQueue will
978 * be created and initialized. This newly created BlockReopenQueue should be
979 * passed back in for subsequent calls that are intended to be of the same
982 * bs is the BlockDriverState to add to the reopen queue.
984 * flags contains the open flags for the associated bs
986 * returns a pointer to bs_queue, which is either the newly allocated
987 * bs_queue, or the existing bs_queue being used.
990 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
991 BlockDriverState
*bs
, int flags
)
995 BlockReopenQueueEntry
*bs_entry
;
996 if (bs_queue
== NULL
) {
997 bs_queue
= g_new0(BlockReopenQueue
, 1);
998 QSIMPLEQ_INIT(bs_queue
);
1002 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
1005 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1006 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1008 bs_entry
->state
.bs
= bs
;
1009 bs_entry
->state
.flags
= flags
;
1015 * Reopen multiple BlockDriverStates atomically & transactionally.
1017 * The queue passed in (bs_queue) must have been built up previous
1018 * via bdrv_reopen_queue().
1020 * Reopens all BDS specified in the queue, with the appropriate
1021 * flags. All devices are prepared for reopen, and failure of any
1022 * device will cause all device changes to be abandonded, and intermediate
1025 * If all devices prepare successfully, then the changes are committed
1029 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1032 BlockReopenQueueEntry
*bs_entry
, *next
;
1033 Error
*local_err
= NULL
;
1035 assert(bs_queue
!= NULL
);
1039 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1040 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1041 error_propagate(errp
, local_err
);
1044 bs_entry
->prepared
= true;
1047 /* If we reach this point, we have success and just need to apply the
1050 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1051 bdrv_reopen_commit(&bs_entry
->state
);
1057 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1058 if (ret
&& bs_entry
->prepared
) {
1059 bdrv_reopen_abort(&bs_entry
->state
);
1068 /* Reopen a single BlockDriverState with the specified flags. */
1069 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1072 Error
*local_err
= NULL
;
1073 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1075 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1076 if (local_err
!= NULL
) {
1077 error_propagate(errp
, local_err
);
1084 * Prepares a BlockDriverState for reopen. All changes are staged in the
1085 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1086 * the block driver layer .bdrv_reopen_prepare()
1088 * bs is the BlockDriverState to reopen
1089 * flags are the new open flags
1090 * queue is the reopen queue
1092 * Returns 0 on success, non-zero on error. On error errp will be set
1095 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1096 * It is the responsibility of the caller to then call the abort() or
1097 * commit() for any other BDS that have been left in a prepare() state
1100 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1104 Error
*local_err
= NULL
;
1107 assert(reopen_state
!= NULL
);
1108 assert(reopen_state
->bs
->drv
!= NULL
);
1109 drv
= reopen_state
->bs
->drv
;
1111 /* if we are to stay read-only, do not allow permission change
1113 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1114 reopen_state
->flags
& BDRV_O_RDWR
) {
1115 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1116 reopen_state
->bs
->device_name
);
1121 ret
= bdrv_flush(reopen_state
->bs
);
1123 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1128 if (drv
->bdrv_reopen_prepare
) {
1129 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1131 if (local_err
!= NULL
) {
1132 error_propagate(errp
, local_err
);
1134 error_set(errp
, QERR_OPEN_FILE_FAILED
,
1135 reopen_state
->bs
->filename
);
1140 /* It is currently mandatory to have a bdrv_reopen_prepare()
1141 * handler for each supported drv. */
1142 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1143 drv
->format_name
, reopen_state
->bs
->device_name
,
1144 "reopening of file");
1156 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1157 * makes them final by swapping the staging BlockDriverState contents into
1158 * the active BlockDriverState contents.
1160 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1164 assert(reopen_state
!= NULL
);
1165 drv
= reopen_state
->bs
->drv
;
1166 assert(drv
!= NULL
);
1168 /* If there are any driver level actions to take */
1169 if (drv
->bdrv_reopen_commit
) {
1170 drv
->bdrv_reopen_commit(reopen_state
);
1173 /* set BDS specific flags now */
1174 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1175 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1177 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1181 * Abort the reopen, and delete and free the staged changes in
1184 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1188 assert(reopen_state
!= NULL
);
1189 drv
= reopen_state
->bs
->drv
;
1190 assert(drv
!= NULL
);
1192 if (drv
->bdrv_reopen_abort
) {
1193 drv
->bdrv_reopen_abort(reopen_state
);
1198 void bdrv_close(BlockDriverState
*bs
)
1202 block_job_cancel_sync(bs
->job
);
1205 notifier_list_notify(&bs
->close_notifiers
, bs
);
1208 if (bs
== bs_snapshots
) {
1209 bs_snapshots
= NULL
;
1211 if (bs
->backing_hd
) {
1212 bdrv_delete(bs
->backing_hd
);
1213 bs
->backing_hd
= NULL
;
1215 bs
->drv
->bdrv_close(bs
);
1218 if (bs
->is_temporary
) {
1219 unlink(bs
->filename
);
1224 bs
->copy_on_read
= 0;
1225 bs
->backing_file
[0] = '\0';
1226 bs
->backing_format
[0] = '\0';
1227 bs
->total_sectors
= 0;
1232 QDECREF(bs
->options
);
1235 if (bs
->file
!= NULL
) {
1236 bdrv_delete(bs
->file
);
1241 bdrv_dev_change_media_cb(bs
, false);
1243 /*throttling disk I/O limits*/
1244 if (bs
->io_limits_enabled
) {
1245 bdrv_io_limits_disable(bs
);
1249 void bdrv_close_all(void)
1251 BlockDriverState
*bs
;
1253 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1259 * Wait for pending requests to complete across all BlockDriverStates
1261 * This function does not flush data to disk, use bdrv_flush_all() for that
1262 * after calling this function.
1264 * Note that completion of an asynchronous I/O operation can trigger any
1265 * number of other I/O operations on other devices---for example a coroutine
1266 * can be arbitrarily complex and a constant flow of I/O can come until the
1267 * coroutine is complete. Because of this, it is not possible to have a
1268 * function to drain a single device's I/O queue.
1270 void bdrv_drain_all(void)
1272 BlockDriverState
*bs
;
1276 busy
= qemu_aio_wait();
1278 /* FIXME: We do not have timer support here, so this is effectively
1281 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1282 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
1283 qemu_co_queue_restart_all(&bs
->throttled_reqs
);
1289 /* If requests are still pending there is a bug somewhere */
1290 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1291 assert(QLIST_EMPTY(&bs
->tracked_requests
));
1292 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
1296 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1297 Also, NULL terminate the device_name to prevent double remove */
1298 void bdrv_make_anon(BlockDriverState
*bs
)
1300 if (bs
->device_name
[0] != '\0') {
1301 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
1303 bs
->device_name
[0] = '\0';
1306 static void bdrv_rebind(BlockDriverState
*bs
)
1308 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1309 bs
->drv
->bdrv_rebind(bs
);
1313 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1314 BlockDriverState
*bs_src
)
1316 /* move some fields that need to stay attached to the device */
1317 bs_dest
->open_flags
= bs_src
->open_flags
;
1320 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1321 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1322 bs_dest
->dev
= bs_src
->dev
;
1323 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
1324 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1326 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1328 /* i/o timing parameters */
1329 bs_dest
->slice_time
= bs_src
->slice_time
;
1330 bs_dest
->slice_start
= bs_src
->slice_start
;
1331 bs_dest
->slice_end
= bs_src
->slice_end
;
1332 bs_dest
->io_limits
= bs_src
->io_limits
;
1333 bs_dest
->io_base
= bs_src
->io_base
;
1334 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
1335 bs_dest
->block_timer
= bs_src
->block_timer
;
1336 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1339 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1340 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1343 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1344 bs_dest
->iostatus
= bs_src
->iostatus
;
1347 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1350 bs_dest
->in_use
= bs_src
->in_use
;
1351 bs_dest
->job
= bs_src
->job
;
1353 /* keep the same entry in bdrv_states */
1354 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1355 bs_src
->device_name
);
1356 bs_dest
->list
= bs_src
->list
;
1360 * Swap bs contents for two image chains while they are live,
1361 * while keeping required fields on the BlockDriverState that is
1362 * actually attached to a device.
1364 * This will modify the BlockDriverState fields, and swap contents
1365 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1367 * bs_new is required to be anonymous.
1369 * This function does not create any image files.
1371 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1373 BlockDriverState tmp
;
1375 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1376 assert(bs_new
->device_name
[0] == '\0');
1377 assert(bs_new
->dirty_bitmap
== NULL
);
1378 assert(bs_new
->job
== NULL
);
1379 assert(bs_new
->dev
== NULL
);
1380 assert(bs_new
->in_use
== 0);
1381 assert(bs_new
->io_limits_enabled
== false);
1382 assert(bs_new
->block_timer
== NULL
);
1388 /* there are some fields that should not be swapped, move them back */
1389 bdrv_move_feature_fields(&tmp
, bs_old
);
1390 bdrv_move_feature_fields(bs_old
, bs_new
);
1391 bdrv_move_feature_fields(bs_new
, &tmp
);
1393 /* bs_new shouldn't be in bdrv_states even after the swap! */
1394 assert(bs_new
->device_name
[0] == '\0');
1396 /* Check a few fields that should remain attached to the device */
1397 assert(bs_new
->dev
== NULL
);
1398 assert(bs_new
->job
== NULL
);
1399 assert(bs_new
->in_use
== 0);
1400 assert(bs_new
->io_limits_enabled
== false);
1401 assert(bs_new
->block_timer
== NULL
);
1403 bdrv_rebind(bs_new
);
1404 bdrv_rebind(bs_old
);
1408 * Add new bs contents at the top of an image chain while the chain is
1409 * live, while keeping required fields on the top layer.
1411 * This will modify the BlockDriverState fields, and swap contents
1412 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1414 * bs_new is required to be anonymous.
1416 * This function does not create any image files.
1418 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1420 bdrv_swap(bs_new
, bs_top
);
1422 /* The contents of 'tmp' will become bs_top, as we are
1423 * swapping bs_new and bs_top contents. */
1424 bs_top
->backing_hd
= bs_new
;
1425 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1426 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1428 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1429 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1432 void bdrv_delete(BlockDriverState
*bs
)
1436 assert(!bs
->in_use
);
1438 /* remove from list, if necessary */
1443 assert(bs
!= bs_snapshots
);
1447 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1448 /* TODO change to DeviceState *dev when all users are qdevified */
1454 bdrv_iostatus_reset(bs
);
1458 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1459 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1461 if (bdrv_attach_dev(bs
, dev
) < 0) {
1466 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1467 /* TODO change to DeviceState *dev when all users are qdevified */
1469 assert(bs
->dev
== dev
);
1472 bs
->dev_opaque
= NULL
;
1473 bs
->buffer_alignment
= 512;
1476 /* TODO change to return DeviceState * when all users are qdevified */
1477 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1482 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1486 bs
->dev_opaque
= opaque
;
1487 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1488 bs_snapshots
= NULL
;
1492 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1493 enum MonitorEvent ev
,
1494 BlockErrorAction action
, bool is_read
)
1497 const char *action_str
;
1500 case BDRV_ACTION_REPORT
:
1501 action_str
= "report";
1503 case BDRV_ACTION_IGNORE
:
1504 action_str
= "ignore";
1506 case BDRV_ACTION_STOP
:
1507 action_str
= "stop";
1513 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1516 is_read
? "read" : "write");
1517 monitor_protocol_event(ev
, data
);
1519 qobject_decref(data
);
1522 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1526 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1527 bdrv_get_device_name(bs
), ejected
);
1528 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1530 qobject_decref(data
);
1533 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1535 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1536 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1537 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1538 if (tray_was_closed
) {
1540 bdrv_emit_qmp_eject_event(bs
, true);
1544 bdrv_emit_qmp_eject_event(bs
, false);
1549 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1551 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1554 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1556 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1557 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1561 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1563 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1564 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1569 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1571 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1572 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1576 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1578 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1579 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1585 * Run consistency checks on an image
1587 * Returns 0 if the check could be completed (it doesn't mean that the image is
1588 * free of errors) or -errno when an internal error occurred. The results of the
1589 * check are stored in res.
1591 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1593 if (bs
->drv
->bdrv_check
== NULL
) {
1597 memset(res
, 0, sizeof(*res
));
1598 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1601 #define COMMIT_BUF_SECTORS 2048
1603 /* commit COW file into the raw image */
1604 int bdrv_commit(BlockDriverState
*bs
)
1606 BlockDriver
*drv
= bs
->drv
;
1607 int64_t sector
, total_sectors
;
1608 int n
, ro
, open_flags
;
1611 char filename
[PATH_MAX
];
1616 if (!bs
->backing_hd
) {
1620 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1624 ro
= bs
->backing_hd
->read_only
;
1625 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1626 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
1627 open_flags
= bs
->backing_hd
->open_flags
;
1630 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
1635 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1636 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1638 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1639 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1641 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1646 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1653 if (drv
->bdrv_make_empty
) {
1654 ret
= drv
->bdrv_make_empty(bs
);
1659 * Make sure all data we wrote to the backing device is actually
1663 bdrv_flush(bs
->backing_hd
);
1669 /* ignoring error return here */
1670 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
1676 int bdrv_commit_all(void)
1678 BlockDriverState
*bs
;
1680 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1681 if (bs
->drv
&& bs
->backing_hd
) {
1682 int ret
= bdrv_commit(bs
);
1691 struct BdrvTrackedRequest
{
1692 BlockDriverState
*bs
;
1696 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1697 Coroutine
*co
; /* owner, used for deadlock detection */
1698 CoQueue wait_queue
; /* coroutines blocked on this request */
1702 * Remove an active request from the tracked requests list
1704 * This function should be called when a tracked request is completing.
1706 static void tracked_request_end(BdrvTrackedRequest
*req
)
1708 QLIST_REMOVE(req
, list
);
1709 qemu_co_queue_restart_all(&req
->wait_queue
);
1713 * Add an active request to the tracked requests list
1715 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1716 BlockDriverState
*bs
,
1718 int nb_sectors
, bool is_write
)
1720 *req
= (BdrvTrackedRequest
){
1722 .sector_num
= sector_num
,
1723 .nb_sectors
= nb_sectors
,
1724 .is_write
= is_write
,
1725 .co
= qemu_coroutine_self(),
1728 qemu_co_queue_init(&req
->wait_queue
);
1730 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1734 * Round a region to cluster boundaries
1736 void bdrv_round_to_clusters(BlockDriverState
*bs
,
1737 int64_t sector_num
, int nb_sectors
,
1738 int64_t *cluster_sector_num
,
1739 int *cluster_nb_sectors
)
1741 BlockDriverInfo bdi
;
1743 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1744 *cluster_sector_num
= sector_num
;
1745 *cluster_nb_sectors
= nb_sectors
;
1747 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1748 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1749 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1754 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1755 int64_t sector_num
, int nb_sectors
) {
1757 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1761 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1767 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1768 int64_t sector_num
, int nb_sectors
)
1770 BdrvTrackedRequest
*req
;
1771 int64_t cluster_sector_num
;
1772 int cluster_nb_sectors
;
1775 /* If we touch the same cluster it counts as an overlap. This guarantees
1776 * that allocating writes will be serialized and not race with each other
1777 * for the same cluster. For example, in copy-on-read it ensures that the
1778 * CoR read and write operations are atomic and guest writes cannot
1779 * interleave between them.
1781 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
1782 &cluster_sector_num
, &cluster_nb_sectors
);
1786 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1787 if (tracked_request_overlaps(req
, cluster_sector_num
,
1788 cluster_nb_sectors
)) {
1789 /* Hitting this means there was a reentrant request, for
1790 * example, a block driver issuing nested requests. This must
1791 * never happen since it means deadlock.
1793 assert(qemu_coroutine_self() != req
->co
);
1795 qemu_co_queue_wait(&req
->wait_queue
);
1806 * -EINVAL - backing format specified, but no file
1807 * -ENOSPC - can't update the backing file because no space is left in the
1809 * -ENOTSUP - format driver doesn't support changing the backing file
1811 int bdrv_change_backing_file(BlockDriverState
*bs
,
1812 const char *backing_file
, const char *backing_fmt
)
1814 BlockDriver
*drv
= bs
->drv
;
1817 /* Backing file format doesn't make sense without a backing file */
1818 if (backing_fmt
&& !backing_file
) {
1822 if (drv
->bdrv_change_backing_file
!= NULL
) {
1823 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1829 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1830 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1836 * Finds the image layer in the chain that has 'bs' as its backing file.
1838 * active is the current topmost image.
1840 * Returns NULL if bs is not found in active's image chain,
1841 * or if active == bs.
1843 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
1844 BlockDriverState
*bs
)
1846 BlockDriverState
*overlay
= NULL
;
1847 BlockDriverState
*intermediate
;
1849 assert(active
!= NULL
);
1852 /* if bs is the same as active, then by definition it has no overlay
1858 intermediate
= active
;
1859 while (intermediate
->backing_hd
) {
1860 if (intermediate
->backing_hd
== bs
) {
1861 overlay
= intermediate
;
1864 intermediate
= intermediate
->backing_hd
;
1870 typedef struct BlkIntermediateStates
{
1871 BlockDriverState
*bs
;
1872 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
1873 } BlkIntermediateStates
;
1877 * Drops images above 'base' up to and including 'top', and sets the image
1878 * above 'top' to have base as its backing file.
1880 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1881 * information in 'bs' can be properly updated.
1883 * E.g., this will convert the following chain:
1884 * bottom <- base <- intermediate <- top <- active
1888 * bottom <- base <- active
1890 * It is allowed for bottom==base, in which case it converts:
1892 * base <- intermediate <- top <- active
1899 * if active == top, that is considered an error
1902 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
1903 BlockDriverState
*base
)
1905 BlockDriverState
*intermediate
;
1906 BlockDriverState
*base_bs
= NULL
;
1907 BlockDriverState
*new_top_bs
= NULL
;
1908 BlkIntermediateStates
*intermediate_state
, *next
;
1911 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
1912 QSIMPLEQ_INIT(&states_to_delete
);
1914 if (!top
->drv
|| !base
->drv
) {
1918 new_top_bs
= bdrv_find_overlay(active
, top
);
1920 if (new_top_bs
== NULL
) {
1921 /* we could not find the image above 'top', this is an error */
1925 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1926 * to do, no intermediate images */
1927 if (new_top_bs
->backing_hd
== base
) {
1934 /* now we will go down through the list, and add each BDS we find
1935 * into our deletion queue, until we hit the 'base'
1937 while (intermediate
) {
1938 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
1939 intermediate_state
->bs
= intermediate
;
1940 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
1942 if (intermediate
->backing_hd
== base
) {
1943 base_bs
= intermediate
->backing_hd
;
1946 intermediate
= intermediate
->backing_hd
;
1948 if (base_bs
== NULL
) {
1949 /* something went wrong, we did not end at the base. safely
1950 * unravel everything, and exit with error */
1954 /* success - we can delete the intermediate states, and link top->base */
1955 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
1956 base_bs
->drv
? base_bs
->drv
->format_name
: "");
1960 new_top_bs
->backing_hd
= base_bs
;
1963 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1964 /* so that bdrv_close() does not recursively close the chain */
1965 intermediate_state
->bs
->backing_hd
= NULL
;
1966 bdrv_delete(intermediate_state
->bs
);
1971 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1972 g_free(intermediate_state
);
1978 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1983 if (!bdrv_is_inserted(bs
))
1989 len
= bdrv_getlength(bs
);
1994 if ((offset
> len
) || (len
- offset
< size
))
2000 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2003 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2004 nb_sectors
* BDRV_SECTOR_SIZE
);
2007 typedef struct RwCo
{
2008 BlockDriverState
*bs
;
2016 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2018 RwCo
*rwco
= opaque
;
2020 if (!rwco
->is_write
) {
2021 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
2022 rwco
->nb_sectors
, rwco
->qiov
, 0);
2024 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
2025 rwco
->nb_sectors
, rwco
->qiov
, 0);
2030 * Process a synchronous request using coroutines
2032 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2033 int nb_sectors
, bool is_write
)
2036 struct iovec iov
= {
2037 .iov_base
= (void *)buf
,
2038 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2043 .sector_num
= sector_num
,
2044 .nb_sectors
= nb_sectors
,
2046 .is_write
= is_write
,
2050 qemu_iovec_init_external(&qiov
, &iov
, 1);
2053 * In sync call context, when the vcpu is blocked, this throttling timer
2054 * will not fire; so the I/O throttling function has to be disabled here
2055 * if it has been enabled.
2057 if (bs
->io_limits_enabled
) {
2058 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2059 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2060 bdrv_io_limits_disable(bs
);
2063 if (qemu_in_coroutine()) {
2064 /* Fast-path if already in coroutine context */
2065 bdrv_rw_co_entry(&rwco
);
2067 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2068 qemu_coroutine_enter(co
, &rwco
);
2069 while (rwco
.ret
== NOT_DONE
) {
2076 /* return < 0 if error. See bdrv_write() for the return codes */
2077 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2078 uint8_t *buf
, int nb_sectors
)
2080 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
2083 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2084 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2085 uint8_t *buf
, int nb_sectors
)
2090 enabled
= bs
->io_limits_enabled
;
2091 bs
->io_limits_enabled
= false;
2092 ret
= bdrv_read(bs
, 0, buf
, 1);
2093 bs
->io_limits_enabled
= enabled
;
2097 /* Return < 0 if error. Important errors are:
2098 -EIO generic I/O error (may happen for all errors)
2099 -ENOMEDIUM No media inserted.
2100 -EINVAL Invalid sector number or nb_sectors
2101 -EACCES Trying to write a read-only device
2103 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2104 const uint8_t *buf
, int nb_sectors
)
2106 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
2109 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2110 void *buf
, int count1
)
2112 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2113 int len
, nb_sectors
, count
;
2118 /* first read to align to sector start */
2119 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2122 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2124 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2126 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2134 /* read the sectors "in place" */
2135 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2136 if (nb_sectors
> 0) {
2137 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2139 sector_num
+= nb_sectors
;
2140 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2145 /* add data from the last sector */
2147 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2149 memcpy(buf
, tmp_buf
, count
);
2154 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2155 const void *buf
, int count1
)
2157 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2158 int len
, nb_sectors
, count
;
2163 /* first write to align to sector start */
2164 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2167 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2169 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2171 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
2172 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2181 /* write the sectors "in place" */
2182 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2183 if (nb_sectors
> 0) {
2184 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2186 sector_num
+= nb_sectors
;
2187 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2192 /* add data from the last sector */
2194 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2196 memcpy(tmp_buf
, buf
, count
);
2197 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2204 * Writes to the file and ensures that no writes are reordered across this
2205 * request (acts as a barrier)
2207 * Returns 0 on success, -errno in error cases.
2209 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2210 const void *buf
, int count
)
2214 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2219 /* No flush needed for cache modes that already do it */
2220 if (bs
->enable_write_cache
) {
2227 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2228 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2230 /* Perform I/O through a temporary buffer so that users who scribble over
2231 * their read buffer while the operation is in progress do not end up
2232 * modifying the image file. This is critical for zero-copy guest I/O
2233 * where anything might happen inside guest memory.
2235 void *bounce_buffer
;
2237 BlockDriver
*drv
= bs
->drv
;
2239 QEMUIOVector bounce_qiov
;
2240 int64_t cluster_sector_num
;
2241 int cluster_nb_sectors
;
2245 /* Cover entire cluster so no additional backing file I/O is required when
2246 * allocating cluster in the image file.
2248 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2249 &cluster_sector_num
, &cluster_nb_sectors
);
2251 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2252 cluster_sector_num
, cluster_nb_sectors
);
2254 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2255 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2256 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2258 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2264 if (drv
->bdrv_co_write_zeroes
&&
2265 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2266 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2267 cluster_nb_sectors
);
2269 /* This does not change the data on the disk, it is not necessary
2270 * to flush even in cache=writethrough mode.
2272 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2277 /* It might be okay to ignore write errors for guest requests. If this
2278 * is a deliberate copy-on-read then we don't want to ignore the error.
2279 * Simply report it in all cases.
2284 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2285 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2286 nb_sectors
* BDRV_SECTOR_SIZE
);
2289 qemu_vfree(bounce_buffer
);
2294 * Handle a read request in coroutine context
2296 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
2297 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2298 BdrvRequestFlags flags
)
2300 BlockDriver
*drv
= bs
->drv
;
2301 BdrvTrackedRequest req
;
2307 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2311 /* throttling disk read I/O */
2312 if (bs
->io_limits_enabled
) {
2313 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
2316 if (bs
->copy_on_read
) {
2317 flags
|= BDRV_REQ_COPY_ON_READ
;
2319 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2320 bs
->copy_on_read_in_flight
++;
2323 if (bs
->copy_on_read_in_flight
) {
2324 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2327 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
2329 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2332 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2337 if (!ret
|| pnum
!= nb_sectors
) {
2338 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2343 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2346 tracked_request_end(&req
);
2348 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2349 bs
->copy_on_read_in_flight
--;
2355 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2356 int nb_sectors
, QEMUIOVector
*qiov
)
2358 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
2360 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
2363 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
2364 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2366 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
2368 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
2369 BDRV_REQ_COPY_ON_READ
);
2372 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
2373 int64_t sector_num
, int nb_sectors
)
2375 BlockDriver
*drv
= bs
->drv
;
2380 /* TODO Emulate only part of misaligned requests instead of letting block
2381 * drivers return -ENOTSUP and emulate everything */
2383 /* First try the efficient write zeroes operation */
2384 if (drv
->bdrv_co_write_zeroes
) {
2385 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2386 if (ret
!= -ENOTSUP
) {
2391 /* Fall back to bounce buffer if write zeroes is unsupported */
2392 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
2393 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
2394 memset(iov
.iov_base
, 0, iov
.iov_len
);
2395 qemu_iovec_init_external(&qiov
, &iov
, 1);
2397 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
2399 qemu_vfree(iov
.iov_base
);
2404 * Handle a write request in coroutine context
2406 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
2407 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2408 BdrvRequestFlags flags
)
2410 BlockDriver
*drv
= bs
->drv
;
2411 BdrvTrackedRequest req
;
2417 if (bs
->read_only
) {
2420 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2424 /* throttling disk write I/O */
2425 if (bs
->io_limits_enabled
) {
2426 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2429 if (bs
->copy_on_read_in_flight
) {
2430 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2433 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2435 if (flags
& BDRV_REQ_ZERO_WRITE
) {
2436 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2438 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2441 if (ret
== 0 && !bs
->enable_write_cache
) {
2442 ret
= bdrv_co_flush(bs
);
2445 if (bs
->dirty_bitmap
) {
2446 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
2449 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2450 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2453 tracked_request_end(&req
);
2458 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2459 int nb_sectors
, QEMUIOVector
*qiov
)
2461 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2463 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2466 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2467 int64_t sector_num
, int nb_sectors
)
2469 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2471 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2472 BDRV_REQ_ZERO_WRITE
);
2476 * Truncate file to 'offset' bytes (needed only for file protocols)
2478 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2480 BlockDriver
*drv
= bs
->drv
;
2484 if (!drv
->bdrv_truncate
)
2488 if (bdrv_in_use(bs
))
2490 ret
= drv
->bdrv_truncate(bs
, offset
);
2492 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2493 bdrv_dev_resize_cb(bs
);
2499 * Length of a allocated file in bytes. Sparse files are counted by actual
2500 * allocated space. Return < 0 if error or unknown.
2502 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2504 BlockDriver
*drv
= bs
->drv
;
2508 if (drv
->bdrv_get_allocated_file_size
) {
2509 return drv
->bdrv_get_allocated_file_size(bs
);
2512 return bdrv_get_allocated_file_size(bs
->file
);
2518 * Length of a file in bytes. Return < 0 if error or unknown.
2520 int64_t bdrv_getlength(BlockDriverState
*bs
)
2522 BlockDriver
*drv
= bs
->drv
;
2526 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2527 if (drv
->bdrv_getlength
) {
2528 return drv
->bdrv_getlength(bs
);
2531 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2534 /* return 0 as number of sectors if no device present or error */
2535 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2538 length
= bdrv_getlength(bs
);
2542 length
= length
>> BDRV_SECTOR_BITS
;
2543 *nb_sectors_ptr
= length
;
2546 /* throttling disk io limits */
2547 void bdrv_set_io_limits(BlockDriverState
*bs
,
2548 BlockIOLimit
*io_limits
)
2550 bs
->io_limits
= *io_limits
;
2551 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2554 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2555 BlockdevOnError on_write_error
)
2557 bs
->on_read_error
= on_read_error
;
2558 bs
->on_write_error
= on_write_error
;
2561 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2563 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2566 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2568 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2571 case BLOCKDEV_ON_ERROR_ENOSPC
:
2572 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
2573 case BLOCKDEV_ON_ERROR_STOP
:
2574 return BDRV_ACTION_STOP
;
2575 case BLOCKDEV_ON_ERROR_REPORT
:
2576 return BDRV_ACTION_REPORT
;
2577 case BLOCKDEV_ON_ERROR_IGNORE
:
2578 return BDRV_ACTION_IGNORE
;
2584 /* This is done by device models because, while the block layer knows
2585 * about the error, it does not know whether an operation comes from
2586 * the device or the block layer (from a job, for example).
2588 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2589 bool is_read
, int error
)
2592 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
2593 if (action
== BDRV_ACTION_STOP
) {
2594 vm_stop(RUN_STATE_IO_ERROR
);
2595 bdrv_iostatus_set_err(bs
, error
);
2599 int bdrv_is_read_only(BlockDriverState
*bs
)
2601 return bs
->read_only
;
2604 int bdrv_is_sg(BlockDriverState
*bs
)
2609 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2611 return bs
->enable_write_cache
;
2614 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2616 bs
->enable_write_cache
= wce
;
2618 /* so a reopen() will preserve wce */
2620 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2622 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2626 int bdrv_is_encrypted(BlockDriverState
*bs
)
2628 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2630 return bs
->encrypted
;
2633 int bdrv_key_required(BlockDriverState
*bs
)
2635 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2637 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2639 return (bs
->encrypted
&& !bs
->valid_key
);
2642 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2645 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2646 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2652 if (!bs
->encrypted
) {
2654 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2657 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2660 } else if (!bs
->valid_key
) {
2662 /* call the change callback now, we skipped it on open */
2663 bdrv_dev_change_media_cb(bs
, true);
2668 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2670 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2673 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2678 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2679 it(opaque
, drv
->format_name
);
2683 BlockDriverState
*bdrv_find(const char *name
)
2685 BlockDriverState
*bs
;
2687 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2688 if (!strcmp(name
, bs
->device_name
)) {
2695 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2698 return QTAILQ_FIRST(&bdrv_states
);
2700 return QTAILQ_NEXT(bs
, list
);
2703 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2705 BlockDriverState
*bs
;
2707 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2712 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2714 return bs
->device_name
;
2717 int bdrv_get_flags(BlockDriverState
*bs
)
2719 return bs
->open_flags
;
2722 void bdrv_flush_all(void)
2724 BlockDriverState
*bs
;
2726 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2731 int bdrv_has_zero_init(BlockDriverState
*bs
)
2735 if (bs
->drv
->bdrv_has_zero_init
) {
2736 return bs
->drv
->bdrv_has_zero_init(bs
);
2742 typedef struct BdrvCoIsAllocatedData
{
2743 BlockDriverState
*bs
;
2744 BlockDriverState
*base
;
2750 } BdrvCoIsAllocatedData
;
2753 * Returns true iff the specified sector is present in the disk image. Drivers
2754 * not implementing the functionality are assumed to not support backing files,
2755 * hence all their sectors are reported as allocated.
2757 * If 'sector_num' is beyond the end of the disk image the return value is 0
2758 * and 'pnum' is set to 0.
2760 * 'pnum' is set to the number of sectors (including and immediately following
2761 * the specified sector) that are known to be in the same
2762 * allocated/unallocated state.
2764 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2765 * beyond the end of the disk image it will be clamped.
2767 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2768 int nb_sectors
, int *pnum
)
2772 if (sector_num
>= bs
->total_sectors
) {
2777 n
= bs
->total_sectors
- sector_num
;
2778 if (n
< nb_sectors
) {
2782 if (!bs
->drv
->bdrv_co_is_allocated
) {
2787 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2790 /* Coroutine wrapper for bdrv_is_allocated() */
2791 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2793 BdrvCoIsAllocatedData
*data
= opaque
;
2794 BlockDriverState
*bs
= data
->bs
;
2796 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2802 * Synchronous wrapper around bdrv_co_is_allocated().
2804 * See bdrv_co_is_allocated() for details.
2806 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2810 BdrvCoIsAllocatedData data
= {
2812 .sector_num
= sector_num
,
2813 .nb_sectors
= nb_sectors
,
2818 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2819 qemu_coroutine_enter(co
, &data
);
2820 while (!data
.done
) {
2827 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2829 * Return true if the given sector is allocated in any image between
2830 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2831 * sector is allocated in any image of the chain. Return false otherwise.
2833 * 'pnum' is set to the number of sectors (including and immediately following
2834 * the specified sector) that are known to be in the same
2835 * allocated/unallocated state.
2838 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2839 BlockDriverState
*base
,
2841 int nb_sectors
, int *pnum
)
2843 BlockDriverState
*intermediate
;
2844 int ret
, n
= nb_sectors
;
2847 while (intermediate
&& intermediate
!= base
) {
2849 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2859 * [sector_num, nb_sectors] is unallocated on top but intermediate
2862 * [sector_num+x, nr_sectors] allocated.
2864 if (n
> pnum_inter
&&
2865 (intermediate
== top
||
2866 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
2870 intermediate
= intermediate
->backing_hd
;
2877 /* Coroutine wrapper for bdrv_is_allocated_above() */
2878 static void coroutine_fn
bdrv_is_allocated_above_co_entry(void *opaque
)
2880 BdrvCoIsAllocatedData
*data
= opaque
;
2881 BlockDriverState
*top
= data
->bs
;
2882 BlockDriverState
*base
= data
->base
;
2884 data
->ret
= bdrv_co_is_allocated_above(top
, base
, data
->sector_num
,
2885 data
->nb_sectors
, data
->pnum
);
2890 * Synchronous wrapper around bdrv_co_is_allocated_above().
2892 * See bdrv_co_is_allocated_above() for details.
2894 int bdrv_is_allocated_above(BlockDriverState
*top
, BlockDriverState
*base
,
2895 int64_t sector_num
, int nb_sectors
, int *pnum
)
2898 BdrvCoIsAllocatedData data
= {
2901 .sector_num
= sector_num
,
2902 .nb_sectors
= nb_sectors
,
2907 co
= qemu_coroutine_create(bdrv_is_allocated_above_co_entry
);
2908 qemu_coroutine_enter(co
, &data
);
2909 while (!data
.done
) {
2915 BlockInfo
*bdrv_query_info(BlockDriverState
*bs
)
2917 BlockInfo
*info
= g_malloc0(sizeof(*info
));
2918 info
->device
= g_strdup(bs
->device_name
);
2919 info
->type
= g_strdup("unknown");
2920 info
->locked
= bdrv_dev_is_medium_locked(bs
);
2921 info
->removable
= bdrv_dev_has_removable_media(bs
);
2923 if (bdrv_dev_has_removable_media(bs
)) {
2924 info
->has_tray_open
= true;
2925 info
->tray_open
= bdrv_dev_is_tray_open(bs
);
2928 if (bdrv_iostatus_is_enabled(bs
)) {
2929 info
->has_io_status
= true;
2930 info
->io_status
= bs
->iostatus
;
2933 if (bs
->dirty_bitmap
) {
2934 info
->has_dirty
= true;
2935 info
->dirty
= g_malloc0(sizeof(*info
->dirty
));
2936 info
->dirty
->count
= bdrv_get_dirty_count(bs
) * BDRV_SECTOR_SIZE
;
2937 info
->dirty
->granularity
=
2938 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bs
->dirty_bitmap
));
2942 info
->has_inserted
= true;
2943 info
->inserted
= g_malloc0(sizeof(*info
->inserted
));
2944 info
->inserted
->file
= g_strdup(bs
->filename
);
2945 info
->inserted
->ro
= bs
->read_only
;
2946 info
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2947 info
->inserted
->encrypted
= bs
->encrypted
;
2948 info
->inserted
->encryption_key_missing
= bdrv_key_required(bs
);
2950 if (bs
->backing_file
[0]) {
2951 info
->inserted
->has_backing_file
= true;
2952 info
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2955 info
->inserted
->backing_file_depth
= bdrv_get_backing_file_depth(bs
);
2957 if (bs
->io_limits_enabled
) {
2958 info
->inserted
->bps
=
2959 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2960 info
->inserted
->bps_rd
=
2961 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2962 info
->inserted
->bps_wr
=
2963 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2964 info
->inserted
->iops
=
2965 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2966 info
->inserted
->iops_rd
=
2967 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2968 info
->inserted
->iops_wr
=
2969 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2975 BlockInfoList
*qmp_query_block(Error
**errp
)
2977 BlockInfoList
*head
= NULL
, **p_next
= &head
;
2978 BlockDriverState
*bs
;
2980 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2981 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2982 info
->value
= bdrv_query_info(bs
);
2985 p_next
= &info
->next
;
2991 BlockStats
*bdrv_query_stats(const BlockDriverState
*bs
)
2995 s
= g_malloc0(sizeof(*s
));
2997 if (bs
->device_name
[0]) {
2998 s
->has_device
= true;
2999 s
->device
= g_strdup(bs
->device_name
);
3002 s
->stats
= g_malloc0(sizeof(*s
->stats
));
3003 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
3004 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
3005 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
3006 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
3007 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
3008 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
3009 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
3010 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
3011 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
3014 s
->has_parent
= true;
3015 s
->parent
= bdrv_query_stats(bs
->file
);
3021 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
3023 BlockStatsList
*head
= NULL
, **p_next
= &head
;
3024 BlockDriverState
*bs
;
3026 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3027 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
3028 info
->value
= bdrv_query_stats(bs
);
3031 p_next
= &info
->next
;
3037 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3039 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3040 return bs
->backing_file
;
3041 else if (bs
->encrypted
)
3042 return bs
->filename
;
3047 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3048 char *filename
, int filename_size
)
3050 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3053 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
3054 const uint8_t *buf
, int nb_sectors
)
3056 BlockDriver
*drv
= bs
->drv
;
3059 if (!drv
->bdrv_write_compressed
)
3061 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
3064 assert(!bs
->dirty_bitmap
);
3066 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
3069 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3071 BlockDriver
*drv
= bs
->drv
;
3074 if (!drv
->bdrv_get_info
)
3076 memset(bdi
, 0, sizeof(*bdi
));
3077 return drv
->bdrv_get_info(bs
, bdi
);
3080 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
3081 int64_t pos
, int size
)
3083 BlockDriver
*drv
= bs
->drv
;
3086 if (drv
->bdrv_save_vmstate
)
3087 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
3089 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
3093 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
3094 int64_t pos
, int size
)
3096 BlockDriver
*drv
= bs
->drv
;
3099 if (drv
->bdrv_load_vmstate
)
3100 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
3102 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
3106 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
3108 BlockDriver
*drv
= bs
->drv
;
3110 if (!drv
|| !drv
->bdrv_debug_event
) {
3114 drv
->bdrv_debug_event(bs
, event
);
3117 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3120 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3124 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3125 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3131 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3133 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_resume
) {
3137 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3138 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3144 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3146 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3150 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3151 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3157 /**************************************************************/
3158 /* handling of snapshots */
3160 int bdrv_can_snapshot(BlockDriverState
*bs
)
3162 BlockDriver
*drv
= bs
->drv
;
3163 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3167 if (!drv
->bdrv_snapshot_create
) {
3168 if (bs
->file
!= NULL
) {
3169 return bdrv_can_snapshot(bs
->file
);
3177 int bdrv_is_snapshot(BlockDriverState
*bs
)
3179 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3182 BlockDriverState
*bdrv_snapshots(void)
3184 BlockDriverState
*bs
;
3187 return bs_snapshots
;
3191 while ((bs
= bdrv_next(bs
))) {
3192 if (bdrv_can_snapshot(bs
)) {
3200 int bdrv_snapshot_create(BlockDriverState
*bs
,
3201 QEMUSnapshotInfo
*sn_info
)
3203 BlockDriver
*drv
= bs
->drv
;
3206 if (drv
->bdrv_snapshot_create
)
3207 return drv
->bdrv_snapshot_create(bs
, sn_info
);
3209 return bdrv_snapshot_create(bs
->file
, sn_info
);
3213 int bdrv_snapshot_goto(BlockDriverState
*bs
,
3214 const char *snapshot_id
)
3216 BlockDriver
*drv
= bs
->drv
;
3221 if (drv
->bdrv_snapshot_goto
)
3222 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
3225 drv
->bdrv_close(bs
);
3226 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
3227 open_ret
= drv
->bdrv_open(bs
, NULL
, bs
->open_flags
);
3229 bdrv_delete(bs
->file
);
3239 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
3241 BlockDriver
*drv
= bs
->drv
;
3244 if (drv
->bdrv_snapshot_delete
)
3245 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
3247 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
3251 int bdrv_snapshot_list(BlockDriverState
*bs
,
3252 QEMUSnapshotInfo
**psn_info
)
3254 BlockDriver
*drv
= bs
->drv
;
3257 if (drv
->bdrv_snapshot_list
)
3258 return drv
->bdrv_snapshot_list(bs
, psn_info
);
3260 return bdrv_snapshot_list(bs
->file
, psn_info
);
3264 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
3265 const char *snapshot_name
)
3267 BlockDriver
*drv
= bs
->drv
;
3271 if (!bs
->read_only
) {
3274 if (drv
->bdrv_snapshot_load_tmp
) {
3275 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
3280 /* backing_file can either be relative, or absolute, or a protocol. If it is
3281 * relative, it must be relative to the chain. So, passing in bs->filename
3282 * from a BDS as backing_file should not be done, as that may be relative to
3283 * the CWD rather than the chain. */
3284 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3285 const char *backing_file
)
3287 char *filename_full
= NULL
;
3288 char *backing_file_full
= NULL
;
3289 char *filename_tmp
= NULL
;
3290 int is_protocol
= 0;
3291 BlockDriverState
*curr_bs
= NULL
;
3292 BlockDriverState
*retval
= NULL
;
3294 if (!bs
|| !bs
->drv
|| !backing_file
) {
3298 filename_full
= g_malloc(PATH_MAX
);
3299 backing_file_full
= g_malloc(PATH_MAX
);
3300 filename_tmp
= g_malloc(PATH_MAX
);
3302 is_protocol
= path_has_protocol(backing_file
);
3304 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3306 /* If either of the filename paths is actually a protocol, then
3307 * compare unmodified paths; otherwise make paths relative */
3308 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3309 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3310 retval
= curr_bs
->backing_hd
;
3314 /* If not an absolute filename path, make it relative to the current
3315 * image's filename path */
3316 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3319 /* We are going to compare absolute pathnames */
3320 if (!realpath(filename_tmp
, filename_full
)) {
3324 /* We need to make sure the backing filename we are comparing against
3325 * is relative to the current image filename (or absolute) */
3326 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3327 curr_bs
->backing_file
);
3329 if (!realpath(filename_tmp
, backing_file_full
)) {
3333 if (strcmp(backing_file_full
, filename_full
) == 0) {
3334 retval
= curr_bs
->backing_hd
;
3340 g_free(filename_full
);
3341 g_free(backing_file_full
);
3342 g_free(filename_tmp
);
3346 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3352 if (!bs
->backing_hd
) {
3356 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3359 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
3361 BlockDriverState
*curr_bs
= NULL
;
3369 while (curr_bs
->backing_hd
) {
3370 curr_bs
= curr_bs
->backing_hd
;
3375 #define NB_SUFFIXES 4
3377 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
3379 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
3384 snprintf(buf
, buf_size
, "%" PRId64
, size
);
3387 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
3388 if (size
< (10 * base
)) {
3389 snprintf(buf
, buf_size
, "%0.1f%c",
3390 (double)size
/ base
,
3393 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
3394 snprintf(buf
, buf_size
, "%" PRId64
"%c",
3395 ((size
+ (base
>> 1)) / base
),
3405 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
3407 char buf1
[128], date_buf
[128], clock_buf
[128];
3413 snprintf(buf
, buf_size
,
3414 "%-10s%-20s%7s%20s%15s",
3415 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3418 localtime_r(&ti
, &tm
);
3419 strftime(date_buf
, sizeof(date_buf
),
3420 "%Y-%m-%d %H:%M:%S", &tm
);
3421 secs
= sn
->vm_clock_nsec
/ 1000000000;
3422 snprintf(clock_buf
, sizeof(clock_buf
),
3423 "%02d:%02d:%02d.%03d",
3425 (int)((secs
/ 60) % 60),
3427 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
3428 snprintf(buf
, buf_size
,
3429 "%-10s%-20s%7s%20s%15s",
3430 sn
->id_str
, sn
->name
,
3431 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
3438 /**************************************************************/
3441 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3442 QEMUIOVector
*qiov
, int nb_sectors
,
3443 BlockDriverCompletionFunc
*cb
, void *opaque
)
3445 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3447 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3451 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3452 QEMUIOVector
*qiov
, int nb_sectors
,
3453 BlockDriverCompletionFunc
*cb
, void *opaque
)
3455 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3457 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3462 typedef struct MultiwriteCB
{
3467 BlockDriverCompletionFunc
*cb
;
3469 QEMUIOVector
*free_qiov
;
3473 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3477 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3478 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3479 if (mcb
->callbacks
[i
].free_qiov
) {
3480 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3482 g_free(mcb
->callbacks
[i
].free_qiov
);
3486 static void multiwrite_cb(void *opaque
, int ret
)
3488 MultiwriteCB
*mcb
= opaque
;
3490 trace_multiwrite_cb(mcb
, ret
);
3492 if (ret
< 0 && !mcb
->error
) {
3496 mcb
->num_requests
--;
3497 if (mcb
->num_requests
== 0) {
3498 multiwrite_user_cb(mcb
);
3503 static int multiwrite_req_compare(const void *a
, const void *b
)
3505 const BlockRequest
*req1
= a
, *req2
= b
;
3508 * Note that we can't simply subtract req2->sector from req1->sector
3509 * here as that could overflow the return value.
3511 if (req1
->sector
> req2
->sector
) {
3513 } else if (req1
->sector
< req2
->sector
) {
3521 * Takes a bunch of requests and tries to merge them. Returns the number of
3522 * requests that remain after merging.
3524 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3525 int num_reqs
, MultiwriteCB
*mcb
)
3529 // Sort requests by start sector
3530 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3532 // Check if adjacent requests touch the same clusters. If so, combine them,
3533 // filling up gaps with zero sectors.
3535 for (i
= 1; i
< num_reqs
; i
++) {
3537 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3539 // Handle exactly sequential writes and overlapping writes.
3540 if (reqs
[i
].sector
<= oldreq_last
) {
3544 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3550 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3551 qemu_iovec_init(qiov
,
3552 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3554 // Add the first request to the merged one. If the requests are
3555 // overlapping, drop the last sectors of the first request.
3556 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3557 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
3559 // We should need to add any zeros between the two requests
3560 assert (reqs
[i
].sector
<= oldreq_last
);
3562 // Add the second request
3563 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
3565 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3566 reqs
[outidx
].qiov
= qiov
;
3568 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3571 reqs
[outidx
].sector
= reqs
[i
].sector
;
3572 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3573 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3581 * Submit multiple AIO write requests at once.
3583 * On success, the function returns 0 and all requests in the reqs array have
3584 * been submitted. In error case this function returns -1, and any of the
3585 * requests may or may not be submitted yet. In particular, this means that the
3586 * callback will be called for some of the requests, for others it won't. The
3587 * caller must check the error field of the BlockRequest to wait for the right
3588 * callbacks (if error != 0, no callback will be called).
3590 * The implementation may modify the contents of the reqs array, e.g. to merge
3591 * requests. However, the fields opaque and error are left unmodified as they
3592 * are used to signal failure for a single request to the caller.
3594 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3599 /* don't submit writes if we don't have a medium */
3600 if (bs
->drv
== NULL
) {
3601 for (i
= 0; i
< num_reqs
; i
++) {
3602 reqs
[i
].error
= -ENOMEDIUM
;
3607 if (num_reqs
== 0) {
3611 // Create MultiwriteCB structure
3612 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3613 mcb
->num_requests
= 0;
3614 mcb
->num_callbacks
= num_reqs
;
3616 for (i
= 0; i
< num_reqs
; i
++) {
3617 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3618 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3621 // Check for mergable requests
3622 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3624 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3626 /* Run the aio requests. */
3627 mcb
->num_requests
= num_reqs
;
3628 for (i
= 0; i
< num_reqs
; i
++) {
3629 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3630 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3636 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3638 acb
->aiocb_info
->cancel(acb
);
3641 /* block I/O throttling */
3642 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3643 bool is_write
, double elapsed_time
, uint64_t *wait
)
3645 uint64_t bps_limit
= 0;
3646 double bytes_limit
, bytes_base
, bytes_res
;
3647 double slice_time
, wait_time
;
3649 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3650 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3651 } else if (bs
->io_limits
.bps
[is_write
]) {
3652 bps_limit
= bs
->io_limits
.bps
[is_write
];
3661 slice_time
= bs
->slice_end
- bs
->slice_start
;
3662 slice_time
/= (NANOSECONDS_PER_SECOND
);
3663 bytes_limit
= bps_limit
* slice_time
;
3664 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3665 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3666 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3669 /* bytes_base: the bytes of data which have been read/written; and
3670 * it is obtained from the history statistic info.
3671 * bytes_res: the remaining bytes of data which need to be read/written.
3672 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3673 * the total time for completing reading/writting all data.
3675 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3677 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3685 /* Calc approx time to dispatch */
3686 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3688 /* When the I/O rate at runtime exceeds the limits,
3689 * bs->slice_end need to be extended in order that the current statistic
3690 * info can be kept until the timer fire, so it is increased and tuned
3691 * based on the result of experiment.
3693 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3694 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3696 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3702 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3703 double elapsed_time
, uint64_t *wait
)
3705 uint64_t iops_limit
= 0;
3706 double ios_limit
, ios_base
;
3707 double slice_time
, wait_time
;
3709 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3710 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3711 } else if (bs
->io_limits
.iops
[is_write
]) {
3712 iops_limit
= bs
->io_limits
.iops
[is_write
];
3721 slice_time
= bs
->slice_end
- bs
->slice_start
;
3722 slice_time
/= (NANOSECONDS_PER_SECOND
);
3723 ios_limit
= iops_limit
* slice_time
;
3724 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3725 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3726 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3729 if (ios_base
+ 1 <= ios_limit
) {
3737 /* Calc approx time to dispatch */
3738 wait_time
= (ios_base
+ 1) / iops_limit
;
3739 if (wait_time
> elapsed_time
) {
3740 wait_time
= wait_time
- elapsed_time
;
3745 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3746 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3748 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3754 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3755 bool is_write
, int64_t *wait
)
3757 int64_t now
, max_wait
;
3758 uint64_t bps_wait
= 0, iops_wait
= 0;
3759 double elapsed_time
;
3760 int bps_ret
, iops_ret
;
3762 now
= qemu_get_clock_ns(vm_clock
);
3763 if ((bs
->slice_start
< now
)
3764 && (bs
->slice_end
> now
)) {
3765 bs
->slice_end
= now
+ bs
->slice_time
;
3767 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3768 bs
->slice_start
= now
;
3769 bs
->slice_end
= now
+ bs
->slice_time
;
3771 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3772 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3774 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3775 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3778 elapsed_time
= now
- bs
->slice_start
;
3779 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3781 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3782 is_write
, elapsed_time
, &bps_wait
);
3783 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3784 elapsed_time
, &iops_wait
);
3785 if (bps_ret
|| iops_ret
) {
3786 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3791 now
= qemu_get_clock_ns(vm_clock
);
3792 if (bs
->slice_end
< now
+ max_wait
) {
3793 bs
->slice_end
= now
+ max_wait
;
3806 /**************************************************************/
3807 /* async block device emulation */
3809 typedef struct BlockDriverAIOCBSync
{
3810 BlockDriverAIOCB common
;
3813 /* vector translation state */
3817 } BlockDriverAIOCBSync
;
3819 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3821 BlockDriverAIOCBSync
*acb
=
3822 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3823 qemu_bh_delete(acb
->bh
);
3825 qemu_aio_release(acb
);
3828 static const AIOCBInfo bdrv_em_aiocb_info
= {
3829 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3830 .cancel
= bdrv_aio_cancel_em
,
3833 static void bdrv_aio_bh_cb(void *opaque
)
3835 BlockDriverAIOCBSync
*acb
= opaque
;
3838 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3839 qemu_vfree(acb
->bounce
);
3840 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3841 qemu_bh_delete(acb
->bh
);
3843 qemu_aio_release(acb
);
3846 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3850 BlockDriverCompletionFunc
*cb
,
3855 BlockDriverAIOCBSync
*acb
;
3857 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
3858 acb
->is_write
= is_write
;
3860 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3861 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3864 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3865 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3867 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3870 qemu_bh_schedule(acb
->bh
);
3872 return &acb
->common
;
3875 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3876 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3877 BlockDriverCompletionFunc
*cb
, void *opaque
)
3879 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3882 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3883 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3884 BlockDriverCompletionFunc
*cb
, void *opaque
)
3886 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3890 typedef struct BlockDriverAIOCBCoroutine
{
3891 BlockDriverAIOCB common
;
3896 } BlockDriverAIOCBCoroutine
;
3898 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3900 BlockDriverAIOCBCoroutine
*acb
=
3901 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
3910 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
3911 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3912 .cancel
= bdrv_aio_co_cancel_em
,
3915 static void bdrv_co_em_bh(void *opaque
)
3917 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3919 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3925 qemu_bh_delete(acb
->bh
);
3926 qemu_aio_release(acb
);
3929 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3930 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3932 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3933 BlockDriverState
*bs
= acb
->common
.bs
;
3935 if (!acb
->is_write
) {
3936 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3937 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3939 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3940 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3943 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3944 qemu_bh_schedule(acb
->bh
);
3947 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3951 BlockDriverCompletionFunc
*cb
,
3956 BlockDriverAIOCBCoroutine
*acb
;
3958 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3959 acb
->req
.sector
= sector_num
;
3960 acb
->req
.nb_sectors
= nb_sectors
;
3961 acb
->req
.qiov
= qiov
;
3962 acb
->is_write
= is_write
;
3965 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3966 qemu_coroutine_enter(co
, acb
);
3968 return &acb
->common
;
3971 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3973 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3974 BlockDriverState
*bs
= acb
->common
.bs
;
3976 acb
->req
.error
= bdrv_co_flush(bs
);
3977 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3978 qemu_bh_schedule(acb
->bh
);
3981 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3982 BlockDriverCompletionFunc
*cb
, void *opaque
)
3984 trace_bdrv_aio_flush(bs
, opaque
);
3987 BlockDriverAIOCBCoroutine
*acb
;
3989 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3992 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3993 qemu_coroutine_enter(co
, acb
);
3995 return &acb
->common
;
3998 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4000 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4001 BlockDriverState
*bs
= acb
->common
.bs
;
4003 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4004 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4005 qemu_bh_schedule(acb
->bh
);
4008 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4009 int64_t sector_num
, int nb_sectors
,
4010 BlockDriverCompletionFunc
*cb
, void *opaque
)
4013 BlockDriverAIOCBCoroutine
*acb
;
4015 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4017 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4018 acb
->req
.sector
= sector_num
;
4019 acb
->req
.nb_sectors
= nb_sectors
;
4021 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4022 qemu_coroutine_enter(co
, acb
);
4024 return &acb
->common
;
4027 void bdrv_init(void)
4029 module_call_init(MODULE_INIT_BLOCK
);
4032 void bdrv_init_with_whitelist(void)
4034 use_bdrv_whitelist
= 1;
4038 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4039 BlockDriverCompletionFunc
*cb
, void *opaque
)
4041 BlockDriverAIOCB
*acb
;
4043 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4044 acb
->aiocb_info
= aiocb_info
;
4047 acb
->opaque
= opaque
;
4051 void qemu_aio_release(void *p
)
4053 BlockDriverAIOCB
*acb
= p
;
4054 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4057 /**************************************************************/
4058 /* Coroutine block device emulation */
4060 typedef struct CoroutineIOCompletion
{
4061 Coroutine
*coroutine
;
4063 } CoroutineIOCompletion
;
4065 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4067 CoroutineIOCompletion
*co
= opaque
;
4070 qemu_coroutine_enter(co
->coroutine
, NULL
);
4073 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4074 int nb_sectors
, QEMUIOVector
*iov
,
4077 CoroutineIOCompletion co
= {
4078 .coroutine
= qemu_coroutine_self(),
4080 BlockDriverAIOCB
*acb
;
4083 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4084 bdrv_co_io_em_complete
, &co
);
4086 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4087 bdrv_co_io_em_complete
, &co
);
4090 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4094 qemu_coroutine_yield();
4099 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4100 int64_t sector_num
, int nb_sectors
,
4103 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4106 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4107 int64_t sector_num
, int nb_sectors
,
4110 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4113 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4115 RwCo
*rwco
= opaque
;
4117 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4120 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4124 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4128 /* Write back cached data to the OS even with cache=unsafe */
4129 if (bs
->drv
->bdrv_co_flush_to_os
) {
4130 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4136 /* But don't actually force it to the disk with cache=unsafe */
4137 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4141 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4142 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4143 } else if (bs
->drv
->bdrv_aio_flush
) {
4144 BlockDriverAIOCB
*acb
;
4145 CoroutineIOCompletion co
= {
4146 .coroutine
= qemu_coroutine_self(),
4149 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4153 qemu_coroutine_yield();
4158 * Some block drivers always operate in either writethrough or unsafe
4159 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4160 * know how the server works (because the behaviour is hardcoded or
4161 * depends on server-side configuration), so we can't ensure that
4162 * everything is safe on disk. Returning an error doesn't work because
4163 * that would break guests even if the server operates in writethrough
4166 * Let's hope the user knows what he's doing.
4174 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4175 * in the case of cache=unsafe, so there are no useless flushes.
4178 return bdrv_co_flush(bs
->file
);
4181 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4183 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4184 bs
->drv
->bdrv_invalidate_cache(bs
);
4188 void bdrv_invalidate_cache_all(void)
4190 BlockDriverState
*bs
;
4192 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4193 bdrv_invalidate_cache(bs
);
4197 void bdrv_clear_incoming_migration_all(void)
4199 BlockDriverState
*bs
;
4201 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4202 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4206 int bdrv_flush(BlockDriverState
*bs
)
4214 if (qemu_in_coroutine()) {
4215 /* Fast-path if already in coroutine context */
4216 bdrv_flush_co_entry(&rwco
);
4218 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4219 qemu_coroutine_enter(co
, &rwco
);
4220 while (rwco
.ret
== NOT_DONE
) {
4228 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4230 RwCo
*rwco
= opaque
;
4232 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4235 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4240 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4242 } else if (bs
->read_only
) {
4246 if (bs
->dirty_bitmap
) {
4247 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
4250 /* Do nothing if disabled. */
4251 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
4255 if (bs
->drv
->bdrv_co_discard
) {
4256 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
4257 } else if (bs
->drv
->bdrv_aio_discard
) {
4258 BlockDriverAIOCB
*acb
;
4259 CoroutineIOCompletion co
= {
4260 .coroutine
= qemu_coroutine_self(),
4263 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4264 bdrv_co_io_em_complete
, &co
);
4268 qemu_coroutine_yield();
4276 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4281 .sector_num
= sector_num
,
4282 .nb_sectors
= nb_sectors
,
4286 if (qemu_in_coroutine()) {
4287 /* Fast-path if already in coroutine context */
4288 bdrv_discard_co_entry(&rwco
);
4290 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4291 qemu_coroutine_enter(co
, &rwco
);
4292 while (rwco
.ret
== NOT_DONE
) {
4300 /**************************************************************/
4301 /* removable device support */
4304 * Return TRUE if the media is present
4306 int bdrv_is_inserted(BlockDriverState
*bs
)
4308 BlockDriver
*drv
= bs
->drv
;
4312 if (!drv
->bdrv_is_inserted
)
4314 return drv
->bdrv_is_inserted(bs
);
4318 * Return whether the media changed since the last call to this
4319 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4321 int bdrv_media_changed(BlockDriverState
*bs
)
4323 BlockDriver
*drv
= bs
->drv
;
4325 if (drv
&& drv
->bdrv_media_changed
) {
4326 return drv
->bdrv_media_changed(bs
);
4332 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4334 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4336 BlockDriver
*drv
= bs
->drv
;
4338 if (drv
&& drv
->bdrv_eject
) {
4339 drv
->bdrv_eject(bs
, eject_flag
);
4342 if (bs
->device_name
[0] != '\0') {
4343 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4348 * Lock or unlock the media (if it is locked, the user won't be able
4349 * to eject it manually).
4351 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4353 BlockDriver
*drv
= bs
->drv
;
4355 trace_bdrv_lock_medium(bs
, locked
);
4357 if (drv
&& drv
->bdrv_lock_medium
) {
4358 drv
->bdrv_lock_medium(bs
, locked
);
4362 /* needed for generic scsi interface */
4364 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
4366 BlockDriver
*drv
= bs
->drv
;
4368 if (drv
&& drv
->bdrv_ioctl
)
4369 return drv
->bdrv_ioctl(bs
, req
, buf
);
4373 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
4374 unsigned long int req
, void *buf
,
4375 BlockDriverCompletionFunc
*cb
, void *opaque
)
4377 BlockDriver
*drv
= bs
->drv
;
4379 if (drv
&& drv
->bdrv_aio_ioctl
)
4380 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
4384 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
4386 bs
->buffer_alignment
= align
;
4389 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
4391 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
4395 * Check if all memory in this vector is sector aligned.
4397 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
4401 for (i
= 0; i
< qiov
->niov
; i
++) {
4402 if ((uintptr_t) qiov
->iov
[i
].iov_base
% bs
->buffer_alignment
) {
4410 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int granularity
)
4412 int64_t bitmap_size
;
4414 assert((granularity
& (granularity
- 1)) == 0);
4417 granularity
>>= BDRV_SECTOR_BITS
;
4418 assert(!bs
->dirty_bitmap
);
4419 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
);
4420 bs
->dirty_bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
4422 if (bs
->dirty_bitmap
) {
4423 hbitmap_free(bs
->dirty_bitmap
);
4424 bs
->dirty_bitmap
= NULL
;
4429 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4431 if (bs
->dirty_bitmap
) {
4432 return hbitmap_get(bs
->dirty_bitmap
, sector
);
4438 void bdrv_dirty_iter_init(BlockDriverState
*bs
, HBitmapIter
*hbi
)
4440 hbitmap_iter_init(hbi
, bs
->dirty_bitmap
, 0);
4443 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4446 hbitmap_set(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4449 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4452 hbitmap_reset(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4455 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4457 if (bs
->dirty_bitmap
) {
4458 return hbitmap_count(bs
->dirty_bitmap
);
4464 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4466 assert(bs
->in_use
!= in_use
);
4467 bs
->in_use
= in_use
;
4470 int bdrv_in_use(BlockDriverState
*bs
)
4475 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4477 bs
->iostatus_enabled
= true;
4478 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4481 /* The I/O status is only enabled if the drive explicitly
4482 * enables it _and_ the VM is configured to stop on errors */
4483 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4485 return (bs
->iostatus_enabled
&&
4486 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
4487 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
4488 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
4491 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4493 bs
->iostatus_enabled
= false;
4496 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4498 if (bdrv_iostatus_is_enabled(bs
)) {
4499 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4501 block_job_iostatus_reset(bs
->job
);
4506 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4508 assert(bdrv_iostatus_is_enabled(bs
));
4509 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4510 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4511 BLOCK_DEVICE_IO_STATUS_FAILED
;
4516 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4517 enum BlockAcctType type
)
4519 assert(type
< BDRV_MAX_IOTYPE
);
4521 cookie
->bytes
= bytes
;
4522 cookie
->start_time_ns
= get_clock();
4523 cookie
->type
= type
;
4527 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4529 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4531 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4532 bs
->nr_ops
[cookie
->type
]++;
4533 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4536 void bdrv_img_create(const char *filename
, const char *fmt
,
4537 const char *base_filename
, const char *base_fmt
,
4538 char *options
, uint64_t img_size
, int flags
,
4539 Error
**errp
, bool quiet
)
4541 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4542 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4543 BlockDriverState
*bs
= NULL
;
4544 BlockDriver
*drv
, *proto_drv
;
4545 BlockDriver
*backing_drv
= NULL
;
4548 /* Find driver and parse its options */
4549 drv
= bdrv_find_format(fmt
);
4551 error_setg(errp
, "Unknown file format '%s'", fmt
);
4555 proto_drv
= bdrv_find_protocol(filename
);
4557 error_setg(errp
, "Unknown protocol '%s'", filename
);
4561 create_options
= append_option_parameters(create_options
,
4562 drv
->create_options
);
4563 create_options
= append_option_parameters(create_options
,
4564 proto_drv
->create_options
);
4566 /* Create parameter list with default values */
4567 param
= parse_option_parameters("", create_options
, param
);
4569 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4571 /* Parse -o options */
4573 param
= parse_option_parameters(options
, create_options
, param
);
4574 if (param
== NULL
) {
4575 error_setg(errp
, "Invalid options for file format '%s'.", fmt
);
4580 if (base_filename
) {
4581 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4583 error_setg(errp
, "Backing file not supported for file format '%s'",
4590 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4591 error_setg(errp
, "Backing file format not supported for file "
4592 "format '%s'", fmt
);
4597 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4598 if (backing_file
&& backing_file
->value
.s
) {
4599 if (!strcmp(filename
, backing_file
->value
.s
)) {
4600 error_setg(errp
, "Error: Trying to create an image with the "
4601 "same filename as the backing file");
4606 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4607 if (backing_fmt
&& backing_fmt
->value
.s
) {
4608 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4610 error_setg(errp
, "Unknown backing file format '%s'",
4611 backing_fmt
->value
.s
);
4616 // The size for the image must always be specified, with one exception:
4617 // If we are using a backing file, we can obtain the size from there
4618 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4619 if (size
&& size
->value
.n
== -1) {
4620 if (backing_file
&& backing_file
->value
.s
) {
4625 /* backing files always opened read-only */
4627 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4631 ret
= bdrv_open(bs
, backing_file
->value
.s
, NULL
, back_flags
,
4634 error_setg_errno(errp
, -ret
, "Could not open '%s'",
4635 backing_file
->value
.s
);
4638 bdrv_get_geometry(bs
, &size
);
4641 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4642 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4644 error_setg(errp
, "Image creation needs a size parameter");
4650 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4651 print_option_parameters(param
);
4654 ret
= bdrv_create(drv
, filename
, param
);
4656 if (ret
== -ENOTSUP
) {
4657 error_setg(errp
,"Formatting or formatting option not supported for "
4658 "file format '%s'", fmt
);
4659 } else if (ret
== -EFBIG
) {
4660 error_setg(errp
, "The image size is too large for file format '%s'",
4663 error_setg(errp
, "%s: error while creating %s: %s", filename
, fmt
,
4669 free_option_parameters(create_options
);
4670 free_option_parameters(param
);
4677 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
4679 /* Currently BlockDriverState always uses the main loop AioContext */
4680 return qemu_get_aio_context();