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
);
975 * Add new bs contents at the top of an image chain while the chain is
976 * live, while keeping required fields on the top layer.
978 * This will modify the BlockDriverState fields, and swap contents
979 * between bs_new and bs_top. Both bs_new and bs_top are modified.
981 * bs_new is required to be anonymous.
983 * This function does not create any image files.
985 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
987 BlockDriverState tmp
;
989 /* bs_new must be anonymous */
990 assert(bs_new
->device_name
[0] == '\0');
994 /* there are some fields that need to stay on the top layer: */
995 tmp
.open_flags
= bs_top
->open_flags
;
998 tmp
.dev_ops
= bs_top
->dev_ops
;
999 tmp
.dev_opaque
= bs_top
->dev_opaque
;
1000 tmp
.dev
= bs_top
->dev
;
1001 tmp
.buffer_alignment
= bs_top
->buffer_alignment
;
1002 tmp
.copy_on_read
= bs_top
->copy_on_read
;
1004 tmp
.enable_write_cache
= bs_top
->enable_write_cache
;
1006 /* i/o timing parameters */
1007 tmp
.slice_time
= bs_top
->slice_time
;
1008 tmp
.slice_start
= bs_top
->slice_start
;
1009 tmp
.slice_end
= bs_top
->slice_end
;
1010 tmp
.io_limits
= bs_top
->io_limits
;
1011 tmp
.io_base
= bs_top
->io_base
;
1012 tmp
.throttled_reqs
= bs_top
->throttled_reqs
;
1013 tmp
.block_timer
= bs_top
->block_timer
;
1014 tmp
.io_limits_enabled
= bs_top
->io_limits_enabled
;
1017 tmp
.cyls
= bs_top
->cyls
;
1018 tmp
.heads
= bs_top
->heads
;
1019 tmp
.secs
= bs_top
->secs
;
1020 tmp
.translation
= bs_top
->translation
;
1023 tmp
.on_read_error
= bs_top
->on_read_error
;
1024 tmp
.on_write_error
= bs_top
->on_write_error
;
1027 tmp
.iostatus_enabled
= bs_top
->iostatus_enabled
;
1028 tmp
.iostatus
= bs_top
->iostatus
;
1030 /* keep the same entry in bdrv_states */
1031 pstrcpy(tmp
.device_name
, sizeof(tmp
.device_name
), bs_top
->device_name
);
1032 tmp
.list
= bs_top
->list
;
1034 /* The contents of 'tmp' will become bs_top, as we are
1035 * swapping bs_new and bs_top contents. */
1036 tmp
.backing_hd
= bs_new
;
1037 pstrcpy(tmp
.backing_file
, sizeof(tmp
.backing_file
), bs_top
->filename
);
1038 bdrv_get_format(bs_top
, tmp
.backing_format
, sizeof(tmp
.backing_format
));
1040 /* swap contents of the fixed new bs and the current top */
1044 /* device_name[] was carried over from the old bs_top. bs_new
1045 * shouldn't be in bdrv_states, so we need to make device_name[]
1046 * reflect the anonymity of bs_new
1048 bs_new
->device_name
[0] = '\0';
1050 /* clear the copied fields in the new backing file */
1051 bdrv_detach_dev(bs_new
, bs_new
->dev
);
1053 qemu_co_queue_init(&bs_new
->throttled_reqs
);
1054 memset(&bs_new
->io_base
, 0, sizeof(bs_new
->io_base
));
1055 memset(&bs_new
->io_limits
, 0, sizeof(bs_new
->io_limits
));
1056 bdrv_iostatus_disable(bs_new
);
1058 /* we don't use bdrv_io_limits_disable() for this, because we don't want
1059 * to affect or delete the block_timer, as it has been moved to bs_top */
1060 bs_new
->io_limits_enabled
= false;
1061 bs_new
->block_timer
= NULL
;
1062 bs_new
->slice_time
= 0;
1063 bs_new
->slice_start
= 0;
1064 bs_new
->slice_end
= 0;
1066 bdrv_rebind(bs_new
);
1067 bdrv_rebind(bs_top
);
1070 void bdrv_delete(BlockDriverState
*bs
)
1074 assert(!bs
->in_use
);
1076 /* remove from list, if necessary */
1081 assert(bs
!= bs_snapshots
);
1085 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1086 /* TODO change to DeviceState *dev when all users are qdevified */
1092 bdrv_iostatus_reset(bs
);
1096 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1097 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1099 if (bdrv_attach_dev(bs
, dev
) < 0) {
1104 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1105 /* TODO change to DeviceState *dev when all users are qdevified */
1107 assert(bs
->dev
== dev
);
1110 bs
->dev_opaque
= NULL
;
1111 bs
->buffer_alignment
= 512;
1114 /* TODO change to return DeviceState * when all users are qdevified */
1115 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1120 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1124 bs
->dev_opaque
= opaque
;
1125 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1126 bs_snapshots
= NULL
;
1130 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1131 BlockQMPEventAction action
, int is_read
)
1134 const char *action_str
;
1137 case BDRV_ACTION_REPORT
:
1138 action_str
= "report";
1140 case BDRV_ACTION_IGNORE
:
1141 action_str
= "ignore";
1143 case BDRV_ACTION_STOP
:
1144 action_str
= "stop";
1150 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1153 is_read
? "read" : "write");
1154 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR
, data
);
1156 qobject_decref(data
);
1159 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1163 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1164 bdrv_get_device_name(bs
), ejected
);
1165 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1167 qobject_decref(data
);
1170 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1172 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1173 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1174 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1175 if (tray_was_closed
) {
1177 bdrv_emit_qmp_eject_event(bs
, true);
1181 bdrv_emit_qmp_eject_event(bs
, false);
1186 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1188 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1191 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1193 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1194 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1198 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1200 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1201 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1206 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1208 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1209 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1213 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1215 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1216 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1222 * Run consistency checks on an image
1224 * Returns 0 if the check could be completed (it doesn't mean that the image is
1225 * free of errors) or -errno when an internal error occurred. The results of the
1226 * check are stored in res.
1228 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1230 if (bs
->drv
->bdrv_check
== NULL
) {
1234 memset(res
, 0, sizeof(*res
));
1235 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1238 #define COMMIT_BUF_SECTORS 2048
1240 /* commit COW file into the raw image */
1241 int bdrv_commit(BlockDriverState
*bs
)
1243 BlockDriver
*drv
= bs
->drv
;
1244 BlockDriver
*backing_drv
;
1245 int64_t sector
, total_sectors
;
1246 int n
, ro
, open_flags
;
1247 int ret
= 0, rw_ret
= 0;
1249 char filename
[1024];
1250 BlockDriverState
*bs_rw
, *bs_ro
;
1255 if (!bs
->backing_hd
) {
1259 if (bs
->backing_hd
->keep_read_only
) {
1263 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1267 backing_drv
= bs
->backing_hd
->drv
;
1268 ro
= bs
->backing_hd
->read_only
;
1269 strncpy(filename
, bs
->backing_hd
->filename
, sizeof(filename
));
1270 open_flags
= bs
->backing_hd
->open_flags
;
1274 bdrv_delete(bs
->backing_hd
);
1275 bs
->backing_hd
= NULL
;
1276 bs_rw
= bdrv_new("");
1277 rw_ret
= bdrv_open(bs_rw
, filename
, open_flags
| BDRV_O_RDWR
,
1281 /* try to re-open read-only */
1282 bs_ro
= bdrv_new("");
1283 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1287 /* drive not functional anymore */
1291 bs
->backing_hd
= bs_ro
;
1294 bs
->backing_hd
= bs_rw
;
1297 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1298 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1300 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1301 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1303 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1308 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1315 if (drv
->bdrv_make_empty
) {
1316 ret
= drv
->bdrv_make_empty(bs
);
1321 * Make sure all data we wrote to the backing device is actually
1325 bdrv_flush(bs
->backing_hd
);
1332 bdrv_delete(bs
->backing_hd
);
1333 bs
->backing_hd
= NULL
;
1334 bs_ro
= bdrv_new("");
1335 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1339 /* drive not functional anymore */
1343 bs
->backing_hd
= bs_ro
;
1344 bs
->backing_hd
->keep_read_only
= 0;
1350 int bdrv_commit_all(void)
1352 BlockDriverState
*bs
;
1354 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1355 int ret
= bdrv_commit(bs
);
1363 struct BdrvTrackedRequest
{
1364 BlockDriverState
*bs
;
1368 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1369 Coroutine
*co
; /* owner, used for deadlock detection */
1370 CoQueue wait_queue
; /* coroutines blocked on this request */
1374 * Remove an active request from the tracked requests list
1376 * This function should be called when a tracked request is completing.
1378 static void tracked_request_end(BdrvTrackedRequest
*req
)
1380 QLIST_REMOVE(req
, list
);
1381 qemu_co_queue_restart_all(&req
->wait_queue
);
1385 * Add an active request to the tracked requests list
1387 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1388 BlockDriverState
*bs
,
1390 int nb_sectors
, bool is_write
)
1392 *req
= (BdrvTrackedRequest
){
1394 .sector_num
= sector_num
,
1395 .nb_sectors
= nb_sectors
,
1396 .is_write
= is_write
,
1397 .co
= qemu_coroutine_self(),
1400 qemu_co_queue_init(&req
->wait_queue
);
1402 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1406 * Round a region to cluster boundaries
1408 static void round_to_clusters(BlockDriverState
*bs
,
1409 int64_t sector_num
, int nb_sectors
,
1410 int64_t *cluster_sector_num
,
1411 int *cluster_nb_sectors
)
1413 BlockDriverInfo bdi
;
1415 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1416 *cluster_sector_num
= sector_num
;
1417 *cluster_nb_sectors
= nb_sectors
;
1419 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1420 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1421 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1426 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1427 int64_t sector_num
, int nb_sectors
) {
1429 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1433 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1439 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1440 int64_t sector_num
, int nb_sectors
)
1442 BdrvTrackedRequest
*req
;
1443 int64_t cluster_sector_num
;
1444 int cluster_nb_sectors
;
1447 /* If we touch the same cluster it counts as an overlap. This guarantees
1448 * that allocating writes will be serialized and not race with each other
1449 * for the same cluster. For example, in copy-on-read it ensures that the
1450 * CoR read and write operations are atomic and guest writes cannot
1451 * interleave between them.
1453 round_to_clusters(bs
, sector_num
, nb_sectors
,
1454 &cluster_sector_num
, &cluster_nb_sectors
);
1458 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1459 if (tracked_request_overlaps(req
, cluster_sector_num
,
1460 cluster_nb_sectors
)) {
1461 /* Hitting this means there was a reentrant request, for
1462 * example, a block driver issuing nested requests. This must
1463 * never happen since it means deadlock.
1465 assert(qemu_coroutine_self() != req
->co
);
1467 qemu_co_queue_wait(&req
->wait_queue
);
1478 * -EINVAL - backing format specified, but no file
1479 * -ENOSPC - can't update the backing file because no space is left in the
1481 * -ENOTSUP - format driver doesn't support changing the backing file
1483 int bdrv_change_backing_file(BlockDriverState
*bs
,
1484 const char *backing_file
, const char *backing_fmt
)
1486 BlockDriver
*drv
= bs
->drv
;
1489 /* Backing file format doesn't make sense without a backing file */
1490 if (backing_fmt
&& !backing_file
) {
1494 if (drv
->bdrv_change_backing_file
!= NULL
) {
1495 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1501 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1502 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1507 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1512 if (!bdrv_is_inserted(bs
))
1518 len
= bdrv_getlength(bs
);
1523 if ((offset
> len
) || (len
- offset
< size
))
1529 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1532 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1533 nb_sectors
* BDRV_SECTOR_SIZE
);
1536 typedef struct RwCo
{
1537 BlockDriverState
*bs
;
1545 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1547 RwCo
*rwco
= opaque
;
1549 if (!rwco
->is_write
) {
1550 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1551 rwco
->nb_sectors
, rwco
->qiov
, 0);
1553 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1554 rwco
->nb_sectors
, rwco
->qiov
, 0);
1559 * Process a synchronous request using coroutines
1561 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1562 int nb_sectors
, bool is_write
)
1565 struct iovec iov
= {
1566 .iov_base
= (void *)buf
,
1567 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1572 .sector_num
= sector_num
,
1573 .nb_sectors
= nb_sectors
,
1575 .is_write
= is_write
,
1579 qemu_iovec_init_external(&qiov
, &iov
, 1);
1582 * In sync call context, when the vcpu is blocked, this throttling timer
1583 * will not fire; so the I/O throttling function has to be disabled here
1584 * if it has been enabled.
1586 if (bs
->io_limits_enabled
) {
1587 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
1588 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
1589 bdrv_io_limits_disable(bs
);
1592 if (qemu_in_coroutine()) {
1593 /* Fast-path if already in coroutine context */
1594 bdrv_rw_co_entry(&rwco
);
1596 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1597 qemu_coroutine_enter(co
, &rwco
);
1598 while (rwco
.ret
== NOT_DONE
) {
1605 /* return < 0 if error. See bdrv_write() for the return codes */
1606 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1607 uint8_t *buf
, int nb_sectors
)
1609 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1612 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
1614 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1615 int nb_sectors
, int dirty
)
1618 unsigned long val
, idx
, bit
;
1620 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
1621 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
1623 for (; start
<= end
; start
++) {
1624 idx
= start
/ BITS_PER_LONG
;
1625 bit
= start
% BITS_PER_LONG
;
1626 val
= bs
->dirty_bitmap
[idx
];
1628 if (!(val
& (1UL << bit
))) {
1633 if (val
& (1UL << bit
)) {
1635 val
&= ~(1UL << bit
);
1638 bs
->dirty_bitmap
[idx
] = val
;
1642 /* Return < 0 if error. Important errors are:
1643 -EIO generic I/O error (may happen for all errors)
1644 -ENOMEDIUM No media inserted.
1645 -EINVAL Invalid sector number or nb_sectors
1646 -EACCES Trying to write a read-only device
1648 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
1649 const uint8_t *buf
, int nb_sectors
)
1651 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
1654 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
1655 void *buf
, int count1
)
1657 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1658 int len
, nb_sectors
, count
;
1663 /* first read to align to sector start */
1664 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1667 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1669 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1671 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
1679 /* read the sectors "in place" */
1680 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1681 if (nb_sectors
> 0) {
1682 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1684 sector_num
+= nb_sectors
;
1685 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1690 /* add data from the last sector */
1692 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1694 memcpy(buf
, tmp_buf
, count
);
1699 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
1700 const void *buf
, int count1
)
1702 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1703 int len
, nb_sectors
, count
;
1708 /* first write to align to sector start */
1709 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1712 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1714 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1716 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
1717 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1726 /* write the sectors "in place" */
1727 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1728 if (nb_sectors
> 0) {
1729 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1731 sector_num
+= nb_sectors
;
1732 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1737 /* add data from the last sector */
1739 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1741 memcpy(tmp_buf
, buf
, count
);
1742 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1749 * Writes to the file and ensures that no writes are reordered across this
1750 * request (acts as a barrier)
1752 * Returns 0 on success, -errno in error cases.
1754 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
1755 const void *buf
, int count
)
1759 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
1764 /* No flush needed for cache modes that already do it */
1765 if (bs
->enable_write_cache
) {
1772 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
1773 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1775 /* Perform I/O through a temporary buffer so that users who scribble over
1776 * their read buffer while the operation is in progress do not end up
1777 * modifying the image file. This is critical for zero-copy guest I/O
1778 * where anything might happen inside guest memory.
1780 void *bounce_buffer
;
1782 BlockDriver
*drv
= bs
->drv
;
1784 QEMUIOVector bounce_qiov
;
1785 int64_t cluster_sector_num
;
1786 int cluster_nb_sectors
;
1790 /* Cover entire cluster so no additional backing file I/O is required when
1791 * allocating cluster in the image file.
1793 round_to_clusters(bs
, sector_num
, nb_sectors
,
1794 &cluster_sector_num
, &cluster_nb_sectors
);
1796 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
1797 cluster_sector_num
, cluster_nb_sectors
);
1799 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
1800 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
1801 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
1803 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
1809 if (drv
->bdrv_co_write_zeroes
&&
1810 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
1811 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
1812 cluster_nb_sectors
);
1814 /* This does not change the data on the disk, it is not necessary
1815 * to flush even in cache=writethrough mode.
1817 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
1822 /* It might be okay to ignore write errors for guest requests. If this
1823 * is a deliberate copy-on-read then we don't want to ignore the error.
1824 * Simply report it in all cases.
1829 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
1830 qemu_iovec_from_buffer(qiov
, bounce_buffer
+ skip_bytes
,
1831 nb_sectors
* BDRV_SECTOR_SIZE
);
1834 qemu_vfree(bounce_buffer
);
1839 * Handle a read request in coroutine context
1841 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
1842 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1843 BdrvRequestFlags flags
)
1845 BlockDriver
*drv
= bs
->drv
;
1846 BdrvTrackedRequest req
;
1852 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1856 /* throttling disk read I/O */
1857 if (bs
->io_limits_enabled
) {
1858 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
1861 if (bs
->copy_on_read
) {
1862 flags
|= BDRV_REQ_COPY_ON_READ
;
1864 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1865 bs
->copy_on_read_in_flight
++;
1868 if (bs
->copy_on_read_in_flight
) {
1869 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1872 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
1874 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1877 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
1882 if (!ret
|| pnum
!= nb_sectors
) {
1883 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
1888 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
1891 tracked_request_end(&req
);
1893 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1894 bs
->copy_on_read_in_flight
--;
1900 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1901 int nb_sectors
, QEMUIOVector
*qiov
)
1903 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
1905 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
1908 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
1909 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1911 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
1913 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
1914 BDRV_REQ_COPY_ON_READ
);
1917 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
1918 int64_t sector_num
, int nb_sectors
)
1920 BlockDriver
*drv
= bs
->drv
;
1925 /* TODO Emulate only part of misaligned requests instead of letting block
1926 * drivers return -ENOTSUP and emulate everything */
1928 /* First try the efficient write zeroes operation */
1929 if (drv
->bdrv_co_write_zeroes
) {
1930 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1931 if (ret
!= -ENOTSUP
) {
1936 /* Fall back to bounce buffer if write zeroes is unsupported */
1937 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
1938 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
1939 memset(iov
.iov_base
, 0, iov
.iov_len
);
1940 qemu_iovec_init_external(&qiov
, &iov
, 1);
1942 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
1944 qemu_vfree(iov
.iov_base
);
1949 * Handle a write request in coroutine context
1951 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
1952 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1953 BdrvRequestFlags flags
)
1955 BlockDriver
*drv
= bs
->drv
;
1956 BdrvTrackedRequest req
;
1962 if (bs
->read_only
) {
1965 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1969 /* throttling disk write I/O */
1970 if (bs
->io_limits_enabled
) {
1971 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
1974 if (bs
->copy_on_read_in_flight
) {
1975 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1978 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
1980 if (flags
& BDRV_REQ_ZERO_WRITE
) {
1981 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
1983 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
1986 if (ret
== 0 && !bs
->enable_write_cache
) {
1987 ret
= bdrv_co_flush(bs
);
1990 if (bs
->dirty_bitmap
) {
1991 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
1994 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
1995 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
1998 tracked_request_end(&req
);
2003 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2004 int nb_sectors
, QEMUIOVector
*qiov
)
2006 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2008 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2011 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2012 int64_t sector_num
, int nb_sectors
)
2014 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2016 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2017 BDRV_REQ_ZERO_WRITE
);
2021 * Truncate file to 'offset' bytes (needed only for file protocols)
2023 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2025 BlockDriver
*drv
= bs
->drv
;
2029 if (!drv
->bdrv_truncate
)
2033 if (bdrv_in_use(bs
))
2035 ret
= drv
->bdrv_truncate(bs
, offset
);
2037 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2038 bdrv_dev_resize_cb(bs
);
2044 * Length of a allocated file in bytes. Sparse files are counted by actual
2045 * allocated space. Return < 0 if error or unknown.
2047 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2049 BlockDriver
*drv
= bs
->drv
;
2053 if (drv
->bdrv_get_allocated_file_size
) {
2054 return drv
->bdrv_get_allocated_file_size(bs
);
2057 return bdrv_get_allocated_file_size(bs
->file
);
2063 * Length of a file in bytes. Return < 0 if error or unknown.
2065 int64_t bdrv_getlength(BlockDriverState
*bs
)
2067 BlockDriver
*drv
= bs
->drv
;
2071 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2072 if (drv
->bdrv_getlength
) {
2073 return drv
->bdrv_getlength(bs
);
2076 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2079 /* return 0 as number of sectors if no device present or error */
2080 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2083 length
= bdrv_getlength(bs
);
2087 length
= length
>> BDRV_SECTOR_BITS
;
2088 *nb_sectors_ptr
= length
;
2092 uint8_t boot_ind
; /* 0x80 - active */
2093 uint8_t head
; /* starting head */
2094 uint8_t sector
; /* starting sector */
2095 uint8_t cyl
; /* starting cylinder */
2096 uint8_t sys_ind
; /* What partition type */
2097 uint8_t end_head
; /* end head */
2098 uint8_t end_sector
; /* end sector */
2099 uint8_t end_cyl
; /* end cylinder */
2100 uint32_t start_sect
; /* starting sector counting from 0 */
2101 uint32_t nr_sects
; /* nr of sectors in partition */
2104 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
2105 static int guess_disk_lchs(BlockDriverState
*bs
,
2106 int *pcylinders
, int *pheads
, int *psectors
)
2108 uint8_t buf
[BDRV_SECTOR_SIZE
];
2109 int ret
, i
, heads
, sectors
, cylinders
;
2110 struct partition
*p
;
2112 uint64_t nb_sectors
;
2115 bdrv_get_geometry(bs
, &nb_sectors
);
2118 * The function will be invoked during startup not only in sync I/O mode,
2119 * but also in async I/O mode. So the I/O throttling function has to
2120 * be disabled temporarily here, not permanently.
2122 enabled
= bs
->io_limits_enabled
;
2123 bs
->io_limits_enabled
= false;
2124 ret
= bdrv_read(bs
, 0, buf
, 1);
2125 bs
->io_limits_enabled
= enabled
;
2128 /* test msdos magic */
2129 if (buf
[510] != 0x55 || buf
[511] != 0xaa)
2131 for(i
= 0; i
< 4; i
++) {
2132 p
= ((struct partition
*)(buf
+ 0x1be)) + i
;
2133 nr_sects
= le32_to_cpu(p
->nr_sects
);
2134 if (nr_sects
&& p
->end_head
) {
2135 /* We make the assumption that the partition terminates on
2136 a cylinder boundary */
2137 heads
= p
->end_head
+ 1;
2138 sectors
= p
->end_sector
& 63;
2141 cylinders
= nb_sectors
/ (heads
* sectors
);
2142 if (cylinders
< 1 || cylinders
> 16383)
2145 *psectors
= sectors
;
2146 *pcylinders
= cylinders
;
2148 printf("guessed geometry: LCHS=%d %d %d\n",
2149 cylinders
, heads
, sectors
);
2157 void bdrv_guess_geometry(BlockDriverState
*bs
, int *pcyls
, int *pheads
, int *psecs
)
2159 int translation
, lba_detected
= 0;
2160 int cylinders
, heads
, secs
;
2161 uint64_t nb_sectors
;
2163 /* if a geometry hint is available, use it */
2164 bdrv_get_geometry(bs
, &nb_sectors
);
2165 bdrv_get_geometry_hint(bs
, &cylinders
, &heads
, &secs
);
2166 translation
= bdrv_get_translation_hint(bs
);
2167 if (cylinders
!= 0) {
2172 if (guess_disk_lchs(bs
, &cylinders
, &heads
, &secs
) == 0) {
2174 /* if heads > 16, it means that a BIOS LBA
2175 translation was active, so the default
2176 hardware geometry is OK */
2178 goto default_geometry
;
2183 /* disable any translation to be in sync with
2184 the logical geometry */
2185 if (translation
== BIOS_ATA_TRANSLATION_AUTO
) {
2186 bdrv_set_translation_hint(bs
,
2187 BIOS_ATA_TRANSLATION_NONE
);
2192 /* if no geometry, use a standard physical disk geometry */
2193 cylinders
= nb_sectors
/ (16 * 63);
2195 if (cylinders
> 16383)
2197 else if (cylinders
< 2)
2202 if ((lba_detected
== 1) && (translation
== BIOS_ATA_TRANSLATION_AUTO
)) {
2203 if ((*pcyls
* *pheads
) <= 131072) {
2204 bdrv_set_translation_hint(bs
,
2205 BIOS_ATA_TRANSLATION_LARGE
);
2207 bdrv_set_translation_hint(bs
,
2208 BIOS_ATA_TRANSLATION_LBA
);
2212 bdrv_set_geometry_hint(bs
, *pcyls
, *pheads
, *psecs
);
2216 void bdrv_set_geometry_hint(BlockDriverState
*bs
,
2217 int cyls
, int heads
, int secs
)
2224 void bdrv_set_translation_hint(BlockDriverState
*bs
, int translation
)
2226 bs
->translation
= translation
;
2229 void bdrv_get_geometry_hint(BlockDriverState
*bs
,
2230 int *pcyls
, int *pheads
, int *psecs
)
2233 *pheads
= bs
->heads
;
2237 /* throttling disk io limits */
2238 void bdrv_set_io_limits(BlockDriverState
*bs
,
2239 BlockIOLimit
*io_limits
)
2241 bs
->io_limits
= *io_limits
;
2242 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2245 /* Recognize floppy formats */
2246 typedef struct FDFormat
{
2254 static const FDFormat fd_formats
[] = {
2255 /* First entry is default format */
2256 /* 1.44 MB 3"1/2 floppy disks */
2257 { FDRIVE_DRV_144
, 18, 80, 1, FDRIVE_RATE_500K
, },
2258 { FDRIVE_DRV_144
, 20, 80, 1, FDRIVE_RATE_500K
, },
2259 { FDRIVE_DRV_144
, 21, 80, 1, FDRIVE_RATE_500K
, },
2260 { FDRIVE_DRV_144
, 21, 82, 1, FDRIVE_RATE_500K
, },
2261 { FDRIVE_DRV_144
, 21, 83, 1, FDRIVE_RATE_500K
, },
2262 { FDRIVE_DRV_144
, 22, 80, 1, FDRIVE_RATE_500K
, },
2263 { FDRIVE_DRV_144
, 23, 80, 1, FDRIVE_RATE_500K
, },
2264 { FDRIVE_DRV_144
, 24, 80, 1, FDRIVE_RATE_500K
, },
2265 /* 2.88 MB 3"1/2 floppy disks */
2266 { FDRIVE_DRV_288
, 36, 80, 1, FDRIVE_RATE_1M
, },
2267 { FDRIVE_DRV_288
, 39, 80, 1, FDRIVE_RATE_1M
, },
2268 { FDRIVE_DRV_288
, 40, 80, 1, FDRIVE_RATE_1M
, },
2269 { FDRIVE_DRV_288
, 44, 80, 1, FDRIVE_RATE_1M
, },
2270 { FDRIVE_DRV_288
, 48, 80, 1, FDRIVE_RATE_1M
, },
2271 /* 720 kB 3"1/2 floppy disks */
2272 { FDRIVE_DRV_144
, 9, 80, 1, FDRIVE_RATE_250K
, },
2273 { FDRIVE_DRV_144
, 10, 80, 1, FDRIVE_RATE_250K
, },
2274 { FDRIVE_DRV_144
, 10, 82, 1, FDRIVE_RATE_250K
, },
2275 { FDRIVE_DRV_144
, 10, 83, 1, FDRIVE_RATE_250K
, },
2276 { FDRIVE_DRV_144
, 13, 80, 1, FDRIVE_RATE_250K
, },
2277 { FDRIVE_DRV_144
, 14, 80, 1, FDRIVE_RATE_250K
, },
2278 /* 1.2 MB 5"1/4 floppy disks */
2279 { FDRIVE_DRV_120
, 15, 80, 1, FDRIVE_RATE_500K
, },
2280 { FDRIVE_DRV_120
, 18, 80, 1, FDRIVE_RATE_500K
, },
2281 { FDRIVE_DRV_120
, 18, 82, 1, FDRIVE_RATE_500K
, },
2282 { FDRIVE_DRV_120
, 18, 83, 1, FDRIVE_RATE_500K
, },
2283 { FDRIVE_DRV_120
, 20, 80, 1, FDRIVE_RATE_500K
, },
2284 /* 720 kB 5"1/4 floppy disks */
2285 { FDRIVE_DRV_120
, 9, 80, 1, FDRIVE_RATE_250K
, },
2286 { FDRIVE_DRV_120
, 11, 80, 1, FDRIVE_RATE_250K
, },
2287 /* 360 kB 5"1/4 floppy disks */
2288 { FDRIVE_DRV_120
, 9, 40, 1, FDRIVE_RATE_300K
, },
2289 { FDRIVE_DRV_120
, 9, 40, 0, FDRIVE_RATE_300K
, },
2290 { FDRIVE_DRV_120
, 10, 41, 1, FDRIVE_RATE_300K
, },
2291 { FDRIVE_DRV_120
, 10, 42, 1, FDRIVE_RATE_300K
, },
2292 /* 320 kB 5"1/4 floppy disks */
2293 { FDRIVE_DRV_120
, 8, 40, 1, FDRIVE_RATE_250K
, },
2294 { FDRIVE_DRV_120
, 8, 40, 0, FDRIVE_RATE_250K
, },
2295 /* 360 kB must match 5"1/4 better than 3"1/2... */
2296 { FDRIVE_DRV_144
, 9, 80, 0, FDRIVE_RATE_250K
, },
2298 { FDRIVE_DRV_NONE
, -1, -1, 0, 0, },
2301 void bdrv_get_floppy_geometry_hint(BlockDriverState
*bs
, int *nb_heads
,
2302 int *max_track
, int *last_sect
,
2303 FDriveType drive_in
, FDriveType
*drive
,
2306 const FDFormat
*parse
;
2307 uint64_t nb_sectors
, size
;
2308 int i
, first_match
, match
;
2310 bdrv_get_geometry_hint(bs
, nb_heads
, max_track
, last_sect
);
2311 if (*nb_heads
!= 0 && *max_track
!= 0 && *last_sect
!= 0) {
2312 /* User defined disk */
2313 *rate
= FDRIVE_RATE_500K
;
2315 bdrv_get_geometry(bs
, &nb_sectors
);
2318 for (i
= 0; ; i
++) {
2319 parse
= &fd_formats
[i
];
2320 if (parse
->drive
== FDRIVE_DRV_NONE
) {
2323 if (drive_in
== parse
->drive
||
2324 drive_in
== FDRIVE_DRV_NONE
) {
2325 size
= (parse
->max_head
+ 1) * parse
->max_track
*
2327 if (nb_sectors
== size
) {
2331 if (first_match
== -1) {
2337 if (first_match
== -1) {
2340 match
= first_match
;
2342 parse
= &fd_formats
[match
];
2344 *nb_heads
= parse
->max_head
+ 1;
2345 *max_track
= parse
->max_track
;
2346 *last_sect
= parse
->last_sect
;
2347 *drive
= parse
->drive
;
2348 *rate
= parse
->rate
;
2352 int bdrv_get_translation_hint(BlockDriverState
*bs
)
2354 return bs
->translation
;
2357 void bdrv_set_on_error(BlockDriverState
*bs
, BlockErrorAction on_read_error
,
2358 BlockErrorAction on_write_error
)
2360 bs
->on_read_error
= on_read_error
;
2361 bs
->on_write_error
= on_write_error
;
2364 BlockErrorAction
bdrv_get_on_error(BlockDriverState
*bs
, int is_read
)
2366 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2369 int bdrv_is_read_only(BlockDriverState
*bs
)
2371 return bs
->read_only
;
2374 int bdrv_is_sg(BlockDriverState
*bs
)
2379 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2381 return bs
->enable_write_cache
;
2384 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2386 bs
->enable_write_cache
= wce
;
2389 int bdrv_is_encrypted(BlockDriverState
*bs
)
2391 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2393 return bs
->encrypted
;
2396 int bdrv_key_required(BlockDriverState
*bs
)
2398 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2400 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2402 return (bs
->encrypted
&& !bs
->valid_key
);
2405 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2408 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2409 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2415 if (!bs
->encrypted
) {
2417 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2420 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2423 } else if (!bs
->valid_key
) {
2425 /* call the change callback now, we skipped it on open */
2426 bdrv_dev_change_media_cb(bs
, true);
2431 void bdrv_get_format(BlockDriverState
*bs
, char *buf
, int buf_size
)
2436 pstrcpy(buf
, buf_size
, bs
->drv
->format_name
);
2440 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2445 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2446 it(opaque
, drv
->format_name
);
2450 BlockDriverState
*bdrv_find(const char *name
)
2452 BlockDriverState
*bs
;
2454 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2455 if (!strcmp(name
, bs
->device_name
)) {
2462 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2465 return QTAILQ_FIRST(&bdrv_states
);
2467 return QTAILQ_NEXT(bs
, list
);
2470 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2472 BlockDriverState
*bs
;
2474 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2479 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2481 return bs
->device_name
;
2484 int bdrv_get_flags(BlockDriverState
*bs
)
2486 return bs
->open_flags
;
2489 void bdrv_flush_all(void)
2491 BlockDriverState
*bs
;
2493 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2498 int bdrv_has_zero_init(BlockDriverState
*bs
)
2502 if (bs
->drv
->bdrv_has_zero_init
) {
2503 return bs
->drv
->bdrv_has_zero_init(bs
);
2509 typedef struct BdrvCoIsAllocatedData
{
2510 BlockDriverState
*bs
;
2516 } BdrvCoIsAllocatedData
;
2519 * Returns true iff the specified sector is present in the disk image. Drivers
2520 * not implementing the functionality are assumed to not support backing files,
2521 * hence all their sectors are reported as allocated.
2523 * If 'sector_num' is beyond the end of the disk image the return value is 0
2524 * and 'pnum' is set to 0.
2526 * 'pnum' is set to the number of sectors (including and immediately following
2527 * the specified sector) that are known to be in the same
2528 * allocated/unallocated state.
2530 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2531 * beyond the end of the disk image it will be clamped.
2533 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2534 int nb_sectors
, int *pnum
)
2538 if (sector_num
>= bs
->total_sectors
) {
2543 n
= bs
->total_sectors
- sector_num
;
2544 if (n
< nb_sectors
) {
2548 if (!bs
->drv
->bdrv_co_is_allocated
) {
2553 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2556 /* Coroutine wrapper for bdrv_is_allocated() */
2557 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2559 BdrvCoIsAllocatedData
*data
= opaque
;
2560 BlockDriverState
*bs
= data
->bs
;
2562 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2568 * Synchronous wrapper around bdrv_co_is_allocated().
2570 * See bdrv_co_is_allocated() for details.
2572 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2576 BdrvCoIsAllocatedData data
= {
2578 .sector_num
= sector_num
,
2579 .nb_sectors
= nb_sectors
,
2584 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2585 qemu_coroutine_enter(co
, &data
);
2586 while (!data
.done
) {
2593 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2595 * Return true if the given sector is allocated in any image between
2596 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2597 * sector is allocated in any image of the chain. Return false otherwise.
2599 * 'pnum' is set to the number of sectors (including and immediately following
2600 * the specified sector) that are known to be in the same
2601 * allocated/unallocated state.
2604 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2605 BlockDriverState
*base
,
2607 int nb_sectors
, int *pnum
)
2609 BlockDriverState
*intermediate
;
2610 int ret
, n
= nb_sectors
;
2613 while (intermediate
&& intermediate
!= base
) {
2615 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2625 * [sector_num, nb_sectors] is unallocated on top but intermediate
2628 * [sector_num+x, nr_sectors] allocated.
2630 if (n
> pnum_inter
) {
2634 intermediate
= intermediate
->backing_hd
;
2641 BlockInfoList
*qmp_query_block(Error
**errp
)
2643 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2644 BlockDriverState
*bs
;
2646 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2647 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2649 info
->value
= g_malloc0(sizeof(*info
->value
));
2650 info
->value
->device
= g_strdup(bs
->device_name
);
2651 info
->value
->type
= g_strdup("unknown");
2652 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2653 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2655 if (bdrv_dev_has_removable_media(bs
)) {
2656 info
->value
->has_tray_open
= true;
2657 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2660 if (bdrv_iostatus_is_enabled(bs
)) {
2661 info
->value
->has_io_status
= true;
2662 info
->value
->io_status
= bs
->iostatus
;
2666 info
->value
->has_inserted
= true;
2667 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2668 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2669 info
->value
->inserted
->ro
= bs
->read_only
;
2670 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2671 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2672 if (bs
->backing_file
[0]) {
2673 info
->value
->inserted
->has_backing_file
= true;
2674 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2677 if (bs
->io_limits_enabled
) {
2678 info
->value
->inserted
->bps
=
2679 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2680 info
->value
->inserted
->bps_rd
=
2681 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2682 info
->value
->inserted
->bps_wr
=
2683 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2684 info
->value
->inserted
->iops
=
2685 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2686 info
->value
->inserted
->iops_rd
=
2687 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2688 info
->value
->inserted
->iops_wr
=
2689 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2693 /* XXX: waiting for the qapi to support GSList */
2695 head
= cur_item
= info
;
2697 cur_item
->next
= info
;
2705 /* Consider exposing this as a full fledged QMP command */
2706 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2710 s
= g_malloc0(sizeof(*s
));
2712 if (bs
->device_name
[0]) {
2713 s
->has_device
= true;
2714 s
->device
= g_strdup(bs
->device_name
);
2717 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2718 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2719 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2720 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2721 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2722 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2723 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2724 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2725 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2726 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2729 s
->has_parent
= true;
2730 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2736 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2738 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2739 BlockDriverState
*bs
;
2741 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2742 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2743 info
->value
= qmp_query_blockstat(bs
, NULL
);
2745 /* XXX: waiting for the qapi to support GSList */
2747 head
= cur_item
= info
;
2749 cur_item
->next
= info
;
2757 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2759 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2760 return bs
->backing_file
;
2761 else if (bs
->encrypted
)
2762 return bs
->filename
;
2767 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2768 char *filename
, int filename_size
)
2770 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2773 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2774 const uint8_t *buf
, int nb_sectors
)
2776 BlockDriver
*drv
= bs
->drv
;
2779 if (!drv
->bdrv_write_compressed
)
2781 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2784 if (bs
->dirty_bitmap
) {
2785 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2788 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2791 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2793 BlockDriver
*drv
= bs
->drv
;
2796 if (!drv
->bdrv_get_info
)
2798 memset(bdi
, 0, sizeof(*bdi
));
2799 return drv
->bdrv_get_info(bs
, bdi
);
2802 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2803 int64_t pos
, int size
)
2805 BlockDriver
*drv
= bs
->drv
;
2808 if (drv
->bdrv_save_vmstate
)
2809 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2811 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2815 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2816 int64_t pos
, int size
)
2818 BlockDriver
*drv
= bs
->drv
;
2821 if (drv
->bdrv_load_vmstate
)
2822 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2824 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2828 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2830 BlockDriver
*drv
= bs
->drv
;
2832 if (!drv
|| !drv
->bdrv_debug_event
) {
2836 return drv
->bdrv_debug_event(bs
, event
);
2840 /**************************************************************/
2841 /* handling of snapshots */
2843 int bdrv_can_snapshot(BlockDriverState
*bs
)
2845 BlockDriver
*drv
= bs
->drv
;
2846 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
2850 if (!drv
->bdrv_snapshot_create
) {
2851 if (bs
->file
!= NULL
) {
2852 return bdrv_can_snapshot(bs
->file
);
2860 int bdrv_is_snapshot(BlockDriverState
*bs
)
2862 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2865 BlockDriverState
*bdrv_snapshots(void)
2867 BlockDriverState
*bs
;
2870 return bs_snapshots
;
2874 while ((bs
= bdrv_next(bs
))) {
2875 if (bdrv_can_snapshot(bs
)) {
2883 int bdrv_snapshot_create(BlockDriverState
*bs
,
2884 QEMUSnapshotInfo
*sn_info
)
2886 BlockDriver
*drv
= bs
->drv
;
2889 if (drv
->bdrv_snapshot_create
)
2890 return drv
->bdrv_snapshot_create(bs
, sn_info
);
2892 return bdrv_snapshot_create(bs
->file
, sn_info
);
2896 int bdrv_snapshot_goto(BlockDriverState
*bs
,
2897 const char *snapshot_id
)
2899 BlockDriver
*drv
= bs
->drv
;
2904 if (drv
->bdrv_snapshot_goto
)
2905 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
2908 drv
->bdrv_close(bs
);
2909 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
2910 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
2912 bdrv_delete(bs
->file
);
2922 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2924 BlockDriver
*drv
= bs
->drv
;
2927 if (drv
->bdrv_snapshot_delete
)
2928 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
2930 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
2934 int bdrv_snapshot_list(BlockDriverState
*bs
,
2935 QEMUSnapshotInfo
**psn_info
)
2937 BlockDriver
*drv
= bs
->drv
;
2940 if (drv
->bdrv_snapshot_list
)
2941 return drv
->bdrv_snapshot_list(bs
, psn_info
);
2943 return bdrv_snapshot_list(bs
->file
, psn_info
);
2947 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
2948 const char *snapshot_name
)
2950 BlockDriver
*drv
= bs
->drv
;
2954 if (!bs
->read_only
) {
2957 if (drv
->bdrv_snapshot_load_tmp
) {
2958 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
2963 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2964 const char *backing_file
)
2970 if (bs
->backing_hd
) {
2971 if (strcmp(bs
->backing_file
, backing_file
) == 0) {
2972 return bs
->backing_hd
;
2974 return bdrv_find_backing_image(bs
->backing_hd
, backing_file
);
2981 #define NB_SUFFIXES 4
2983 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
2985 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
2990 snprintf(buf
, buf_size
, "%" PRId64
, size
);
2993 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
2994 if (size
< (10 * base
)) {
2995 snprintf(buf
, buf_size
, "%0.1f%c",
2996 (double)size
/ base
,
2999 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
3000 snprintf(buf
, buf_size
, "%" PRId64
"%c",
3001 ((size
+ (base
>> 1)) / base
),
3011 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
3013 char buf1
[128], date_buf
[128], clock_buf
[128];
3023 snprintf(buf
, buf_size
,
3024 "%-10s%-20s%7s%20s%15s",
3025 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3029 ptm
= localtime(&ti
);
3030 strftime(date_buf
, sizeof(date_buf
),
3031 "%Y-%m-%d %H:%M:%S", ptm
);
3033 localtime_r(&ti
, &tm
);
3034 strftime(date_buf
, sizeof(date_buf
),
3035 "%Y-%m-%d %H:%M:%S", &tm
);
3037 secs
= sn
->vm_clock_nsec
/ 1000000000;
3038 snprintf(clock_buf
, sizeof(clock_buf
),
3039 "%02d:%02d:%02d.%03d",
3041 (int)((secs
/ 60) % 60),
3043 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
3044 snprintf(buf
, buf_size
,
3045 "%-10s%-20s%7s%20s%15s",
3046 sn
->id_str
, sn
->name
,
3047 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
3054 /**************************************************************/
3057 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3058 QEMUIOVector
*qiov
, int nb_sectors
,
3059 BlockDriverCompletionFunc
*cb
, void *opaque
)
3061 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3063 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3067 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3068 QEMUIOVector
*qiov
, int nb_sectors
,
3069 BlockDriverCompletionFunc
*cb
, void *opaque
)
3071 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3073 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3078 typedef struct MultiwriteCB
{
3083 BlockDriverCompletionFunc
*cb
;
3085 QEMUIOVector
*free_qiov
;
3089 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3093 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3094 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3095 if (mcb
->callbacks
[i
].free_qiov
) {
3096 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3098 g_free(mcb
->callbacks
[i
].free_qiov
);
3102 static void multiwrite_cb(void *opaque
, int ret
)
3104 MultiwriteCB
*mcb
= opaque
;
3106 trace_multiwrite_cb(mcb
, ret
);
3108 if (ret
< 0 && !mcb
->error
) {
3112 mcb
->num_requests
--;
3113 if (mcb
->num_requests
== 0) {
3114 multiwrite_user_cb(mcb
);
3119 static int multiwrite_req_compare(const void *a
, const void *b
)
3121 const BlockRequest
*req1
= a
, *req2
= b
;
3124 * Note that we can't simply subtract req2->sector from req1->sector
3125 * here as that could overflow the return value.
3127 if (req1
->sector
> req2
->sector
) {
3129 } else if (req1
->sector
< req2
->sector
) {
3137 * Takes a bunch of requests and tries to merge them. Returns the number of
3138 * requests that remain after merging.
3140 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3141 int num_reqs
, MultiwriteCB
*mcb
)
3145 // Sort requests by start sector
3146 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3148 // Check if adjacent requests touch the same clusters. If so, combine them,
3149 // filling up gaps with zero sectors.
3151 for (i
= 1; i
< num_reqs
; i
++) {
3153 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3155 // Handle exactly sequential writes and overlapping writes.
3156 if (reqs
[i
].sector
<= oldreq_last
) {
3160 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3166 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3167 qemu_iovec_init(qiov
,
3168 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3170 // Add the first request to the merged one. If the requests are
3171 // overlapping, drop the last sectors of the first request.
3172 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3173 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, size
);
3175 // We should need to add any zeros between the two requests
3176 assert (reqs
[i
].sector
<= oldreq_last
);
3178 // Add the second request
3179 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, reqs
[i
].qiov
->size
);
3181 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3182 reqs
[outidx
].qiov
= qiov
;
3184 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3187 reqs
[outidx
].sector
= reqs
[i
].sector
;
3188 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3189 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3197 * Submit multiple AIO write requests at once.
3199 * On success, the function returns 0 and all requests in the reqs array have
3200 * been submitted. In error case this function returns -1, and any of the
3201 * requests may or may not be submitted yet. In particular, this means that the
3202 * callback will be called for some of the requests, for others it won't. The
3203 * caller must check the error field of the BlockRequest to wait for the right
3204 * callbacks (if error != 0, no callback will be called).
3206 * The implementation may modify the contents of the reqs array, e.g. to merge
3207 * requests. However, the fields opaque and error are left unmodified as they
3208 * are used to signal failure for a single request to the caller.
3210 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3215 /* don't submit writes if we don't have a medium */
3216 if (bs
->drv
== NULL
) {
3217 for (i
= 0; i
< num_reqs
; i
++) {
3218 reqs
[i
].error
= -ENOMEDIUM
;
3223 if (num_reqs
== 0) {
3227 // Create MultiwriteCB structure
3228 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3229 mcb
->num_requests
= 0;
3230 mcb
->num_callbacks
= num_reqs
;
3232 for (i
= 0; i
< num_reqs
; i
++) {
3233 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3234 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3237 // Check for mergable requests
3238 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3240 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3242 /* Run the aio requests. */
3243 mcb
->num_requests
= num_reqs
;
3244 for (i
= 0; i
< num_reqs
; i
++) {
3245 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3246 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3252 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3254 acb
->pool
->cancel(acb
);
3257 /* block I/O throttling */
3258 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3259 bool is_write
, double elapsed_time
, uint64_t *wait
)
3261 uint64_t bps_limit
= 0;
3262 double bytes_limit
, bytes_base
, bytes_res
;
3263 double slice_time
, wait_time
;
3265 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3266 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3267 } else if (bs
->io_limits
.bps
[is_write
]) {
3268 bps_limit
= bs
->io_limits
.bps
[is_write
];
3277 slice_time
= bs
->slice_end
- bs
->slice_start
;
3278 slice_time
/= (NANOSECONDS_PER_SECOND
);
3279 bytes_limit
= bps_limit
* slice_time
;
3280 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3281 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3282 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3285 /* bytes_base: the bytes of data which have been read/written; and
3286 * it is obtained from the history statistic info.
3287 * bytes_res: the remaining bytes of data which need to be read/written.
3288 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3289 * the total time for completing reading/writting all data.
3291 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3293 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3301 /* Calc approx time to dispatch */
3302 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3304 /* When the I/O rate at runtime exceeds the limits,
3305 * bs->slice_end need to be extended in order that the current statistic
3306 * info can be kept until the timer fire, so it is increased and tuned
3307 * based on the result of experiment.
3309 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3310 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3312 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3318 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3319 double elapsed_time
, uint64_t *wait
)
3321 uint64_t iops_limit
= 0;
3322 double ios_limit
, ios_base
;
3323 double slice_time
, wait_time
;
3325 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3326 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3327 } else if (bs
->io_limits
.iops
[is_write
]) {
3328 iops_limit
= bs
->io_limits
.iops
[is_write
];
3337 slice_time
= bs
->slice_end
- bs
->slice_start
;
3338 slice_time
/= (NANOSECONDS_PER_SECOND
);
3339 ios_limit
= iops_limit
* slice_time
;
3340 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3341 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3342 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3345 if (ios_base
+ 1 <= ios_limit
) {
3353 /* Calc approx time to dispatch */
3354 wait_time
= (ios_base
+ 1) / iops_limit
;
3355 if (wait_time
> elapsed_time
) {
3356 wait_time
= wait_time
- elapsed_time
;
3361 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3362 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3364 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3370 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3371 bool is_write
, int64_t *wait
)
3373 int64_t now
, max_wait
;
3374 uint64_t bps_wait
= 0, iops_wait
= 0;
3375 double elapsed_time
;
3376 int bps_ret
, iops_ret
;
3378 now
= qemu_get_clock_ns(vm_clock
);
3379 if ((bs
->slice_start
< now
)
3380 && (bs
->slice_end
> now
)) {
3381 bs
->slice_end
= now
+ bs
->slice_time
;
3383 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3384 bs
->slice_start
= now
;
3385 bs
->slice_end
= now
+ bs
->slice_time
;
3387 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3388 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3390 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3391 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3394 elapsed_time
= now
- bs
->slice_start
;
3395 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3397 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3398 is_write
, elapsed_time
, &bps_wait
);
3399 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3400 elapsed_time
, &iops_wait
);
3401 if (bps_ret
|| iops_ret
) {
3402 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3407 now
= qemu_get_clock_ns(vm_clock
);
3408 if (bs
->slice_end
< now
+ max_wait
) {
3409 bs
->slice_end
= now
+ max_wait
;
3422 /**************************************************************/
3423 /* async block device emulation */
3425 typedef struct BlockDriverAIOCBSync
{
3426 BlockDriverAIOCB common
;
3429 /* vector translation state */
3433 } BlockDriverAIOCBSync
;
3435 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3437 BlockDriverAIOCBSync
*acb
=
3438 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3439 qemu_bh_delete(acb
->bh
);
3441 qemu_aio_release(acb
);
3444 static AIOPool bdrv_em_aio_pool
= {
3445 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3446 .cancel
= bdrv_aio_cancel_em
,
3449 static void bdrv_aio_bh_cb(void *opaque
)
3451 BlockDriverAIOCBSync
*acb
= opaque
;
3454 qemu_iovec_from_buffer(acb
->qiov
, acb
->bounce
, acb
->qiov
->size
);
3455 qemu_vfree(acb
->bounce
);
3456 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3457 qemu_bh_delete(acb
->bh
);
3459 qemu_aio_release(acb
);
3462 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3466 BlockDriverCompletionFunc
*cb
,
3471 BlockDriverAIOCBSync
*acb
;
3473 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3474 acb
->is_write
= is_write
;
3476 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3477 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3480 qemu_iovec_to_buffer(acb
->qiov
, acb
->bounce
);
3481 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3483 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3486 qemu_bh_schedule(acb
->bh
);
3488 return &acb
->common
;
3491 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3492 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3493 BlockDriverCompletionFunc
*cb
, void *opaque
)
3495 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3498 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3499 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3500 BlockDriverCompletionFunc
*cb
, void *opaque
)
3502 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3506 typedef struct BlockDriverAIOCBCoroutine
{
3507 BlockDriverAIOCB common
;
3511 } BlockDriverAIOCBCoroutine
;
3513 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3518 static AIOPool bdrv_em_co_aio_pool
= {
3519 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3520 .cancel
= bdrv_aio_co_cancel_em
,
3523 static void bdrv_co_em_bh(void *opaque
)
3525 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3527 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3528 qemu_bh_delete(acb
->bh
);
3529 qemu_aio_release(acb
);
3532 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3533 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3535 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3536 BlockDriverState
*bs
= acb
->common
.bs
;
3538 if (!acb
->is_write
) {
3539 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3540 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3542 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3543 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3546 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3547 qemu_bh_schedule(acb
->bh
);
3550 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3554 BlockDriverCompletionFunc
*cb
,
3559 BlockDriverAIOCBCoroutine
*acb
;
3561 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3562 acb
->req
.sector
= sector_num
;
3563 acb
->req
.nb_sectors
= nb_sectors
;
3564 acb
->req
.qiov
= qiov
;
3565 acb
->is_write
= is_write
;
3567 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3568 qemu_coroutine_enter(co
, acb
);
3570 return &acb
->common
;
3573 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3575 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3576 BlockDriverState
*bs
= acb
->common
.bs
;
3578 acb
->req
.error
= bdrv_co_flush(bs
);
3579 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3580 qemu_bh_schedule(acb
->bh
);
3583 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3584 BlockDriverCompletionFunc
*cb
, void *opaque
)
3586 trace_bdrv_aio_flush(bs
, opaque
);
3589 BlockDriverAIOCBCoroutine
*acb
;
3591 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3592 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3593 qemu_coroutine_enter(co
, acb
);
3595 return &acb
->common
;
3598 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3600 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3601 BlockDriverState
*bs
= acb
->common
.bs
;
3603 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3604 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3605 qemu_bh_schedule(acb
->bh
);
3608 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3609 int64_t sector_num
, int nb_sectors
,
3610 BlockDriverCompletionFunc
*cb
, void *opaque
)
3613 BlockDriverAIOCBCoroutine
*acb
;
3615 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3617 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3618 acb
->req
.sector
= sector_num
;
3619 acb
->req
.nb_sectors
= nb_sectors
;
3620 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3621 qemu_coroutine_enter(co
, acb
);
3623 return &acb
->common
;
3626 void bdrv_init(void)
3628 module_call_init(MODULE_INIT_BLOCK
);
3631 void bdrv_init_with_whitelist(void)
3633 use_bdrv_whitelist
= 1;
3637 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3638 BlockDriverCompletionFunc
*cb
, void *opaque
)
3640 BlockDriverAIOCB
*acb
;
3642 if (pool
->free_aiocb
) {
3643 acb
= pool
->free_aiocb
;
3644 pool
->free_aiocb
= acb
->next
;
3646 acb
= g_malloc0(pool
->aiocb_size
);
3651 acb
->opaque
= opaque
;
3655 void qemu_aio_release(void *p
)
3657 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3658 AIOPool
*pool
= acb
->pool
;
3659 acb
->next
= pool
->free_aiocb
;
3660 pool
->free_aiocb
= acb
;
3663 /**************************************************************/
3664 /* Coroutine block device emulation */
3666 typedef struct CoroutineIOCompletion
{
3667 Coroutine
*coroutine
;
3669 } CoroutineIOCompletion
;
3671 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3673 CoroutineIOCompletion
*co
= opaque
;
3676 qemu_coroutine_enter(co
->coroutine
, NULL
);
3679 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3680 int nb_sectors
, QEMUIOVector
*iov
,
3683 CoroutineIOCompletion co
= {
3684 .coroutine
= qemu_coroutine_self(),
3686 BlockDriverAIOCB
*acb
;
3689 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3690 bdrv_co_io_em_complete
, &co
);
3692 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3693 bdrv_co_io_em_complete
, &co
);
3696 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3700 qemu_coroutine_yield();
3705 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3706 int64_t sector_num
, int nb_sectors
,
3709 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3712 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3713 int64_t sector_num
, int nb_sectors
,
3716 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3719 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3721 RwCo
*rwco
= opaque
;
3723 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3726 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3730 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3734 /* Write back cached data to the OS even with cache=unsafe */
3735 if (bs
->drv
->bdrv_co_flush_to_os
) {
3736 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3742 /* But don't actually force it to the disk with cache=unsafe */
3743 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3747 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3748 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
3749 } else if (bs
->drv
->bdrv_aio_flush
) {
3750 BlockDriverAIOCB
*acb
;
3751 CoroutineIOCompletion co
= {
3752 .coroutine
= qemu_coroutine_self(),
3755 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
3759 qemu_coroutine_yield();
3764 * Some block drivers always operate in either writethrough or unsafe
3765 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3766 * know how the server works (because the behaviour is hardcoded or
3767 * depends on server-side configuration), so we can't ensure that
3768 * everything is safe on disk. Returning an error doesn't work because
3769 * that would break guests even if the server operates in writethrough
3772 * Let's hope the user knows what he's doing.
3780 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
3781 * in the case of cache=unsafe, so there are no useless flushes.
3783 return bdrv_co_flush(bs
->file
);
3786 void bdrv_invalidate_cache(BlockDriverState
*bs
)
3788 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
3789 bs
->drv
->bdrv_invalidate_cache(bs
);
3793 void bdrv_invalidate_cache_all(void)
3795 BlockDriverState
*bs
;
3797 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3798 bdrv_invalidate_cache(bs
);
3802 void bdrv_clear_incoming_migration_all(void)
3804 BlockDriverState
*bs
;
3806 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3807 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
3811 int bdrv_flush(BlockDriverState
*bs
)
3819 if (qemu_in_coroutine()) {
3820 /* Fast-path if already in coroutine context */
3821 bdrv_flush_co_entry(&rwco
);
3823 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
3824 qemu_coroutine_enter(co
, &rwco
);
3825 while (rwco
.ret
== NOT_DONE
) {
3833 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
3835 RwCo
*rwco
= opaque
;
3837 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
3840 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
3845 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
3847 } else if (bs
->read_only
) {
3849 } else if (bs
->drv
->bdrv_co_discard
) {
3850 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
3851 } else if (bs
->drv
->bdrv_aio_discard
) {
3852 BlockDriverAIOCB
*acb
;
3853 CoroutineIOCompletion co
= {
3854 .coroutine
= qemu_coroutine_self(),
3857 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
3858 bdrv_co_io_em_complete
, &co
);
3862 qemu_coroutine_yield();
3870 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
3875 .sector_num
= sector_num
,
3876 .nb_sectors
= nb_sectors
,
3880 if (qemu_in_coroutine()) {
3881 /* Fast-path if already in coroutine context */
3882 bdrv_discard_co_entry(&rwco
);
3884 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
3885 qemu_coroutine_enter(co
, &rwco
);
3886 while (rwco
.ret
== NOT_DONE
) {
3894 /**************************************************************/
3895 /* removable device support */
3898 * Return TRUE if the media is present
3900 int bdrv_is_inserted(BlockDriverState
*bs
)
3902 BlockDriver
*drv
= bs
->drv
;
3906 if (!drv
->bdrv_is_inserted
)
3908 return drv
->bdrv_is_inserted(bs
);
3912 * Return whether the media changed since the last call to this
3913 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3915 int bdrv_media_changed(BlockDriverState
*bs
)
3917 BlockDriver
*drv
= bs
->drv
;
3919 if (drv
&& drv
->bdrv_media_changed
) {
3920 return drv
->bdrv_media_changed(bs
);
3926 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3928 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3930 BlockDriver
*drv
= bs
->drv
;
3932 if (drv
&& drv
->bdrv_eject
) {
3933 drv
->bdrv_eject(bs
, eject_flag
);
3936 if (bs
->device_name
[0] != '\0') {
3937 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
3942 * Lock or unlock the media (if it is locked, the user won't be able
3943 * to eject it manually).
3945 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3947 BlockDriver
*drv
= bs
->drv
;
3949 trace_bdrv_lock_medium(bs
, locked
);
3951 if (drv
&& drv
->bdrv_lock_medium
) {
3952 drv
->bdrv_lock_medium(bs
, locked
);
3956 /* needed for generic scsi interface */
3958 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
3960 BlockDriver
*drv
= bs
->drv
;
3962 if (drv
&& drv
->bdrv_ioctl
)
3963 return drv
->bdrv_ioctl(bs
, req
, buf
);
3967 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
3968 unsigned long int req
, void *buf
,
3969 BlockDriverCompletionFunc
*cb
, void *opaque
)
3971 BlockDriver
*drv
= bs
->drv
;
3973 if (drv
&& drv
->bdrv_aio_ioctl
)
3974 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
3978 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
3980 bs
->buffer_alignment
= align
;
3983 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
3985 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
3988 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
3990 int64_t bitmap_size
;
3992 bs
->dirty_count
= 0;
3994 if (!bs
->dirty_bitmap
) {
3995 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
3996 BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
- 1;
3997 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
;
3999 bs
->dirty_bitmap
= g_new0(unsigned long, bitmap_size
);
4002 if (bs
->dirty_bitmap
) {
4003 g_free(bs
->dirty_bitmap
);
4004 bs
->dirty_bitmap
= NULL
;
4009 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4011 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
4013 if (bs
->dirty_bitmap
&&
4014 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
4015 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
4016 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
4022 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4025 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
4028 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4030 return bs
->dirty_count
;
4033 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4035 assert(bs
->in_use
!= in_use
);
4036 bs
->in_use
= in_use
;
4039 int bdrv_in_use(BlockDriverState
*bs
)
4044 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4046 bs
->iostatus_enabled
= true;
4047 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4050 /* The I/O status is only enabled if the drive explicitly
4051 * enables it _and_ the VM is configured to stop on errors */
4052 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4054 return (bs
->iostatus_enabled
&&
4055 (bs
->on_write_error
== BLOCK_ERR_STOP_ENOSPC
||
4056 bs
->on_write_error
== BLOCK_ERR_STOP_ANY
||
4057 bs
->on_read_error
== BLOCK_ERR_STOP_ANY
));
4060 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4062 bs
->iostatus_enabled
= false;
4065 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4067 if (bdrv_iostatus_is_enabled(bs
)) {
4068 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4072 /* XXX: Today this is set by device models because it makes the implementation
4073 quite simple. However, the block layer knows about the error, so it's
4074 possible to implement this without device models being involved */
4075 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4077 if (bdrv_iostatus_is_enabled(bs
) &&
4078 bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4080 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4081 BLOCK_DEVICE_IO_STATUS_FAILED
;
4086 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4087 enum BlockAcctType type
)
4089 assert(type
< BDRV_MAX_IOTYPE
);
4091 cookie
->bytes
= bytes
;
4092 cookie
->start_time_ns
= get_clock();
4093 cookie
->type
= type
;
4097 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4099 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4101 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4102 bs
->nr_ops
[cookie
->type
]++;
4103 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4106 int bdrv_img_create(const char *filename
, const char *fmt
,
4107 const char *base_filename
, const char *base_fmt
,
4108 char *options
, uint64_t img_size
, int flags
)
4110 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4111 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4112 BlockDriverState
*bs
= NULL
;
4113 BlockDriver
*drv
, *proto_drv
;
4114 BlockDriver
*backing_drv
= NULL
;
4117 /* Find driver and parse its options */
4118 drv
= bdrv_find_format(fmt
);
4120 error_report("Unknown file format '%s'", fmt
);
4125 proto_drv
= bdrv_find_protocol(filename
);
4127 error_report("Unknown protocol '%s'", filename
);
4132 create_options
= append_option_parameters(create_options
,
4133 drv
->create_options
);
4134 create_options
= append_option_parameters(create_options
,
4135 proto_drv
->create_options
);
4137 /* Create parameter list with default values */
4138 param
= parse_option_parameters("", create_options
, param
);
4140 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4142 /* Parse -o options */
4144 param
= parse_option_parameters(options
, create_options
, param
);
4145 if (param
== NULL
) {
4146 error_report("Invalid options for file format '%s'.", fmt
);
4152 if (base_filename
) {
4153 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4155 error_report("Backing file not supported for file format '%s'",
4163 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4164 error_report("Backing file format not supported for file "
4165 "format '%s'", fmt
);
4171 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4172 if (backing_file
&& backing_file
->value
.s
) {
4173 if (!strcmp(filename
, backing_file
->value
.s
)) {
4174 error_report("Error: Trying to create an image with the "
4175 "same filename as the backing file");
4181 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4182 if (backing_fmt
&& backing_fmt
->value
.s
) {
4183 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4185 error_report("Unknown backing file format '%s'",
4186 backing_fmt
->value
.s
);
4192 // The size for the image must always be specified, with one exception:
4193 // If we are using a backing file, we can obtain the size from there
4194 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4195 if (size
&& size
->value
.n
== -1) {
4196 if (backing_file
&& backing_file
->value
.s
) {
4201 /* backing files always opened read-only */
4203 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4207 ret
= bdrv_open(bs
, backing_file
->value
.s
, back_flags
, backing_drv
);
4209 error_report("Could not open '%s'", backing_file
->value
.s
);
4212 bdrv_get_geometry(bs
, &size
);
4215 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4216 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4218 error_report("Image creation needs a size parameter");
4224 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4225 print_option_parameters(param
);
4228 ret
= bdrv_create(drv
, filename
, param
);
4231 if (ret
== -ENOTSUP
) {
4232 error_report("Formatting or formatting option not supported for "
4233 "file format '%s'", fmt
);
4234 } else if (ret
== -EFBIG
) {
4235 error_report("The image size is too large for file format '%s'",
4238 error_report("%s: error while creating %s: %s", filename
, fmt
,
4244 free_option_parameters(create_options
);
4245 free_option_parameters(param
);
4254 void *block_job_create(const BlockJobType
*job_type
, BlockDriverState
*bs
,
4255 int64_t speed
, BlockDriverCompletionFunc
*cb
,
4256 void *opaque
, Error
**errp
)
4260 if (bs
->job
|| bdrv_in_use(bs
)) {
4261 error_set(errp
, QERR_DEVICE_IN_USE
, bdrv_get_device_name(bs
));
4264 bdrv_set_in_use(bs
, 1);
4266 job
= g_malloc0(job_type
->instance_size
);
4267 job
->job_type
= job_type
;
4270 job
->opaque
= opaque
;
4274 /* Only set speed when necessary to avoid NotSupported error */
4276 Error
*local_err
= NULL
;
4278 block_job_set_speed(job
, speed
, &local_err
);
4279 if (error_is_set(&local_err
)) {
4282 bdrv_set_in_use(bs
, 0);
4283 error_propagate(errp
, local_err
);
4290 void block_job_complete(BlockJob
*job
, int ret
)
4292 BlockDriverState
*bs
= job
->bs
;
4294 assert(bs
->job
== job
);
4295 job
->cb(job
->opaque
, ret
);
4298 bdrv_set_in_use(bs
, 0);
4301 void block_job_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
4303 Error
*local_err
= NULL
;
4305 if (!job
->job_type
->set_speed
) {
4306 error_set(errp
, QERR_NOT_SUPPORTED
);
4309 job
->job_type
->set_speed(job
, speed
, &local_err
);
4310 if (error_is_set(&local_err
)) {
4311 error_propagate(errp
, local_err
);
4318 void block_job_cancel(BlockJob
*job
)
4320 job
->cancelled
= true;
4321 if (job
->co
&& !job
->busy
) {
4322 qemu_coroutine_enter(job
->co
, NULL
);
4326 bool block_job_is_cancelled(BlockJob
*job
)
4328 return job
->cancelled
;
4331 struct BlockCancelData
{
4333 BlockDriverCompletionFunc
*cb
;
4339 static void block_job_cancel_cb(void *opaque
, int ret
)
4341 struct BlockCancelData
*data
= opaque
;
4343 data
->cancelled
= block_job_is_cancelled(data
->job
);
4345 data
->cb(data
->opaque
, ret
);
4348 int block_job_cancel_sync(BlockJob
*job
)
4350 struct BlockCancelData data
;
4351 BlockDriverState
*bs
= job
->bs
;
4353 assert(bs
->job
== job
);
4355 /* Set up our own callback to store the result and chain to
4356 * the original callback.
4360 data
.opaque
= job
->opaque
;
4361 data
.ret
= -EINPROGRESS
;
4362 job
->cb
= block_job_cancel_cb
;
4363 job
->opaque
= &data
;
4364 block_job_cancel(job
);
4365 while (data
.ret
== -EINPROGRESS
) {
4368 return (data
.cancelled
&& data
.ret
== 0) ? -ECANCELED
: data
.ret
;
4371 void block_job_sleep_ns(BlockJob
*job
, QEMUClock
*clock
, int64_t ns
)
4373 /* Check cancellation *before* setting busy = false, too! */
4374 if (!block_job_is_cancelled(job
)) {
4376 co_sleep_ns(clock
, ns
);