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"
28 #include "block_int.h"
31 #include "qemu-coroutine.h"
32 #include "qmp-commands.h"
33 #include "qemu-timer.h"
36 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/queue.h>
49 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
52 BDRV_REQ_COPY_ON_READ
= 0x1,
53 BDRV_REQ_ZERO_WRITE
= 0x2,
56 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
57 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
58 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
59 BlockDriverCompletionFunc
*cb
, void *opaque
);
60 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
61 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
62 BlockDriverCompletionFunc
*cb
, void *opaque
);
63 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
64 int64_t sector_num
, int nb_sectors
,
66 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
67 int64_t sector_num
, int nb_sectors
,
69 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
70 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
71 BdrvRequestFlags flags
);
72 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
73 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
74 BdrvRequestFlags flags
);
75 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
79 BlockDriverCompletionFunc
*cb
,
82 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
83 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
84 int64_t sector_num
, int nb_sectors
);
86 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
87 bool is_write
, double elapsed_time
, uint64_t *wait
);
88 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
89 double elapsed_time
, uint64_t *wait
);
90 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
91 bool is_write
, int64_t *wait
);
93 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
94 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
96 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
97 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
99 /* The device to use for VM snapshots */
100 static BlockDriverState
*bs_snapshots
;
102 /* If non-zero, use only whitelisted block drivers */
103 static int use_bdrv_whitelist
;
106 static int is_windows_drive_prefix(const char *filename
)
108 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
109 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
113 int is_windows_drive(const char *filename
)
115 if (is_windows_drive_prefix(filename
) &&
118 if (strstart(filename
, "\\\\.\\", NULL
) ||
119 strstart(filename
, "//./", NULL
))
125 /* throttling disk I/O limits */
126 void bdrv_io_limits_disable(BlockDriverState
*bs
)
128 bs
->io_limits_enabled
= false;
130 while (qemu_co_queue_next(&bs
->throttled_reqs
));
132 if (bs
->block_timer
) {
133 qemu_del_timer(bs
->block_timer
);
134 qemu_free_timer(bs
->block_timer
);
135 bs
->block_timer
= NULL
;
141 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
144 static void bdrv_block_timer(void *opaque
)
146 BlockDriverState
*bs
= opaque
;
148 qemu_co_queue_next(&bs
->throttled_reqs
);
151 void bdrv_io_limits_enable(BlockDriverState
*bs
)
153 qemu_co_queue_init(&bs
->throttled_reqs
);
154 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
155 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
156 bs
->slice_start
= qemu_get_clock_ns(vm_clock
);
157 bs
->slice_end
= bs
->slice_start
+ bs
->slice_time
;
158 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
159 bs
->io_limits_enabled
= true;
162 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
164 BlockIOLimit
*io_limits
= &bs
->io_limits
;
165 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
166 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
167 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
168 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
169 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
170 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
173 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
174 bool is_write
, int nb_sectors
)
176 int64_t wait_time
= -1;
178 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
179 qemu_co_queue_wait(&bs
->throttled_reqs
);
182 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
183 * throttled requests will not be dequeued until the current request is
184 * allowed to be serviced. So if the current request still exceeds the
185 * limits, it will be inserted to the head. All requests followed it will
186 * be still in throttled_reqs queue.
189 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
190 qemu_mod_timer(bs
->block_timer
,
191 wait_time
+ qemu_get_clock_ns(vm_clock
));
192 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
195 qemu_co_queue_next(&bs
->throttled_reqs
);
198 /* check if the path starts with "<protocol>:" */
199 static int path_has_protocol(const char *path
)
204 if (is_windows_drive(path
) ||
205 is_windows_drive_prefix(path
)) {
208 p
= path
+ strcspn(path
, ":/\\");
210 p
= path
+ strcspn(path
, ":/");
216 int path_is_absolute(const char *path
)
219 /* specific case for names like: "\\.\d:" */
220 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
223 return (*path
== '/' || *path
== '\\');
225 return (*path
== '/');
229 /* if filename is absolute, just copy it to dest. Otherwise, build a
230 path to it by considering it is relative to base_path. URL are
232 void path_combine(char *dest
, int dest_size
,
233 const char *base_path
,
234 const char *filename
)
241 if (path_is_absolute(filename
)) {
242 pstrcpy(dest
, dest_size
, filename
);
244 p
= strchr(base_path
, ':');
249 p1
= strrchr(base_path
, '/');
253 p2
= strrchr(base_path
, '\\');
265 if (len
> dest_size
- 1)
267 memcpy(dest
, base_path
, len
);
269 pstrcat(dest
, dest_size
, filename
);
273 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
275 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
276 pstrcpy(dest
, sz
, bs
->backing_file
);
278 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
282 void bdrv_register(BlockDriver
*bdrv
)
284 /* Block drivers without coroutine functions need emulation */
285 if (!bdrv
->bdrv_co_readv
) {
286 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
287 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
289 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
290 * the block driver lacks aio we need to emulate that too.
292 if (!bdrv
->bdrv_aio_readv
) {
293 /* add AIO emulation layer */
294 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
295 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
299 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
302 /* create a new block device (by default it is empty) */
303 BlockDriverState
*bdrv_new(const char *device_name
)
305 BlockDriverState
*bs
;
307 bs
= g_malloc0(sizeof(BlockDriverState
));
308 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
309 if (device_name
[0] != '\0') {
310 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
312 bdrv_iostatus_disable(bs
);
316 BlockDriver
*bdrv_find_format(const char *format_name
)
319 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
320 if (!strcmp(drv1
->format_name
, format_name
)) {
327 static int bdrv_is_whitelisted(BlockDriver
*drv
)
329 static const char *whitelist
[] = {
330 CONFIG_BDRV_WHITELIST
335 return 1; /* no whitelist, anything goes */
337 for (p
= whitelist
; *p
; p
++) {
338 if (!strcmp(drv
->format_name
, *p
)) {
345 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
)
347 BlockDriver
*drv
= bdrv_find_format(format_name
);
348 return drv
&& bdrv_is_whitelisted(drv
) ? drv
: NULL
;
351 typedef struct CreateCo
{
354 QEMUOptionParameter
*options
;
358 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
360 CreateCo
*cco
= opaque
;
363 cco
->ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
);
366 int bdrv_create(BlockDriver
*drv
, const char* filename
,
367 QEMUOptionParameter
*options
)
374 .filename
= g_strdup(filename
),
379 if (!drv
->bdrv_create
) {
383 if (qemu_in_coroutine()) {
384 /* Fast-path if already in coroutine context */
385 bdrv_create_co_entry(&cco
);
387 co
= qemu_coroutine_create(bdrv_create_co_entry
);
388 qemu_coroutine_enter(co
, &cco
);
389 while (cco
.ret
== NOT_DONE
) {
395 g_free(cco
.filename
);
400 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
404 drv
= bdrv_find_protocol(filename
);
409 return bdrv_create(drv
, filename
, options
);
413 * Create a uniquely-named empty temporary file.
414 * Return 0 upon success, otherwise a negative errno value.
416 int get_tmp_filename(char *filename
, int size
)
419 char temp_dir
[MAX_PATH
];
420 /* GetTempFileName requires that its output buffer (4th param)
421 have length MAX_PATH or greater. */
422 assert(size
>= MAX_PATH
);
423 return (GetTempPath(MAX_PATH
, temp_dir
)
424 && GetTempFileName(temp_dir
, "qem", 0, filename
)
425 ? 0 : -GetLastError());
429 tmpdir
= getenv("TMPDIR");
432 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
435 fd
= mkstemp(filename
);
436 if (fd
< 0 || close(fd
)) {
444 * Detect host devices. By convention, /dev/cdrom[N] is always
445 * recognized as a host CDROM.
447 static BlockDriver
*find_hdev_driver(const char *filename
)
449 int score_max
= 0, score
;
450 BlockDriver
*drv
= NULL
, *d
;
452 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
453 if (d
->bdrv_probe_device
) {
454 score
= d
->bdrv_probe_device(filename
);
455 if (score
> score_max
) {
465 BlockDriver
*bdrv_find_protocol(const char *filename
)
472 /* TODO Drivers without bdrv_file_open must be specified explicitly */
475 * XXX(hch): we really should not let host device detection
476 * override an explicit protocol specification, but moving this
477 * later breaks access to device names with colons in them.
478 * Thanks to the brain-dead persistent naming schemes on udev-
479 * based Linux systems those actually are quite common.
481 drv1
= find_hdev_driver(filename
);
486 if (!path_has_protocol(filename
)) {
487 return bdrv_find_format("file");
489 p
= strchr(filename
, ':');
492 if (len
> sizeof(protocol
) - 1)
493 len
= sizeof(protocol
) - 1;
494 memcpy(protocol
, filename
, len
);
495 protocol
[len
] = '\0';
496 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
497 if (drv1
->protocol_name
&&
498 !strcmp(drv1
->protocol_name
, protocol
)) {
505 static int find_image_format(const char *filename
, BlockDriver
**pdrv
)
507 int ret
, score
, score_max
;
508 BlockDriver
*drv1
, *drv
;
510 BlockDriverState
*bs
;
512 ret
= bdrv_file_open(&bs
, filename
, 0);
518 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
519 if (bs
->sg
|| !bdrv_is_inserted(bs
)) {
521 drv
= bdrv_find_format("raw");
529 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
538 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
539 if (drv1
->bdrv_probe
) {
540 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
541 if (score
> score_max
) {
555 * Set the current 'total_sectors' value
557 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
559 BlockDriver
*drv
= bs
->drv
;
561 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
565 /* query actual device if possible, otherwise just trust the hint */
566 if (drv
->bdrv_getlength
) {
567 int64_t length
= drv
->bdrv_getlength(bs
);
571 hint
= length
>> BDRV_SECTOR_BITS
;
574 bs
->total_sectors
= hint
;
579 * Set open flags for a given cache mode
581 * Return 0 on success, -1 if the cache mode was invalid.
583 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
585 *flags
&= ~BDRV_O_CACHE_MASK
;
587 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
588 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
589 } else if (!strcmp(mode
, "directsync")) {
590 *flags
|= BDRV_O_NOCACHE
;
591 } else if (!strcmp(mode
, "writeback")) {
592 *flags
|= BDRV_O_CACHE_WB
;
593 } else if (!strcmp(mode
, "unsafe")) {
594 *flags
|= BDRV_O_CACHE_WB
;
595 *flags
|= BDRV_O_NO_FLUSH
;
596 } else if (!strcmp(mode
, "writethrough")) {
597 /* this is the default */
606 * The copy-on-read flag is actually a reference count so multiple users may
607 * use the feature without worrying about clobbering its previous state.
608 * Copy-on-read stays enabled until all users have called to disable it.
610 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
615 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
617 assert(bs
->copy_on_read
> 0);
622 * Common part for opening disk images and files
624 static int bdrv_open_common(BlockDriverState
*bs
, const char *filename
,
625 int flags
, BlockDriver
*drv
)
630 assert(bs
->file
== NULL
);
632 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
634 bs
->open_flags
= flags
;
635 bs
->buffer_alignment
= 512;
637 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
638 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
639 bdrv_enable_copy_on_read(bs
);
642 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
644 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
649 bs
->opaque
= g_malloc0(drv
->instance_size
);
651 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
652 open_flags
= flags
| BDRV_O_CACHE_WB
;
655 * Clear flags that are internal to the block layer before opening the
658 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
661 * Snapshots should be writable.
663 if (bs
->is_temporary
) {
664 open_flags
|= BDRV_O_RDWR
;
667 bs
->keep_read_only
= bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
669 /* Open the image, either directly or using a protocol */
670 if (drv
->bdrv_file_open
) {
671 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
673 ret
= bdrv_file_open(&bs
->file
, filename
, open_flags
);
675 ret
= drv
->bdrv_open(bs
, open_flags
);
683 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
689 if (bs
->is_temporary
) {
697 bdrv_delete(bs
->file
);
707 * Opens a file using a protocol (file, host_device, nbd, ...)
709 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
711 BlockDriverState
*bs
;
715 drv
= bdrv_find_protocol(filename
);
721 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
732 * Opens a disk image (raw, qcow2, vmdk, ...)
734 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int flags
,
738 char tmp_filename
[PATH_MAX
];
740 if (flags
& BDRV_O_SNAPSHOT
) {
741 BlockDriverState
*bs1
;
744 BlockDriver
*bdrv_qcow2
;
745 QEMUOptionParameter
*options
;
746 char backing_filename
[PATH_MAX
];
748 /* if snapshot, we create a temporary backing file and open it
749 instead of opening 'filename' directly */
751 /* if there is a backing file, use it */
753 ret
= bdrv_open(bs1
, filename
, 0, drv
);
758 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
760 if (bs1
->drv
&& bs1
->drv
->protocol_name
)
765 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
770 /* Real path is meaningless for protocols */
772 snprintf(backing_filename
, sizeof(backing_filename
),
774 else if (!realpath(filename
, backing_filename
))
777 bdrv_qcow2
= bdrv_find_format("qcow2");
778 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
780 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
781 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
783 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
787 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
788 free_option_parameters(options
);
793 filename
= tmp_filename
;
795 bs
->is_temporary
= 1;
798 /* Find the right image format driver */
800 ret
= find_image_format(filename
, &drv
);
804 goto unlink_and_fail
;
808 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
810 goto unlink_and_fail
;
813 /* If there is a backing file, use it */
814 if ((flags
& BDRV_O_NO_BACKING
) == 0 && bs
->backing_file
[0] != '\0') {
815 char backing_filename
[PATH_MAX
];
817 BlockDriver
*back_drv
= NULL
;
819 bs
->backing_hd
= bdrv_new("");
820 bdrv_get_full_backing_filename(bs
, backing_filename
,
821 sizeof(backing_filename
));
823 if (bs
->backing_format
[0] != '\0') {
824 back_drv
= bdrv_find_format(bs
->backing_format
);
827 /* backing files always opened read-only */
829 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
831 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, back_flags
, back_drv
);
836 if (bs
->is_temporary
) {
837 bs
->backing_hd
->keep_read_only
= !(flags
& BDRV_O_RDWR
);
839 /* base image inherits from "parent" */
840 bs
->backing_hd
->keep_read_only
= bs
->keep_read_only
;
844 if (!bdrv_key_required(bs
)) {
845 bdrv_dev_change_media_cb(bs
, true);
848 /* throttling disk I/O limits */
849 if (bs
->io_limits_enabled
) {
850 bdrv_io_limits_enable(bs
);
856 if (bs
->is_temporary
) {
862 void bdrv_close(BlockDriverState
*bs
)
867 block_job_cancel_sync(bs
->job
);
871 if (bs
== bs_snapshots
) {
874 if (bs
->backing_hd
) {
875 bdrv_delete(bs
->backing_hd
);
876 bs
->backing_hd
= NULL
;
878 bs
->drv
->bdrv_close(bs
);
881 if (bs
->is_temporary
) {
882 unlink(bs
->filename
);
887 bs
->copy_on_read
= 0;
888 bs
->backing_file
[0] = '\0';
889 bs
->backing_format
[0] = '\0';
890 bs
->total_sectors
= 0;
896 if (bs
->file
!= NULL
) {
897 bdrv_delete(bs
->file
);
901 bdrv_dev_change_media_cb(bs
, false);
904 /*throttling disk I/O limits*/
905 if (bs
->io_limits_enabled
) {
906 bdrv_io_limits_disable(bs
);
910 void bdrv_close_all(void)
912 BlockDriverState
*bs
;
914 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
920 * Wait for pending requests to complete across all BlockDriverStates
922 * This function does not flush data to disk, use bdrv_flush_all() for that
923 * after calling this function.
925 * Note that completion of an asynchronous I/O operation can trigger any
926 * number of other I/O operations on other devices---for example a coroutine
927 * can be arbitrarily complex and a constant flow of I/O can come until the
928 * coroutine is complete. Because of this, it is not possible to have a
929 * function to drain a single device's I/O queue.
931 void bdrv_drain_all(void)
933 BlockDriverState
*bs
;
937 busy
= qemu_aio_wait();
939 /* FIXME: We do not have timer support here, so this is effectively
942 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
943 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
944 qemu_co_queue_restart_all(&bs
->throttled_reqs
);
950 /* If requests are still pending there is a bug somewhere */
951 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
952 assert(QLIST_EMPTY(&bs
->tracked_requests
));
953 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
957 /* make a BlockDriverState anonymous by removing from bdrv_state list.
958 Also, NULL terminate the device_name to prevent double remove */
959 void bdrv_make_anon(BlockDriverState
*bs
)
961 if (bs
->device_name
[0] != '\0') {
962 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
964 bs
->device_name
[0] = '\0';
967 static void bdrv_rebind(BlockDriverState
*bs
)
969 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
970 bs
->drv
->bdrv_rebind(bs
);
974 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
975 BlockDriverState
*bs_src
)
977 /* move some fields that need to stay attached to the device */
978 bs_dest
->open_flags
= bs_src
->open_flags
;
981 bs_dest
->dev_ops
= bs_src
->dev_ops
;
982 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
983 bs_dest
->dev
= bs_src
->dev
;
984 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
985 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
987 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
989 /* i/o timing parameters */
990 bs_dest
->slice_time
= bs_src
->slice_time
;
991 bs_dest
->slice_start
= bs_src
->slice_start
;
992 bs_dest
->slice_end
= bs_src
->slice_end
;
993 bs_dest
->io_limits
= bs_src
->io_limits
;
994 bs_dest
->io_base
= bs_src
->io_base
;
995 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
996 bs_dest
->block_timer
= bs_src
->block_timer
;
997 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1000 bs_dest
->cyls
= bs_src
->cyls
;
1001 bs_dest
->heads
= bs_src
->heads
;
1002 bs_dest
->secs
= bs_src
->secs
;
1003 bs_dest
->translation
= bs_src
->translation
;
1006 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1007 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1010 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1011 bs_dest
->iostatus
= bs_src
->iostatus
;
1014 bs_dest
->dirty_count
= bs_src
->dirty_count
;
1015 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1018 bs_dest
->in_use
= bs_src
->in_use
;
1019 bs_dest
->job
= bs_src
->job
;
1021 /* keep the same entry in bdrv_states */
1022 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1023 bs_src
->device_name
);
1024 bs_dest
->list
= bs_src
->list
;
1028 * Swap bs contents for two image chains while they are live,
1029 * while keeping required fields on the BlockDriverState that is
1030 * actually attached to a device.
1032 * This will modify the BlockDriverState fields, and swap contents
1033 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1035 * bs_new is required to be anonymous.
1037 * This function does not create any image files.
1039 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1041 BlockDriverState tmp
;
1043 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1044 assert(bs_new
->device_name
[0] == '\0');
1045 assert(bs_new
->dirty_bitmap
== NULL
);
1046 assert(bs_new
->job
== NULL
);
1047 assert(bs_new
->dev
== NULL
);
1048 assert(bs_new
->in_use
== 0);
1049 assert(bs_new
->io_limits_enabled
== false);
1050 assert(bs_new
->block_timer
== NULL
);
1056 /* there are some fields that should not be swapped, move them back */
1057 bdrv_move_feature_fields(&tmp
, bs_old
);
1058 bdrv_move_feature_fields(bs_old
, bs_new
);
1059 bdrv_move_feature_fields(bs_new
, &tmp
);
1061 /* bs_new shouldn't be in bdrv_states even after the swap! */
1062 assert(bs_new
->device_name
[0] == '\0');
1064 /* Check a few fields that should remain attached to the device */
1065 assert(bs_new
->dev
== NULL
);
1066 assert(bs_new
->job
== NULL
);
1067 assert(bs_new
->in_use
== 0);
1068 assert(bs_new
->io_limits_enabled
== false);
1069 assert(bs_new
->block_timer
== NULL
);
1071 bdrv_rebind(bs_new
);
1072 bdrv_rebind(bs_old
);
1076 * Add new bs contents at the top of an image chain while the chain is
1077 * live, while keeping required fields on the top layer.
1079 * This will modify the BlockDriverState fields, and swap contents
1080 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1082 * bs_new is required to be anonymous.
1084 * This function does not create any image files.
1086 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1088 bdrv_swap(bs_new
, bs_top
);
1090 /* The contents of 'tmp' will become bs_top, as we are
1091 * swapping bs_new and bs_top contents. */
1092 bs_top
->backing_hd
= bs_new
;
1093 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1094 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1096 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1097 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1100 void bdrv_delete(BlockDriverState
*bs
)
1104 assert(!bs
->in_use
);
1106 /* remove from list, if necessary */
1111 assert(bs
!= bs_snapshots
);
1115 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1116 /* TODO change to DeviceState *dev when all users are qdevified */
1122 bdrv_iostatus_reset(bs
);
1126 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1127 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1129 if (bdrv_attach_dev(bs
, dev
) < 0) {
1134 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1135 /* TODO change to DeviceState *dev when all users are qdevified */
1137 assert(bs
->dev
== dev
);
1140 bs
->dev_opaque
= NULL
;
1141 bs
->buffer_alignment
= 512;
1144 /* TODO change to return DeviceState * when all users are qdevified */
1145 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1150 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1154 bs
->dev_opaque
= opaque
;
1155 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1156 bs_snapshots
= NULL
;
1160 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1161 BlockQMPEventAction action
, int is_read
)
1164 const char *action_str
;
1167 case BDRV_ACTION_REPORT
:
1168 action_str
= "report";
1170 case BDRV_ACTION_IGNORE
:
1171 action_str
= "ignore";
1173 case BDRV_ACTION_STOP
:
1174 action_str
= "stop";
1180 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1183 is_read
? "read" : "write");
1184 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR
, data
);
1186 qobject_decref(data
);
1189 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1193 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1194 bdrv_get_device_name(bs
), ejected
);
1195 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1197 qobject_decref(data
);
1200 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1202 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1203 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1204 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1205 if (tray_was_closed
) {
1207 bdrv_emit_qmp_eject_event(bs
, true);
1211 bdrv_emit_qmp_eject_event(bs
, false);
1216 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1218 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1221 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1223 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1224 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1228 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1230 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1231 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1236 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1238 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1239 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1243 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1245 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1246 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1252 * Run consistency checks on an image
1254 * Returns 0 if the check could be completed (it doesn't mean that the image is
1255 * free of errors) or -errno when an internal error occurred. The results of the
1256 * check are stored in res.
1258 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1260 if (bs
->drv
->bdrv_check
== NULL
) {
1264 memset(res
, 0, sizeof(*res
));
1265 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1268 #define COMMIT_BUF_SECTORS 2048
1270 /* commit COW file into the raw image */
1271 int bdrv_commit(BlockDriverState
*bs
)
1273 BlockDriver
*drv
= bs
->drv
;
1274 BlockDriver
*backing_drv
;
1275 int64_t sector
, total_sectors
;
1276 int n
, ro
, open_flags
;
1277 int ret
= 0, rw_ret
= 0;
1279 char filename
[1024];
1280 BlockDriverState
*bs_rw
, *bs_ro
;
1285 if (!bs
->backing_hd
) {
1289 if (bs
->backing_hd
->keep_read_only
) {
1293 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1297 backing_drv
= bs
->backing_hd
->drv
;
1298 ro
= bs
->backing_hd
->read_only
;
1299 strncpy(filename
, bs
->backing_hd
->filename
, sizeof(filename
));
1300 open_flags
= bs
->backing_hd
->open_flags
;
1304 bdrv_delete(bs
->backing_hd
);
1305 bs
->backing_hd
= NULL
;
1306 bs_rw
= bdrv_new("");
1307 rw_ret
= bdrv_open(bs_rw
, filename
, open_flags
| BDRV_O_RDWR
,
1311 /* try to re-open read-only */
1312 bs_ro
= bdrv_new("");
1313 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1317 /* drive not functional anymore */
1321 bs
->backing_hd
= bs_ro
;
1324 bs
->backing_hd
= bs_rw
;
1327 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1328 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1330 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1331 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1333 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1338 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1345 if (drv
->bdrv_make_empty
) {
1346 ret
= drv
->bdrv_make_empty(bs
);
1351 * Make sure all data we wrote to the backing device is actually
1355 bdrv_flush(bs
->backing_hd
);
1362 bdrv_delete(bs
->backing_hd
);
1363 bs
->backing_hd
= NULL
;
1364 bs_ro
= bdrv_new("");
1365 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1369 /* drive not functional anymore */
1373 bs
->backing_hd
= bs_ro
;
1374 bs
->backing_hd
->keep_read_only
= 0;
1380 int bdrv_commit_all(void)
1382 BlockDriverState
*bs
;
1384 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1385 int ret
= bdrv_commit(bs
);
1393 struct BdrvTrackedRequest
{
1394 BlockDriverState
*bs
;
1398 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1399 Coroutine
*co
; /* owner, used for deadlock detection */
1400 CoQueue wait_queue
; /* coroutines blocked on this request */
1404 * Remove an active request from the tracked requests list
1406 * This function should be called when a tracked request is completing.
1408 static void tracked_request_end(BdrvTrackedRequest
*req
)
1410 QLIST_REMOVE(req
, list
);
1411 qemu_co_queue_restart_all(&req
->wait_queue
);
1415 * Add an active request to the tracked requests list
1417 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1418 BlockDriverState
*bs
,
1420 int nb_sectors
, bool is_write
)
1422 *req
= (BdrvTrackedRequest
){
1424 .sector_num
= sector_num
,
1425 .nb_sectors
= nb_sectors
,
1426 .is_write
= is_write
,
1427 .co
= qemu_coroutine_self(),
1430 qemu_co_queue_init(&req
->wait_queue
);
1432 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1436 * Round a region to cluster boundaries
1438 static void round_to_clusters(BlockDriverState
*bs
,
1439 int64_t sector_num
, int nb_sectors
,
1440 int64_t *cluster_sector_num
,
1441 int *cluster_nb_sectors
)
1443 BlockDriverInfo bdi
;
1445 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1446 *cluster_sector_num
= sector_num
;
1447 *cluster_nb_sectors
= nb_sectors
;
1449 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1450 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1451 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1456 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1457 int64_t sector_num
, int nb_sectors
) {
1459 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1463 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1469 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1470 int64_t sector_num
, int nb_sectors
)
1472 BdrvTrackedRequest
*req
;
1473 int64_t cluster_sector_num
;
1474 int cluster_nb_sectors
;
1477 /* If we touch the same cluster it counts as an overlap. This guarantees
1478 * that allocating writes will be serialized and not race with each other
1479 * for the same cluster. For example, in copy-on-read it ensures that the
1480 * CoR read and write operations are atomic and guest writes cannot
1481 * interleave between them.
1483 round_to_clusters(bs
, sector_num
, nb_sectors
,
1484 &cluster_sector_num
, &cluster_nb_sectors
);
1488 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1489 if (tracked_request_overlaps(req
, cluster_sector_num
,
1490 cluster_nb_sectors
)) {
1491 /* Hitting this means there was a reentrant request, for
1492 * example, a block driver issuing nested requests. This must
1493 * never happen since it means deadlock.
1495 assert(qemu_coroutine_self() != req
->co
);
1497 qemu_co_queue_wait(&req
->wait_queue
);
1508 * -EINVAL - backing format specified, but no file
1509 * -ENOSPC - can't update the backing file because no space is left in the
1511 * -ENOTSUP - format driver doesn't support changing the backing file
1513 int bdrv_change_backing_file(BlockDriverState
*bs
,
1514 const char *backing_file
, const char *backing_fmt
)
1516 BlockDriver
*drv
= bs
->drv
;
1519 /* Backing file format doesn't make sense without a backing file */
1520 if (backing_fmt
&& !backing_file
) {
1524 if (drv
->bdrv_change_backing_file
!= NULL
) {
1525 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1531 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1532 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1537 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1542 if (!bdrv_is_inserted(bs
))
1548 len
= bdrv_getlength(bs
);
1553 if ((offset
> len
) || (len
- offset
< size
))
1559 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1562 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1563 nb_sectors
* BDRV_SECTOR_SIZE
);
1566 typedef struct RwCo
{
1567 BlockDriverState
*bs
;
1575 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1577 RwCo
*rwco
= opaque
;
1579 if (!rwco
->is_write
) {
1580 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1581 rwco
->nb_sectors
, rwco
->qiov
, 0);
1583 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1584 rwco
->nb_sectors
, rwco
->qiov
, 0);
1589 * Process a synchronous request using coroutines
1591 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1592 int nb_sectors
, bool is_write
)
1595 struct iovec iov
= {
1596 .iov_base
= (void *)buf
,
1597 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1602 .sector_num
= sector_num
,
1603 .nb_sectors
= nb_sectors
,
1605 .is_write
= is_write
,
1609 qemu_iovec_init_external(&qiov
, &iov
, 1);
1612 * In sync call context, when the vcpu is blocked, this throttling timer
1613 * will not fire; so the I/O throttling function has to be disabled here
1614 * if it has been enabled.
1616 if (bs
->io_limits_enabled
) {
1617 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
1618 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
1619 bdrv_io_limits_disable(bs
);
1622 if (qemu_in_coroutine()) {
1623 /* Fast-path if already in coroutine context */
1624 bdrv_rw_co_entry(&rwco
);
1626 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1627 qemu_coroutine_enter(co
, &rwco
);
1628 while (rwco
.ret
== NOT_DONE
) {
1635 /* return < 0 if error. See bdrv_write() for the return codes */
1636 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1637 uint8_t *buf
, int nb_sectors
)
1639 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1642 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
1643 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
1644 uint8_t *buf
, int nb_sectors
)
1649 enabled
= bs
->io_limits_enabled
;
1650 bs
->io_limits_enabled
= false;
1651 ret
= bdrv_read(bs
, 0, buf
, 1);
1652 bs
->io_limits_enabled
= enabled
;
1656 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
1658 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1659 int nb_sectors
, int dirty
)
1662 unsigned long val
, idx
, bit
;
1664 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
1665 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
1667 for (; start
<= end
; start
++) {
1668 idx
= start
/ BITS_PER_LONG
;
1669 bit
= start
% BITS_PER_LONG
;
1670 val
= bs
->dirty_bitmap
[idx
];
1672 if (!(val
& (1UL << bit
))) {
1677 if (val
& (1UL << bit
)) {
1679 val
&= ~(1UL << bit
);
1682 bs
->dirty_bitmap
[idx
] = val
;
1686 /* Return < 0 if error. Important errors are:
1687 -EIO generic I/O error (may happen for all errors)
1688 -ENOMEDIUM No media inserted.
1689 -EINVAL Invalid sector number or nb_sectors
1690 -EACCES Trying to write a read-only device
1692 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
1693 const uint8_t *buf
, int nb_sectors
)
1695 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
1698 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
1699 void *buf
, int count1
)
1701 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1702 int len
, nb_sectors
, count
;
1707 /* first read to align to sector start */
1708 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1711 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1713 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1715 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
1723 /* read the sectors "in place" */
1724 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1725 if (nb_sectors
> 0) {
1726 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1728 sector_num
+= nb_sectors
;
1729 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1734 /* add data from the last sector */
1736 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1738 memcpy(buf
, tmp_buf
, count
);
1743 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
1744 const void *buf
, int count1
)
1746 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1747 int len
, nb_sectors
, count
;
1752 /* first write to align to sector start */
1753 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1756 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1758 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1760 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
1761 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1770 /* write the sectors "in place" */
1771 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1772 if (nb_sectors
> 0) {
1773 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1775 sector_num
+= nb_sectors
;
1776 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1781 /* add data from the last sector */
1783 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1785 memcpy(tmp_buf
, buf
, count
);
1786 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1793 * Writes to the file and ensures that no writes are reordered across this
1794 * request (acts as a barrier)
1796 * Returns 0 on success, -errno in error cases.
1798 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
1799 const void *buf
, int count
)
1803 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
1808 /* No flush needed for cache modes that already do it */
1809 if (bs
->enable_write_cache
) {
1816 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
1817 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1819 /* Perform I/O through a temporary buffer so that users who scribble over
1820 * their read buffer while the operation is in progress do not end up
1821 * modifying the image file. This is critical for zero-copy guest I/O
1822 * where anything might happen inside guest memory.
1824 void *bounce_buffer
;
1826 BlockDriver
*drv
= bs
->drv
;
1828 QEMUIOVector bounce_qiov
;
1829 int64_t cluster_sector_num
;
1830 int cluster_nb_sectors
;
1834 /* Cover entire cluster so no additional backing file I/O is required when
1835 * allocating cluster in the image file.
1837 round_to_clusters(bs
, sector_num
, nb_sectors
,
1838 &cluster_sector_num
, &cluster_nb_sectors
);
1840 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
1841 cluster_sector_num
, cluster_nb_sectors
);
1843 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
1844 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
1845 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
1847 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
1853 if (drv
->bdrv_co_write_zeroes
&&
1854 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
1855 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
1856 cluster_nb_sectors
);
1858 /* This does not change the data on the disk, it is not necessary
1859 * to flush even in cache=writethrough mode.
1861 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
1866 /* It might be okay to ignore write errors for guest requests. If this
1867 * is a deliberate copy-on-read then we don't want to ignore the error.
1868 * Simply report it in all cases.
1873 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
1874 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
1875 nb_sectors
* BDRV_SECTOR_SIZE
);
1878 qemu_vfree(bounce_buffer
);
1883 * Handle a read request in coroutine context
1885 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
1886 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1887 BdrvRequestFlags flags
)
1889 BlockDriver
*drv
= bs
->drv
;
1890 BdrvTrackedRequest req
;
1896 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1900 /* throttling disk read I/O */
1901 if (bs
->io_limits_enabled
) {
1902 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
1905 if (bs
->copy_on_read
) {
1906 flags
|= BDRV_REQ_COPY_ON_READ
;
1908 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1909 bs
->copy_on_read_in_flight
++;
1912 if (bs
->copy_on_read_in_flight
) {
1913 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1916 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
1918 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1921 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
1926 if (!ret
|| pnum
!= nb_sectors
) {
1927 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
1932 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
1935 tracked_request_end(&req
);
1937 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1938 bs
->copy_on_read_in_flight
--;
1944 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1945 int nb_sectors
, QEMUIOVector
*qiov
)
1947 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
1949 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
1952 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
1953 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1955 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
1957 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
1958 BDRV_REQ_COPY_ON_READ
);
1961 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
1962 int64_t sector_num
, int nb_sectors
)
1964 BlockDriver
*drv
= bs
->drv
;
1969 /* TODO Emulate only part of misaligned requests instead of letting block
1970 * drivers return -ENOTSUP and emulate everything */
1972 /* First try the efficient write zeroes operation */
1973 if (drv
->bdrv_co_write_zeroes
) {
1974 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1975 if (ret
!= -ENOTSUP
) {
1980 /* Fall back to bounce buffer if write zeroes is unsupported */
1981 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
1982 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
1983 memset(iov
.iov_base
, 0, iov
.iov_len
);
1984 qemu_iovec_init_external(&qiov
, &iov
, 1);
1986 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
1988 qemu_vfree(iov
.iov_base
);
1993 * Handle a write request in coroutine context
1995 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
1996 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1997 BdrvRequestFlags flags
)
1999 BlockDriver
*drv
= bs
->drv
;
2000 BdrvTrackedRequest req
;
2006 if (bs
->read_only
) {
2009 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2013 /* throttling disk write I/O */
2014 if (bs
->io_limits_enabled
) {
2015 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2018 if (bs
->copy_on_read_in_flight
) {
2019 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2022 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2024 if (flags
& BDRV_REQ_ZERO_WRITE
) {
2025 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2027 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2030 if (ret
== 0 && !bs
->enable_write_cache
) {
2031 ret
= bdrv_co_flush(bs
);
2034 if (bs
->dirty_bitmap
) {
2035 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2038 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2039 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2042 tracked_request_end(&req
);
2047 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2048 int nb_sectors
, QEMUIOVector
*qiov
)
2050 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2052 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2055 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2056 int64_t sector_num
, int nb_sectors
)
2058 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2060 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2061 BDRV_REQ_ZERO_WRITE
);
2065 * Truncate file to 'offset' bytes (needed only for file protocols)
2067 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2069 BlockDriver
*drv
= bs
->drv
;
2073 if (!drv
->bdrv_truncate
)
2077 if (bdrv_in_use(bs
))
2079 ret
= drv
->bdrv_truncate(bs
, offset
);
2081 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2082 bdrv_dev_resize_cb(bs
);
2088 * Length of a allocated file in bytes. Sparse files are counted by actual
2089 * allocated space. Return < 0 if error or unknown.
2091 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2093 BlockDriver
*drv
= bs
->drv
;
2097 if (drv
->bdrv_get_allocated_file_size
) {
2098 return drv
->bdrv_get_allocated_file_size(bs
);
2101 return bdrv_get_allocated_file_size(bs
->file
);
2107 * Length of a file in bytes. Return < 0 if error or unknown.
2109 int64_t bdrv_getlength(BlockDriverState
*bs
)
2111 BlockDriver
*drv
= bs
->drv
;
2115 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2116 if (drv
->bdrv_getlength
) {
2117 return drv
->bdrv_getlength(bs
);
2120 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2123 /* return 0 as number of sectors if no device present or error */
2124 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2127 length
= bdrv_getlength(bs
);
2131 length
= length
>> BDRV_SECTOR_BITS
;
2132 *nb_sectors_ptr
= length
;
2135 void bdrv_set_geometry_hint(BlockDriverState
*bs
,
2136 int cyls
, int heads
, int secs
)
2143 void bdrv_set_translation_hint(BlockDriverState
*bs
, int translation
)
2145 bs
->translation
= translation
;
2148 void bdrv_get_geometry_hint(BlockDriverState
*bs
,
2149 int *pcyls
, int *pheads
, int *psecs
)
2152 *pheads
= bs
->heads
;
2156 /* throttling disk io limits */
2157 void bdrv_set_io_limits(BlockDriverState
*bs
,
2158 BlockIOLimit
*io_limits
)
2160 bs
->io_limits
= *io_limits
;
2161 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2164 int bdrv_get_translation_hint(BlockDriverState
*bs
)
2166 return bs
->translation
;
2169 void bdrv_set_on_error(BlockDriverState
*bs
, BlockErrorAction on_read_error
,
2170 BlockErrorAction on_write_error
)
2172 bs
->on_read_error
= on_read_error
;
2173 bs
->on_write_error
= on_write_error
;
2176 BlockErrorAction
bdrv_get_on_error(BlockDriverState
*bs
, int is_read
)
2178 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2181 int bdrv_is_read_only(BlockDriverState
*bs
)
2183 return bs
->read_only
;
2186 int bdrv_is_sg(BlockDriverState
*bs
)
2191 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2193 return bs
->enable_write_cache
;
2196 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2198 bs
->enable_write_cache
= wce
;
2201 int bdrv_is_encrypted(BlockDriverState
*bs
)
2203 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2205 return bs
->encrypted
;
2208 int bdrv_key_required(BlockDriverState
*bs
)
2210 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2212 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2214 return (bs
->encrypted
&& !bs
->valid_key
);
2217 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2220 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2221 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2227 if (!bs
->encrypted
) {
2229 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2232 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2235 } else if (!bs
->valid_key
) {
2237 /* call the change callback now, we skipped it on open */
2238 bdrv_dev_change_media_cb(bs
, true);
2243 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2245 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2248 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2253 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2254 it(opaque
, drv
->format_name
);
2258 BlockDriverState
*bdrv_find(const char *name
)
2260 BlockDriverState
*bs
;
2262 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2263 if (!strcmp(name
, bs
->device_name
)) {
2270 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2273 return QTAILQ_FIRST(&bdrv_states
);
2275 return QTAILQ_NEXT(bs
, list
);
2278 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2280 BlockDriverState
*bs
;
2282 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2287 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2289 return bs
->device_name
;
2292 int bdrv_get_flags(BlockDriverState
*bs
)
2294 return bs
->open_flags
;
2297 void bdrv_flush_all(void)
2299 BlockDriverState
*bs
;
2301 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2306 int bdrv_has_zero_init(BlockDriverState
*bs
)
2310 if (bs
->drv
->bdrv_has_zero_init
) {
2311 return bs
->drv
->bdrv_has_zero_init(bs
);
2317 typedef struct BdrvCoIsAllocatedData
{
2318 BlockDriverState
*bs
;
2324 } BdrvCoIsAllocatedData
;
2327 * Returns true iff the specified sector is present in the disk image. Drivers
2328 * not implementing the functionality are assumed to not support backing files,
2329 * hence all their sectors are reported as allocated.
2331 * If 'sector_num' is beyond the end of the disk image the return value is 0
2332 * and 'pnum' is set to 0.
2334 * 'pnum' is set to the number of sectors (including and immediately following
2335 * the specified sector) that are known to be in the same
2336 * allocated/unallocated state.
2338 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2339 * beyond the end of the disk image it will be clamped.
2341 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2342 int nb_sectors
, int *pnum
)
2346 if (sector_num
>= bs
->total_sectors
) {
2351 n
= bs
->total_sectors
- sector_num
;
2352 if (n
< nb_sectors
) {
2356 if (!bs
->drv
->bdrv_co_is_allocated
) {
2361 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2364 /* Coroutine wrapper for bdrv_is_allocated() */
2365 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2367 BdrvCoIsAllocatedData
*data
= opaque
;
2368 BlockDriverState
*bs
= data
->bs
;
2370 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2376 * Synchronous wrapper around bdrv_co_is_allocated().
2378 * See bdrv_co_is_allocated() for details.
2380 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2384 BdrvCoIsAllocatedData data
= {
2386 .sector_num
= sector_num
,
2387 .nb_sectors
= nb_sectors
,
2392 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2393 qemu_coroutine_enter(co
, &data
);
2394 while (!data
.done
) {
2401 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2403 * Return true if the given sector is allocated in any image between
2404 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2405 * sector is allocated in any image of the chain. Return false otherwise.
2407 * 'pnum' is set to the number of sectors (including and immediately following
2408 * the specified sector) that are known to be in the same
2409 * allocated/unallocated state.
2412 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2413 BlockDriverState
*base
,
2415 int nb_sectors
, int *pnum
)
2417 BlockDriverState
*intermediate
;
2418 int ret
, n
= nb_sectors
;
2421 while (intermediate
&& intermediate
!= base
) {
2423 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2433 * [sector_num, nb_sectors] is unallocated on top but intermediate
2436 * [sector_num+x, nr_sectors] allocated.
2438 if (n
> pnum_inter
) {
2442 intermediate
= intermediate
->backing_hd
;
2449 BlockInfoList
*qmp_query_block(Error
**errp
)
2451 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2452 BlockDriverState
*bs
;
2454 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2455 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2457 info
->value
= g_malloc0(sizeof(*info
->value
));
2458 info
->value
->device
= g_strdup(bs
->device_name
);
2459 info
->value
->type
= g_strdup("unknown");
2460 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2461 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2463 if (bdrv_dev_has_removable_media(bs
)) {
2464 info
->value
->has_tray_open
= true;
2465 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2468 if (bdrv_iostatus_is_enabled(bs
)) {
2469 info
->value
->has_io_status
= true;
2470 info
->value
->io_status
= bs
->iostatus
;
2474 info
->value
->has_inserted
= true;
2475 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2476 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2477 info
->value
->inserted
->ro
= bs
->read_only
;
2478 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2479 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2480 if (bs
->backing_file
[0]) {
2481 info
->value
->inserted
->has_backing_file
= true;
2482 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2485 if (bs
->io_limits_enabled
) {
2486 info
->value
->inserted
->bps
=
2487 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2488 info
->value
->inserted
->bps_rd
=
2489 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2490 info
->value
->inserted
->bps_wr
=
2491 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2492 info
->value
->inserted
->iops
=
2493 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2494 info
->value
->inserted
->iops_rd
=
2495 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2496 info
->value
->inserted
->iops_wr
=
2497 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2501 /* XXX: waiting for the qapi to support GSList */
2503 head
= cur_item
= info
;
2505 cur_item
->next
= info
;
2513 /* Consider exposing this as a full fledged QMP command */
2514 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2518 s
= g_malloc0(sizeof(*s
));
2520 if (bs
->device_name
[0]) {
2521 s
->has_device
= true;
2522 s
->device
= g_strdup(bs
->device_name
);
2525 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2526 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2527 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2528 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2529 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2530 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2531 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2532 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2533 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2534 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2537 s
->has_parent
= true;
2538 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2544 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2546 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2547 BlockDriverState
*bs
;
2549 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2550 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2551 info
->value
= qmp_query_blockstat(bs
, NULL
);
2553 /* XXX: waiting for the qapi to support GSList */
2555 head
= cur_item
= info
;
2557 cur_item
->next
= info
;
2565 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2567 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2568 return bs
->backing_file
;
2569 else if (bs
->encrypted
)
2570 return bs
->filename
;
2575 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2576 char *filename
, int filename_size
)
2578 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2581 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2582 const uint8_t *buf
, int nb_sectors
)
2584 BlockDriver
*drv
= bs
->drv
;
2587 if (!drv
->bdrv_write_compressed
)
2589 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2592 if (bs
->dirty_bitmap
) {
2593 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2596 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2599 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2601 BlockDriver
*drv
= bs
->drv
;
2604 if (!drv
->bdrv_get_info
)
2606 memset(bdi
, 0, sizeof(*bdi
));
2607 return drv
->bdrv_get_info(bs
, bdi
);
2610 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2611 int64_t pos
, int size
)
2613 BlockDriver
*drv
= bs
->drv
;
2616 if (drv
->bdrv_save_vmstate
)
2617 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2619 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2623 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2624 int64_t pos
, int size
)
2626 BlockDriver
*drv
= bs
->drv
;
2629 if (drv
->bdrv_load_vmstate
)
2630 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2632 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2636 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2638 BlockDriver
*drv
= bs
->drv
;
2640 if (!drv
|| !drv
->bdrv_debug_event
) {
2644 return drv
->bdrv_debug_event(bs
, event
);
2648 /**************************************************************/
2649 /* handling of snapshots */
2651 int bdrv_can_snapshot(BlockDriverState
*bs
)
2653 BlockDriver
*drv
= bs
->drv
;
2654 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
2658 if (!drv
->bdrv_snapshot_create
) {
2659 if (bs
->file
!= NULL
) {
2660 return bdrv_can_snapshot(bs
->file
);
2668 int bdrv_is_snapshot(BlockDriverState
*bs
)
2670 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2673 BlockDriverState
*bdrv_snapshots(void)
2675 BlockDriverState
*bs
;
2678 return bs_snapshots
;
2682 while ((bs
= bdrv_next(bs
))) {
2683 if (bdrv_can_snapshot(bs
)) {
2691 int bdrv_snapshot_create(BlockDriverState
*bs
,
2692 QEMUSnapshotInfo
*sn_info
)
2694 BlockDriver
*drv
= bs
->drv
;
2697 if (drv
->bdrv_snapshot_create
)
2698 return drv
->bdrv_snapshot_create(bs
, sn_info
);
2700 return bdrv_snapshot_create(bs
->file
, sn_info
);
2704 int bdrv_snapshot_goto(BlockDriverState
*bs
,
2705 const char *snapshot_id
)
2707 BlockDriver
*drv
= bs
->drv
;
2712 if (drv
->bdrv_snapshot_goto
)
2713 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
2716 drv
->bdrv_close(bs
);
2717 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
2718 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
2720 bdrv_delete(bs
->file
);
2730 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2732 BlockDriver
*drv
= bs
->drv
;
2735 if (drv
->bdrv_snapshot_delete
)
2736 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
2738 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
2742 int bdrv_snapshot_list(BlockDriverState
*bs
,
2743 QEMUSnapshotInfo
**psn_info
)
2745 BlockDriver
*drv
= bs
->drv
;
2748 if (drv
->bdrv_snapshot_list
)
2749 return drv
->bdrv_snapshot_list(bs
, psn_info
);
2751 return bdrv_snapshot_list(bs
->file
, psn_info
);
2755 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
2756 const char *snapshot_name
)
2758 BlockDriver
*drv
= bs
->drv
;
2762 if (!bs
->read_only
) {
2765 if (drv
->bdrv_snapshot_load_tmp
) {
2766 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
2771 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2772 const char *backing_file
)
2778 if (bs
->backing_hd
) {
2779 if (strcmp(bs
->backing_file
, backing_file
) == 0) {
2780 return bs
->backing_hd
;
2782 return bdrv_find_backing_image(bs
->backing_hd
, backing_file
);
2789 #define NB_SUFFIXES 4
2791 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
2793 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
2798 snprintf(buf
, buf_size
, "%" PRId64
, size
);
2801 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
2802 if (size
< (10 * base
)) {
2803 snprintf(buf
, buf_size
, "%0.1f%c",
2804 (double)size
/ base
,
2807 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
2808 snprintf(buf
, buf_size
, "%" PRId64
"%c",
2809 ((size
+ (base
>> 1)) / base
),
2819 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
2821 char buf1
[128], date_buf
[128], clock_buf
[128];
2831 snprintf(buf
, buf_size
,
2832 "%-10s%-20s%7s%20s%15s",
2833 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2837 ptm
= localtime(&ti
);
2838 strftime(date_buf
, sizeof(date_buf
),
2839 "%Y-%m-%d %H:%M:%S", ptm
);
2841 localtime_r(&ti
, &tm
);
2842 strftime(date_buf
, sizeof(date_buf
),
2843 "%Y-%m-%d %H:%M:%S", &tm
);
2845 secs
= sn
->vm_clock_nsec
/ 1000000000;
2846 snprintf(clock_buf
, sizeof(clock_buf
),
2847 "%02d:%02d:%02d.%03d",
2849 (int)((secs
/ 60) % 60),
2851 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
2852 snprintf(buf
, buf_size
,
2853 "%-10s%-20s%7s%20s%15s",
2854 sn
->id_str
, sn
->name
,
2855 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
2862 /**************************************************************/
2865 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
2866 QEMUIOVector
*qiov
, int nb_sectors
,
2867 BlockDriverCompletionFunc
*cb
, void *opaque
)
2869 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
2871 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2875 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
2876 QEMUIOVector
*qiov
, int nb_sectors
,
2877 BlockDriverCompletionFunc
*cb
, void *opaque
)
2879 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
2881 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2886 typedef struct MultiwriteCB
{
2891 BlockDriverCompletionFunc
*cb
;
2893 QEMUIOVector
*free_qiov
;
2897 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
2901 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
2902 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
2903 if (mcb
->callbacks
[i
].free_qiov
) {
2904 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
2906 g_free(mcb
->callbacks
[i
].free_qiov
);
2910 static void multiwrite_cb(void *opaque
, int ret
)
2912 MultiwriteCB
*mcb
= opaque
;
2914 trace_multiwrite_cb(mcb
, ret
);
2916 if (ret
< 0 && !mcb
->error
) {
2920 mcb
->num_requests
--;
2921 if (mcb
->num_requests
== 0) {
2922 multiwrite_user_cb(mcb
);
2927 static int multiwrite_req_compare(const void *a
, const void *b
)
2929 const BlockRequest
*req1
= a
, *req2
= b
;
2932 * Note that we can't simply subtract req2->sector from req1->sector
2933 * here as that could overflow the return value.
2935 if (req1
->sector
> req2
->sector
) {
2937 } else if (req1
->sector
< req2
->sector
) {
2945 * Takes a bunch of requests and tries to merge them. Returns the number of
2946 * requests that remain after merging.
2948 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
2949 int num_reqs
, MultiwriteCB
*mcb
)
2953 // Sort requests by start sector
2954 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
2956 // Check if adjacent requests touch the same clusters. If so, combine them,
2957 // filling up gaps with zero sectors.
2959 for (i
= 1; i
< num_reqs
; i
++) {
2961 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
2963 // Handle exactly sequential writes and overlapping writes.
2964 if (reqs
[i
].sector
<= oldreq_last
) {
2968 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
2974 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
2975 qemu_iovec_init(qiov
,
2976 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
2978 // Add the first request to the merged one. If the requests are
2979 // overlapping, drop the last sectors of the first request.
2980 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
2981 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
2983 // We should need to add any zeros between the two requests
2984 assert (reqs
[i
].sector
<= oldreq_last
);
2986 // Add the second request
2987 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
2989 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
2990 reqs
[outidx
].qiov
= qiov
;
2992 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
2995 reqs
[outidx
].sector
= reqs
[i
].sector
;
2996 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
2997 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3005 * Submit multiple AIO write requests at once.
3007 * On success, the function returns 0 and all requests in the reqs array have
3008 * been submitted. In error case this function returns -1, and any of the
3009 * requests may or may not be submitted yet. In particular, this means that the
3010 * callback will be called for some of the requests, for others it won't. The
3011 * caller must check the error field of the BlockRequest to wait for the right
3012 * callbacks (if error != 0, no callback will be called).
3014 * The implementation may modify the contents of the reqs array, e.g. to merge
3015 * requests. However, the fields opaque and error are left unmodified as they
3016 * are used to signal failure for a single request to the caller.
3018 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3023 /* don't submit writes if we don't have a medium */
3024 if (bs
->drv
== NULL
) {
3025 for (i
= 0; i
< num_reqs
; i
++) {
3026 reqs
[i
].error
= -ENOMEDIUM
;
3031 if (num_reqs
== 0) {
3035 // Create MultiwriteCB structure
3036 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3037 mcb
->num_requests
= 0;
3038 mcb
->num_callbacks
= num_reqs
;
3040 for (i
= 0; i
< num_reqs
; i
++) {
3041 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3042 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3045 // Check for mergable requests
3046 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3048 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3050 /* Run the aio requests. */
3051 mcb
->num_requests
= num_reqs
;
3052 for (i
= 0; i
< num_reqs
; i
++) {
3053 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3054 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3060 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3062 acb
->pool
->cancel(acb
);
3065 /* block I/O throttling */
3066 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3067 bool is_write
, double elapsed_time
, uint64_t *wait
)
3069 uint64_t bps_limit
= 0;
3070 double bytes_limit
, bytes_base
, bytes_res
;
3071 double slice_time
, wait_time
;
3073 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3074 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3075 } else if (bs
->io_limits
.bps
[is_write
]) {
3076 bps_limit
= bs
->io_limits
.bps
[is_write
];
3085 slice_time
= bs
->slice_end
- bs
->slice_start
;
3086 slice_time
/= (NANOSECONDS_PER_SECOND
);
3087 bytes_limit
= bps_limit
* slice_time
;
3088 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3089 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3090 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3093 /* bytes_base: the bytes of data which have been read/written; and
3094 * it is obtained from the history statistic info.
3095 * bytes_res: the remaining bytes of data which need to be read/written.
3096 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3097 * the total time for completing reading/writting all data.
3099 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3101 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3109 /* Calc approx time to dispatch */
3110 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3112 /* When the I/O rate at runtime exceeds the limits,
3113 * bs->slice_end need to be extended in order that the current statistic
3114 * info can be kept until the timer fire, so it is increased and tuned
3115 * based on the result of experiment.
3117 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3118 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3120 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3126 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3127 double elapsed_time
, uint64_t *wait
)
3129 uint64_t iops_limit
= 0;
3130 double ios_limit
, ios_base
;
3131 double slice_time
, wait_time
;
3133 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3134 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3135 } else if (bs
->io_limits
.iops
[is_write
]) {
3136 iops_limit
= bs
->io_limits
.iops
[is_write
];
3145 slice_time
= bs
->slice_end
- bs
->slice_start
;
3146 slice_time
/= (NANOSECONDS_PER_SECOND
);
3147 ios_limit
= iops_limit
* slice_time
;
3148 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3149 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3150 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3153 if (ios_base
+ 1 <= ios_limit
) {
3161 /* Calc approx time to dispatch */
3162 wait_time
= (ios_base
+ 1) / iops_limit
;
3163 if (wait_time
> elapsed_time
) {
3164 wait_time
= wait_time
- elapsed_time
;
3169 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3170 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3172 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3178 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3179 bool is_write
, int64_t *wait
)
3181 int64_t now
, max_wait
;
3182 uint64_t bps_wait
= 0, iops_wait
= 0;
3183 double elapsed_time
;
3184 int bps_ret
, iops_ret
;
3186 now
= qemu_get_clock_ns(vm_clock
);
3187 if ((bs
->slice_start
< now
)
3188 && (bs
->slice_end
> now
)) {
3189 bs
->slice_end
= now
+ bs
->slice_time
;
3191 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3192 bs
->slice_start
= now
;
3193 bs
->slice_end
= now
+ bs
->slice_time
;
3195 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3196 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3198 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3199 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3202 elapsed_time
= now
- bs
->slice_start
;
3203 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3205 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3206 is_write
, elapsed_time
, &bps_wait
);
3207 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3208 elapsed_time
, &iops_wait
);
3209 if (bps_ret
|| iops_ret
) {
3210 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3215 now
= qemu_get_clock_ns(vm_clock
);
3216 if (bs
->slice_end
< now
+ max_wait
) {
3217 bs
->slice_end
= now
+ max_wait
;
3230 /**************************************************************/
3231 /* async block device emulation */
3233 typedef struct BlockDriverAIOCBSync
{
3234 BlockDriverAIOCB common
;
3237 /* vector translation state */
3241 } BlockDriverAIOCBSync
;
3243 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3245 BlockDriverAIOCBSync
*acb
=
3246 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3247 qemu_bh_delete(acb
->bh
);
3249 qemu_aio_release(acb
);
3252 static AIOPool bdrv_em_aio_pool
= {
3253 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3254 .cancel
= bdrv_aio_cancel_em
,
3257 static void bdrv_aio_bh_cb(void *opaque
)
3259 BlockDriverAIOCBSync
*acb
= opaque
;
3262 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3263 qemu_vfree(acb
->bounce
);
3264 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3265 qemu_bh_delete(acb
->bh
);
3267 qemu_aio_release(acb
);
3270 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3274 BlockDriverCompletionFunc
*cb
,
3279 BlockDriverAIOCBSync
*acb
;
3281 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3282 acb
->is_write
= is_write
;
3284 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3285 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3288 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3289 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3291 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3294 qemu_bh_schedule(acb
->bh
);
3296 return &acb
->common
;
3299 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3300 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3301 BlockDriverCompletionFunc
*cb
, void *opaque
)
3303 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3306 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3307 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3308 BlockDriverCompletionFunc
*cb
, void *opaque
)
3310 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3314 typedef struct BlockDriverAIOCBCoroutine
{
3315 BlockDriverAIOCB common
;
3319 } BlockDriverAIOCBCoroutine
;
3321 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3326 static AIOPool bdrv_em_co_aio_pool
= {
3327 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3328 .cancel
= bdrv_aio_co_cancel_em
,
3331 static void bdrv_co_em_bh(void *opaque
)
3333 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3335 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3336 qemu_bh_delete(acb
->bh
);
3337 qemu_aio_release(acb
);
3340 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3341 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3343 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3344 BlockDriverState
*bs
= acb
->common
.bs
;
3346 if (!acb
->is_write
) {
3347 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3348 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3350 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3351 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3354 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3355 qemu_bh_schedule(acb
->bh
);
3358 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3362 BlockDriverCompletionFunc
*cb
,
3367 BlockDriverAIOCBCoroutine
*acb
;
3369 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3370 acb
->req
.sector
= sector_num
;
3371 acb
->req
.nb_sectors
= nb_sectors
;
3372 acb
->req
.qiov
= qiov
;
3373 acb
->is_write
= is_write
;
3375 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3376 qemu_coroutine_enter(co
, acb
);
3378 return &acb
->common
;
3381 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3383 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3384 BlockDriverState
*bs
= acb
->common
.bs
;
3386 acb
->req
.error
= bdrv_co_flush(bs
);
3387 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3388 qemu_bh_schedule(acb
->bh
);
3391 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3392 BlockDriverCompletionFunc
*cb
, void *opaque
)
3394 trace_bdrv_aio_flush(bs
, opaque
);
3397 BlockDriverAIOCBCoroutine
*acb
;
3399 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3400 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3401 qemu_coroutine_enter(co
, acb
);
3403 return &acb
->common
;
3406 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3408 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3409 BlockDriverState
*bs
= acb
->common
.bs
;
3411 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3412 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3413 qemu_bh_schedule(acb
->bh
);
3416 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3417 int64_t sector_num
, int nb_sectors
,
3418 BlockDriverCompletionFunc
*cb
, void *opaque
)
3421 BlockDriverAIOCBCoroutine
*acb
;
3423 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3425 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3426 acb
->req
.sector
= sector_num
;
3427 acb
->req
.nb_sectors
= nb_sectors
;
3428 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3429 qemu_coroutine_enter(co
, acb
);
3431 return &acb
->common
;
3434 void bdrv_init(void)
3436 module_call_init(MODULE_INIT_BLOCK
);
3439 void bdrv_init_with_whitelist(void)
3441 use_bdrv_whitelist
= 1;
3445 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3446 BlockDriverCompletionFunc
*cb
, void *opaque
)
3448 BlockDriverAIOCB
*acb
;
3450 if (pool
->free_aiocb
) {
3451 acb
= pool
->free_aiocb
;
3452 pool
->free_aiocb
= acb
->next
;
3454 acb
= g_malloc0(pool
->aiocb_size
);
3459 acb
->opaque
= opaque
;
3463 void qemu_aio_release(void *p
)
3465 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3466 AIOPool
*pool
= acb
->pool
;
3467 acb
->next
= pool
->free_aiocb
;
3468 pool
->free_aiocb
= acb
;
3471 /**************************************************************/
3472 /* Coroutine block device emulation */
3474 typedef struct CoroutineIOCompletion
{
3475 Coroutine
*coroutine
;
3477 } CoroutineIOCompletion
;
3479 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3481 CoroutineIOCompletion
*co
= opaque
;
3484 qemu_coroutine_enter(co
->coroutine
, NULL
);
3487 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3488 int nb_sectors
, QEMUIOVector
*iov
,
3491 CoroutineIOCompletion co
= {
3492 .coroutine
= qemu_coroutine_self(),
3494 BlockDriverAIOCB
*acb
;
3497 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3498 bdrv_co_io_em_complete
, &co
);
3500 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3501 bdrv_co_io_em_complete
, &co
);
3504 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3508 qemu_coroutine_yield();
3513 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3514 int64_t sector_num
, int nb_sectors
,
3517 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3520 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3521 int64_t sector_num
, int nb_sectors
,
3524 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3527 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3529 RwCo
*rwco
= opaque
;
3531 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3534 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3538 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3542 /* Write back cached data to the OS even with cache=unsafe */
3543 if (bs
->drv
->bdrv_co_flush_to_os
) {
3544 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3550 /* But don't actually force it to the disk with cache=unsafe */
3551 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3555 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3556 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
3557 } else if (bs
->drv
->bdrv_aio_flush
) {
3558 BlockDriverAIOCB
*acb
;
3559 CoroutineIOCompletion co
= {
3560 .coroutine
= qemu_coroutine_self(),
3563 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
3567 qemu_coroutine_yield();
3572 * Some block drivers always operate in either writethrough or unsafe
3573 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3574 * know how the server works (because the behaviour is hardcoded or
3575 * depends on server-side configuration), so we can't ensure that
3576 * everything is safe on disk. Returning an error doesn't work because
3577 * that would break guests even if the server operates in writethrough
3580 * Let's hope the user knows what he's doing.
3588 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
3589 * in the case of cache=unsafe, so there are no useless flushes.
3591 return bdrv_co_flush(bs
->file
);
3594 void bdrv_invalidate_cache(BlockDriverState
*bs
)
3596 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
3597 bs
->drv
->bdrv_invalidate_cache(bs
);
3601 void bdrv_invalidate_cache_all(void)
3603 BlockDriverState
*bs
;
3605 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3606 bdrv_invalidate_cache(bs
);
3610 void bdrv_clear_incoming_migration_all(void)
3612 BlockDriverState
*bs
;
3614 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3615 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
3619 int bdrv_flush(BlockDriverState
*bs
)
3627 if (qemu_in_coroutine()) {
3628 /* Fast-path if already in coroutine context */
3629 bdrv_flush_co_entry(&rwco
);
3631 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
3632 qemu_coroutine_enter(co
, &rwco
);
3633 while (rwco
.ret
== NOT_DONE
) {
3641 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
3643 RwCo
*rwco
= opaque
;
3645 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
3648 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
3653 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
3655 } else if (bs
->read_only
) {
3657 } else if (bs
->drv
->bdrv_co_discard
) {
3658 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
3659 } else if (bs
->drv
->bdrv_aio_discard
) {
3660 BlockDriverAIOCB
*acb
;
3661 CoroutineIOCompletion co
= {
3662 .coroutine
= qemu_coroutine_self(),
3665 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
3666 bdrv_co_io_em_complete
, &co
);
3670 qemu_coroutine_yield();
3678 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
3683 .sector_num
= sector_num
,
3684 .nb_sectors
= nb_sectors
,
3688 if (qemu_in_coroutine()) {
3689 /* Fast-path if already in coroutine context */
3690 bdrv_discard_co_entry(&rwco
);
3692 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
3693 qemu_coroutine_enter(co
, &rwco
);
3694 while (rwco
.ret
== NOT_DONE
) {
3702 /**************************************************************/
3703 /* removable device support */
3706 * Return TRUE if the media is present
3708 int bdrv_is_inserted(BlockDriverState
*bs
)
3710 BlockDriver
*drv
= bs
->drv
;
3714 if (!drv
->bdrv_is_inserted
)
3716 return drv
->bdrv_is_inserted(bs
);
3720 * Return whether the media changed since the last call to this
3721 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3723 int bdrv_media_changed(BlockDriverState
*bs
)
3725 BlockDriver
*drv
= bs
->drv
;
3727 if (drv
&& drv
->bdrv_media_changed
) {
3728 return drv
->bdrv_media_changed(bs
);
3734 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3736 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3738 BlockDriver
*drv
= bs
->drv
;
3740 if (drv
&& drv
->bdrv_eject
) {
3741 drv
->bdrv_eject(bs
, eject_flag
);
3744 if (bs
->device_name
[0] != '\0') {
3745 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
3750 * Lock or unlock the media (if it is locked, the user won't be able
3751 * to eject it manually).
3753 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3755 BlockDriver
*drv
= bs
->drv
;
3757 trace_bdrv_lock_medium(bs
, locked
);
3759 if (drv
&& drv
->bdrv_lock_medium
) {
3760 drv
->bdrv_lock_medium(bs
, locked
);
3764 /* needed for generic scsi interface */
3766 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
3768 BlockDriver
*drv
= bs
->drv
;
3770 if (drv
&& drv
->bdrv_ioctl
)
3771 return drv
->bdrv_ioctl(bs
, req
, buf
);
3775 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
3776 unsigned long int req
, void *buf
,
3777 BlockDriverCompletionFunc
*cb
, void *opaque
)
3779 BlockDriver
*drv
= bs
->drv
;
3781 if (drv
&& drv
->bdrv_aio_ioctl
)
3782 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
3786 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
3788 bs
->buffer_alignment
= align
;
3791 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
3793 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
3796 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
3798 int64_t bitmap_size
;
3800 bs
->dirty_count
= 0;
3802 if (!bs
->dirty_bitmap
) {
3803 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
3804 BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
- 1;
3805 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
;
3807 bs
->dirty_bitmap
= g_new0(unsigned long, bitmap_size
);
3810 if (bs
->dirty_bitmap
) {
3811 g_free(bs
->dirty_bitmap
);
3812 bs
->dirty_bitmap
= NULL
;
3817 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
3819 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
3821 if (bs
->dirty_bitmap
&&
3822 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
3823 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
3824 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
3830 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3833 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
3836 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
3838 return bs
->dirty_count
;
3841 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
3843 assert(bs
->in_use
!= in_use
);
3844 bs
->in_use
= in_use
;
3847 int bdrv_in_use(BlockDriverState
*bs
)
3852 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3854 bs
->iostatus_enabled
= true;
3855 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3858 /* The I/O status is only enabled if the drive explicitly
3859 * enables it _and_ the VM is configured to stop on errors */
3860 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3862 return (bs
->iostatus_enabled
&&
3863 (bs
->on_write_error
== BLOCK_ERR_STOP_ENOSPC
||
3864 bs
->on_write_error
== BLOCK_ERR_STOP_ANY
||
3865 bs
->on_read_error
== BLOCK_ERR_STOP_ANY
));
3868 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3870 bs
->iostatus_enabled
= false;
3873 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3875 if (bdrv_iostatus_is_enabled(bs
)) {
3876 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3880 /* XXX: Today this is set by device models because it makes the implementation
3881 quite simple. However, the block layer knows about the error, so it's
3882 possible to implement this without device models being involved */
3883 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3885 if (bdrv_iostatus_is_enabled(bs
) &&
3886 bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3888 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3889 BLOCK_DEVICE_IO_STATUS_FAILED
;
3894 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
3895 enum BlockAcctType type
)
3897 assert(type
< BDRV_MAX_IOTYPE
);
3899 cookie
->bytes
= bytes
;
3900 cookie
->start_time_ns
= get_clock();
3901 cookie
->type
= type
;
3905 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
3907 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
3909 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
3910 bs
->nr_ops
[cookie
->type
]++;
3911 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
3914 int bdrv_img_create(const char *filename
, const char *fmt
,
3915 const char *base_filename
, const char *base_fmt
,
3916 char *options
, uint64_t img_size
, int flags
)
3918 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
3919 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
3920 BlockDriverState
*bs
= NULL
;
3921 BlockDriver
*drv
, *proto_drv
;
3922 BlockDriver
*backing_drv
= NULL
;
3925 /* Find driver and parse its options */
3926 drv
= bdrv_find_format(fmt
);
3928 error_report("Unknown file format '%s'", fmt
);
3933 proto_drv
= bdrv_find_protocol(filename
);
3935 error_report("Unknown protocol '%s'", filename
);
3940 create_options
= append_option_parameters(create_options
,
3941 drv
->create_options
);
3942 create_options
= append_option_parameters(create_options
,
3943 proto_drv
->create_options
);
3945 /* Create parameter list with default values */
3946 param
= parse_option_parameters("", create_options
, param
);
3948 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
3950 /* Parse -o options */
3952 param
= parse_option_parameters(options
, create_options
, param
);
3953 if (param
== NULL
) {
3954 error_report("Invalid options for file format '%s'.", fmt
);
3960 if (base_filename
) {
3961 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
3963 error_report("Backing file not supported for file format '%s'",
3971 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
3972 error_report("Backing file format not supported for file "
3973 "format '%s'", fmt
);
3979 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
3980 if (backing_file
&& backing_file
->value
.s
) {
3981 if (!strcmp(filename
, backing_file
->value
.s
)) {
3982 error_report("Error: Trying to create an image with the "
3983 "same filename as the backing file");
3989 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
3990 if (backing_fmt
&& backing_fmt
->value
.s
) {
3991 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
3993 error_report("Unknown backing file format '%s'",
3994 backing_fmt
->value
.s
);
4000 // The size for the image must always be specified, with one exception:
4001 // If we are using a backing file, we can obtain the size from there
4002 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4003 if (size
&& size
->value
.n
== -1) {
4004 if (backing_file
&& backing_file
->value
.s
) {
4009 /* backing files always opened read-only */
4011 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4015 ret
= bdrv_open(bs
, backing_file
->value
.s
, back_flags
, backing_drv
);
4017 error_report("Could not open '%s'", backing_file
->value
.s
);
4020 bdrv_get_geometry(bs
, &size
);
4023 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4024 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4026 error_report("Image creation needs a size parameter");
4032 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4033 print_option_parameters(param
);
4036 ret
= bdrv_create(drv
, filename
, param
);
4039 if (ret
== -ENOTSUP
) {
4040 error_report("Formatting or formatting option not supported for "
4041 "file format '%s'", fmt
);
4042 } else if (ret
== -EFBIG
) {
4043 error_report("The image size is too large for file format '%s'",
4046 error_report("%s: error while creating %s: %s", filename
, fmt
,
4052 free_option_parameters(create_options
);
4053 free_option_parameters(param
);
4062 void *block_job_create(const BlockJobType
*job_type
, BlockDriverState
*bs
,
4063 int64_t speed
, BlockDriverCompletionFunc
*cb
,
4064 void *opaque
, Error
**errp
)
4068 if (bs
->job
|| bdrv_in_use(bs
)) {
4069 error_set(errp
, QERR_DEVICE_IN_USE
, bdrv_get_device_name(bs
));
4072 bdrv_set_in_use(bs
, 1);
4074 job
= g_malloc0(job_type
->instance_size
);
4075 job
->job_type
= job_type
;
4078 job
->opaque
= opaque
;
4082 /* Only set speed when necessary to avoid NotSupported error */
4084 Error
*local_err
= NULL
;
4086 block_job_set_speed(job
, speed
, &local_err
);
4087 if (error_is_set(&local_err
)) {
4090 bdrv_set_in_use(bs
, 0);
4091 error_propagate(errp
, local_err
);
4098 void block_job_complete(BlockJob
*job
, int ret
)
4100 BlockDriverState
*bs
= job
->bs
;
4102 assert(bs
->job
== job
);
4103 job
->cb(job
->opaque
, ret
);
4106 bdrv_set_in_use(bs
, 0);
4109 void block_job_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
4111 Error
*local_err
= NULL
;
4113 if (!job
->job_type
->set_speed
) {
4114 error_set(errp
, QERR_NOT_SUPPORTED
);
4117 job
->job_type
->set_speed(job
, speed
, &local_err
);
4118 if (error_is_set(&local_err
)) {
4119 error_propagate(errp
, local_err
);
4126 void block_job_cancel(BlockJob
*job
)
4128 job
->cancelled
= true;
4129 if (job
->co
&& !job
->busy
) {
4130 qemu_coroutine_enter(job
->co
, NULL
);
4134 bool block_job_is_cancelled(BlockJob
*job
)
4136 return job
->cancelled
;
4139 struct BlockCancelData
{
4141 BlockDriverCompletionFunc
*cb
;
4147 static void block_job_cancel_cb(void *opaque
, int ret
)
4149 struct BlockCancelData
*data
= opaque
;
4151 data
->cancelled
= block_job_is_cancelled(data
->job
);
4153 data
->cb(data
->opaque
, ret
);
4156 int block_job_cancel_sync(BlockJob
*job
)
4158 struct BlockCancelData data
;
4159 BlockDriverState
*bs
= job
->bs
;
4161 assert(bs
->job
== job
);
4163 /* Set up our own callback to store the result and chain to
4164 * the original callback.
4168 data
.opaque
= job
->opaque
;
4169 data
.ret
= -EINPROGRESS
;
4170 job
->cb
= block_job_cancel_cb
;
4171 job
->opaque
= &data
;
4172 block_job_cancel(job
);
4173 while (data
.ret
== -EINPROGRESS
) {
4176 return (data
.cancelled
&& data
.ret
== 0) ? -ECANCELED
: data
.ret
;
4179 void block_job_sleep_ns(BlockJob
*job
, QEMUClock
*clock
, int64_t ns
)
4181 /* Check cancellation *before* setting busy = false, too! */
4182 if (!block_job_is_cancelled(job
)) {
4184 co_sleep_ns(clock
, ns
);