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
);
439 if (close(fd
) != 0) {
448 * Detect host devices. By convention, /dev/cdrom[N] is always
449 * recognized as a host CDROM.
451 static BlockDriver
*find_hdev_driver(const char *filename
)
453 int score_max
= 0, score
;
454 BlockDriver
*drv
= NULL
, *d
;
456 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
457 if (d
->bdrv_probe_device
) {
458 score
= d
->bdrv_probe_device(filename
);
459 if (score
> score_max
) {
469 BlockDriver
*bdrv_find_protocol(const char *filename
)
476 /* TODO Drivers without bdrv_file_open must be specified explicitly */
479 * XXX(hch): we really should not let host device detection
480 * override an explicit protocol specification, but moving this
481 * later breaks access to device names with colons in them.
482 * Thanks to the brain-dead persistent naming schemes on udev-
483 * based Linux systems those actually are quite common.
485 drv1
= find_hdev_driver(filename
);
490 if (!path_has_protocol(filename
)) {
491 return bdrv_find_format("file");
493 p
= strchr(filename
, ':');
496 if (len
> sizeof(protocol
) - 1)
497 len
= sizeof(protocol
) - 1;
498 memcpy(protocol
, filename
, len
);
499 protocol
[len
] = '\0';
500 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
501 if (drv1
->protocol_name
&&
502 !strcmp(drv1
->protocol_name
, protocol
)) {
509 static int find_image_format(const char *filename
, BlockDriver
**pdrv
)
511 int ret
, score
, score_max
;
512 BlockDriver
*drv1
, *drv
;
514 BlockDriverState
*bs
;
516 ret
= bdrv_file_open(&bs
, filename
, 0);
522 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
523 if (bs
->sg
|| !bdrv_is_inserted(bs
)) {
525 drv
= bdrv_find_format("raw");
533 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
542 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
543 if (drv1
->bdrv_probe
) {
544 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
545 if (score
> score_max
) {
559 * Set the current 'total_sectors' value
561 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
563 BlockDriver
*drv
= bs
->drv
;
565 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
569 /* query actual device if possible, otherwise just trust the hint */
570 if (drv
->bdrv_getlength
) {
571 int64_t length
= drv
->bdrv_getlength(bs
);
575 hint
= length
>> BDRV_SECTOR_BITS
;
578 bs
->total_sectors
= hint
;
583 * Set open flags for a given cache mode
585 * Return 0 on success, -1 if the cache mode was invalid.
587 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
589 *flags
&= ~BDRV_O_CACHE_MASK
;
591 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
592 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
593 } else if (!strcmp(mode
, "directsync")) {
594 *flags
|= BDRV_O_NOCACHE
;
595 } else if (!strcmp(mode
, "writeback")) {
596 *flags
|= BDRV_O_CACHE_WB
;
597 } else if (!strcmp(mode
, "unsafe")) {
598 *flags
|= BDRV_O_CACHE_WB
;
599 *flags
|= BDRV_O_NO_FLUSH
;
600 } else if (!strcmp(mode
, "writethrough")) {
601 /* this is the default */
610 * The copy-on-read flag is actually a reference count so multiple users may
611 * use the feature without worrying about clobbering its previous state.
612 * Copy-on-read stays enabled until all users have called to disable it.
614 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
619 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
621 assert(bs
->copy_on_read
> 0);
626 * Common part for opening disk images and files
628 static int bdrv_open_common(BlockDriverState
*bs
, const char *filename
,
629 int flags
, BlockDriver
*drv
)
634 assert(bs
->file
== NULL
);
636 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
638 bs
->open_flags
= flags
;
639 bs
->buffer_alignment
= 512;
641 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
642 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
643 bdrv_enable_copy_on_read(bs
);
646 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
648 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
653 bs
->opaque
= g_malloc0(drv
->instance_size
);
655 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
656 open_flags
= flags
| BDRV_O_CACHE_WB
;
659 * Clear flags that are internal to the block layer before opening the
662 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
665 * Snapshots should be writable.
667 if (bs
->is_temporary
) {
668 open_flags
|= BDRV_O_RDWR
;
671 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
673 /* Open the image, either directly or using a protocol */
674 if (drv
->bdrv_file_open
) {
675 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
677 ret
= bdrv_file_open(&bs
->file
, filename
, open_flags
);
679 ret
= drv
->bdrv_open(bs
, open_flags
);
687 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
693 if (bs
->is_temporary
) {
701 bdrv_delete(bs
->file
);
711 * Opens a file using a protocol (file, host_device, nbd, ...)
713 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
715 BlockDriverState
*bs
;
719 drv
= bdrv_find_protocol(filename
);
725 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
736 * Opens a disk image (raw, qcow2, vmdk, ...)
738 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int flags
,
742 char tmp_filename
[PATH_MAX
];
744 if (flags
& BDRV_O_SNAPSHOT
) {
745 BlockDriverState
*bs1
;
748 BlockDriver
*bdrv_qcow2
;
749 QEMUOptionParameter
*options
;
750 char backing_filename
[PATH_MAX
];
752 /* if snapshot, we create a temporary backing file and open it
753 instead of opening 'filename' directly */
755 /* if there is a backing file, use it */
757 ret
= bdrv_open(bs1
, filename
, 0, drv
);
762 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
764 if (bs1
->drv
&& bs1
->drv
->protocol_name
)
769 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
774 /* Real path is meaningless for protocols */
776 snprintf(backing_filename
, sizeof(backing_filename
),
778 else if (!realpath(filename
, backing_filename
))
781 bdrv_qcow2
= bdrv_find_format("qcow2");
782 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
784 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
785 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
787 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
791 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
792 free_option_parameters(options
);
797 filename
= tmp_filename
;
799 bs
->is_temporary
= 1;
802 /* Find the right image format driver */
804 ret
= find_image_format(filename
, &drv
);
808 goto unlink_and_fail
;
811 if (flags
& BDRV_O_RDWR
) {
812 flags
|= BDRV_O_ALLOW_RDWR
;
816 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
818 goto unlink_and_fail
;
821 /* If there is a backing file, use it */
822 if ((flags
& BDRV_O_NO_BACKING
) == 0 && bs
->backing_file
[0] != '\0') {
823 char backing_filename
[PATH_MAX
];
825 BlockDriver
*back_drv
= NULL
;
827 bs
->backing_hd
= bdrv_new("");
828 bdrv_get_full_backing_filename(bs
, backing_filename
,
829 sizeof(backing_filename
));
831 if (bs
->backing_format
[0] != '\0') {
832 back_drv
= bdrv_find_format(bs
->backing_format
);
835 /* backing files always opened read-only */
837 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
839 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, back_flags
, back_drv
);
846 if (!bdrv_key_required(bs
)) {
847 bdrv_dev_change_media_cb(bs
, true);
850 /* throttling disk I/O limits */
851 if (bs
->io_limits_enabled
) {
852 bdrv_io_limits_enable(bs
);
858 if (bs
->is_temporary
) {
864 typedef struct BlockReopenQueueEntry
{
866 BDRVReopenState state
;
867 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
868 } BlockReopenQueueEntry
;
871 * Adds a BlockDriverState to a simple queue for an atomic, transactional
872 * reopen of multiple devices.
874 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
875 * already performed, or alternatively may be NULL a new BlockReopenQueue will
876 * be created and initialized. This newly created BlockReopenQueue should be
877 * passed back in for subsequent calls that are intended to be of the same
880 * bs is the BlockDriverState to add to the reopen queue.
882 * flags contains the open flags for the associated bs
884 * returns a pointer to bs_queue, which is either the newly allocated
885 * bs_queue, or the existing bs_queue being used.
888 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
889 BlockDriverState
*bs
, int flags
)
893 BlockReopenQueueEntry
*bs_entry
;
894 if (bs_queue
== NULL
) {
895 bs_queue
= g_new0(BlockReopenQueue
, 1);
896 QSIMPLEQ_INIT(bs_queue
);
900 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
903 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
904 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
906 bs_entry
->state
.bs
= bs
;
907 bs_entry
->state
.flags
= flags
;
913 * Reopen multiple BlockDriverStates atomically & transactionally.
915 * The queue passed in (bs_queue) must have been built up previous
916 * via bdrv_reopen_queue().
918 * Reopens all BDS specified in the queue, with the appropriate
919 * flags. All devices are prepared for reopen, and failure of any
920 * device will cause all device changes to be abandonded, and intermediate
923 * If all devices prepare successfully, then the changes are committed
927 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
930 BlockReopenQueueEntry
*bs_entry
, *next
;
931 Error
*local_err
= NULL
;
933 assert(bs_queue
!= NULL
);
937 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
938 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
939 error_propagate(errp
, local_err
);
942 bs_entry
->prepared
= true;
945 /* If we reach this point, we have success and just need to apply the
948 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
949 bdrv_reopen_commit(&bs_entry
->state
);
955 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
956 if (ret
&& bs_entry
->prepared
) {
957 bdrv_reopen_abort(&bs_entry
->state
);
966 /* Reopen a single BlockDriverState with the specified flags. */
967 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
970 Error
*local_err
= NULL
;
971 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
973 ret
= bdrv_reopen_multiple(queue
, &local_err
);
974 if (local_err
!= NULL
) {
975 error_propagate(errp
, local_err
);
982 * Prepares a BlockDriverState for reopen. All changes are staged in the
983 * 'opaque' field of the BDRVReopenState, which is used and allocated by
984 * the block driver layer .bdrv_reopen_prepare()
986 * bs is the BlockDriverState to reopen
987 * flags are the new open flags
988 * queue is the reopen queue
990 * Returns 0 on success, non-zero on error. On error errp will be set
993 * On failure, bdrv_reopen_abort() will be called to clean up any data.
994 * It is the responsibility of the caller to then call the abort() or
995 * commit() for any other BDS that have been left in a prepare() state
998 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1002 Error
*local_err
= NULL
;
1005 assert(reopen_state
!= NULL
);
1006 assert(reopen_state
->bs
->drv
!= NULL
);
1007 drv
= reopen_state
->bs
->drv
;
1009 /* if we are to stay read-only, do not allow permission change
1011 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1012 reopen_state
->flags
& BDRV_O_RDWR
) {
1013 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1014 reopen_state
->bs
->device_name
);
1019 ret
= bdrv_flush(reopen_state
->bs
);
1021 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1026 if (drv
->bdrv_reopen_prepare
) {
1027 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1029 if (local_err
!= NULL
) {
1030 error_propagate(errp
, local_err
);
1032 error_set(errp
, QERR_OPEN_FILE_FAILED
,
1033 reopen_state
->bs
->filename
);
1038 /* It is currently mandatory to have a bdrv_reopen_prepare()
1039 * handler for each supported drv. */
1040 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1041 drv
->format_name
, reopen_state
->bs
->device_name
,
1042 "reopening of file");
1054 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1055 * makes them final by swapping the staging BlockDriverState contents into
1056 * the active BlockDriverState contents.
1058 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1062 assert(reopen_state
!= NULL
);
1063 drv
= reopen_state
->bs
->drv
;
1064 assert(drv
!= NULL
);
1066 /* If there are any driver level actions to take */
1067 if (drv
->bdrv_reopen_commit
) {
1068 drv
->bdrv_reopen_commit(reopen_state
);
1071 /* set BDS specific flags now */
1072 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1073 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1075 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1079 * Abort the reopen, and delete and free the staged changes in
1082 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1086 assert(reopen_state
!= NULL
);
1087 drv
= reopen_state
->bs
->drv
;
1088 assert(drv
!= NULL
);
1090 if (drv
->bdrv_reopen_abort
) {
1091 drv
->bdrv_reopen_abort(reopen_state
);
1096 void bdrv_close(BlockDriverState
*bs
)
1101 block_job_cancel_sync(bs
->job
);
1105 if (bs
== bs_snapshots
) {
1106 bs_snapshots
= NULL
;
1108 if (bs
->backing_hd
) {
1109 bdrv_delete(bs
->backing_hd
);
1110 bs
->backing_hd
= NULL
;
1112 bs
->drv
->bdrv_close(bs
);
1115 if (bs
->is_temporary
) {
1116 unlink(bs
->filename
);
1121 bs
->copy_on_read
= 0;
1122 bs
->backing_file
[0] = '\0';
1123 bs
->backing_format
[0] = '\0';
1124 bs
->total_sectors
= 0;
1130 if (bs
->file
!= NULL
) {
1131 bdrv_delete(bs
->file
);
1136 bdrv_dev_change_media_cb(bs
, false);
1138 /*throttling disk I/O limits*/
1139 if (bs
->io_limits_enabled
) {
1140 bdrv_io_limits_disable(bs
);
1144 void bdrv_close_all(void)
1146 BlockDriverState
*bs
;
1148 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1154 * Wait for pending requests to complete across all BlockDriverStates
1156 * This function does not flush data to disk, use bdrv_flush_all() for that
1157 * after calling this function.
1159 * Note that completion of an asynchronous I/O operation can trigger any
1160 * number of other I/O operations on other devices---for example a coroutine
1161 * can be arbitrarily complex and a constant flow of I/O can come until the
1162 * coroutine is complete. Because of this, it is not possible to have a
1163 * function to drain a single device's I/O queue.
1165 void bdrv_drain_all(void)
1167 BlockDriverState
*bs
;
1171 busy
= qemu_aio_wait();
1173 /* FIXME: We do not have timer support here, so this is effectively
1176 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1177 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
1178 qemu_co_queue_restart_all(&bs
->throttled_reqs
);
1184 /* If requests are still pending there is a bug somewhere */
1185 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1186 assert(QLIST_EMPTY(&bs
->tracked_requests
));
1187 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
1191 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1192 Also, NULL terminate the device_name to prevent double remove */
1193 void bdrv_make_anon(BlockDriverState
*bs
)
1195 if (bs
->device_name
[0] != '\0') {
1196 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
1198 bs
->device_name
[0] = '\0';
1201 static void bdrv_rebind(BlockDriverState
*bs
)
1203 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1204 bs
->drv
->bdrv_rebind(bs
);
1208 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1209 BlockDriverState
*bs_src
)
1211 /* move some fields that need to stay attached to the device */
1212 bs_dest
->open_flags
= bs_src
->open_flags
;
1215 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1216 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1217 bs_dest
->dev
= bs_src
->dev
;
1218 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
1219 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1221 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1223 /* i/o timing parameters */
1224 bs_dest
->slice_time
= bs_src
->slice_time
;
1225 bs_dest
->slice_start
= bs_src
->slice_start
;
1226 bs_dest
->slice_end
= bs_src
->slice_end
;
1227 bs_dest
->io_limits
= bs_src
->io_limits
;
1228 bs_dest
->io_base
= bs_src
->io_base
;
1229 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
1230 bs_dest
->block_timer
= bs_src
->block_timer
;
1231 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1234 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1235 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1238 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1239 bs_dest
->iostatus
= bs_src
->iostatus
;
1242 bs_dest
->dirty_count
= bs_src
->dirty_count
;
1243 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1246 bs_dest
->in_use
= bs_src
->in_use
;
1247 bs_dest
->job
= bs_src
->job
;
1249 /* keep the same entry in bdrv_states */
1250 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1251 bs_src
->device_name
);
1252 bs_dest
->list
= bs_src
->list
;
1256 * Swap bs contents for two image chains while they are live,
1257 * while keeping required fields on the BlockDriverState that is
1258 * actually attached to a device.
1260 * This will modify the BlockDriverState fields, and swap contents
1261 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1263 * bs_new is required to be anonymous.
1265 * This function does not create any image files.
1267 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1269 BlockDriverState tmp
;
1271 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1272 assert(bs_new
->device_name
[0] == '\0');
1273 assert(bs_new
->dirty_bitmap
== NULL
);
1274 assert(bs_new
->job
== NULL
);
1275 assert(bs_new
->dev
== NULL
);
1276 assert(bs_new
->in_use
== 0);
1277 assert(bs_new
->io_limits_enabled
== false);
1278 assert(bs_new
->block_timer
== NULL
);
1284 /* there are some fields that should not be swapped, move them back */
1285 bdrv_move_feature_fields(&tmp
, bs_old
);
1286 bdrv_move_feature_fields(bs_old
, bs_new
);
1287 bdrv_move_feature_fields(bs_new
, &tmp
);
1289 /* bs_new shouldn't be in bdrv_states even after the swap! */
1290 assert(bs_new
->device_name
[0] == '\0');
1292 /* Check a few fields that should remain attached to the device */
1293 assert(bs_new
->dev
== NULL
);
1294 assert(bs_new
->job
== NULL
);
1295 assert(bs_new
->in_use
== 0);
1296 assert(bs_new
->io_limits_enabled
== false);
1297 assert(bs_new
->block_timer
== NULL
);
1299 bdrv_rebind(bs_new
);
1300 bdrv_rebind(bs_old
);
1304 * Add new bs contents at the top of an image chain while the chain is
1305 * live, while keeping required fields on the top layer.
1307 * This will modify the BlockDriverState fields, and swap contents
1308 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1310 * bs_new is required to be anonymous.
1312 * This function does not create any image files.
1314 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1316 bdrv_swap(bs_new
, bs_top
);
1318 /* The contents of 'tmp' will become bs_top, as we are
1319 * swapping bs_new and bs_top contents. */
1320 bs_top
->backing_hd
= bs_new
;
1321 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1322 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1324 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1325 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1328 void bdrv_delete(BlockDriverState
*bs
)
1332 assert(!bs
->in_use
);
1334 /* remove from list, if necessary */
1339 assert(bs
!= bs_snapshots
);
1343 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1344 /* TODO change to DeviceState *dev when all users are qdevified */
1350 bdrv_iostatus_reset(bs
);
1354 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1355 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1357 if (bdrv_attach_dev(bs
, dev
) < 0) {
1362 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1363 /* TODO change to DeviceState *dev when all users are qdevified */
1365 assert(bs
->dev
== dev
);
1368 bs
->dev_opaque
= NULL
;
1369 bs
->buffer_alignment
= 512;
1372 /* TODO change to return DeviceState * when all users are qdevified */
1373 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1378 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1382 bs
->dev_opaque
= opaque
;
1383 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1384 bs_snapshots
= NULL
;
1388 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1389 BlockQMPEventAction action
, int is_read
)
1392 const char *action_str
;
1395 case BDRV_ACTION_REPORT
:
1396 action_str
= "report";
1398 case BDRV_ACTION_IGNORE
:
1399 action_str
= "ignore";
1401 case BDRV_ACTION_STOP
:
1402 action_str
= "stop";
1408 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1411 is_read
? "read" : "write");
1412 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR
, data
);
1414 qobject_decref(data
);
1417 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1421 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1422 bdrv_get_device_name(bs
), ejected
);
1423 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1425 qobject_decref(data
);
1428 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1430 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1431 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1432 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1433 if (tray_was_closed
) {
1435 bdrv_emit_qmp_eject_event(bs
, true);
1439 bdrv_emit_qmp_eject_event(bs
, false);
1444 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1446 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1449 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1451 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1452 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1456 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1458 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1459 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1464 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1466 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1467 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1471 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1473 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1474 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1480 * Run consistency checks on an image
1482 * Returns 0 if the check could be completed (it doesn't mean that the image is
1483 * free of errors) or -errno when an internal error occurred. The results of the
1484 * check are stored in res.
1486 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1488 if (bs
->drv
->bdrv_check
== NULL
) {
1492 memset(res
, 0, sizeof(*res
));
1493 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1496 #define COMMIT_BUF_SECTORS 2048
1498 /* commit COW file into the raw image */
1499 int bdrv_commit(BlockDriverState
*bs
)
1501 BlockDriver
*drv
= bs
->drv
;
1502 int64_t sector
, total_sectors
;
1503 int n
, ro
, open_flags
;
1506 char filename
[1024];
1511 if (!bs
->backing_hd
) {
1515 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1519 ro
= bs
->backing_hd
->read_only
;
1520 strncpy(filename
, bs
->backing_hd
->filename
, sizeof(filename
));
1521 open_flags
= bs
->backing_hd
->open_flags
;
1524 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
1529 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1530 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1532 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1533 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1535 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1540 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1547 if (drv
->bdrv_make_empty
) {
1548 ret
= drv
->bdrv_make_empty(bs
);
1553 * Make sure all data we wrote to the backing device is actually
1557 bdrv_flush(bs
->backing_hd
);
1563 /* ignoring error return here */
1564 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
1570 int bdrv_commit_all(void)
1572 BlockDriverState
*bs
;
1574 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1575 int ret
= bdrv_commit(bs
);
1583 struct BdrvTrackedRequest
{
1584 BlockDriverState
*bs
;
1588 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1589 Coroutine
*co
; /* owner, used for deadlock detection */
1590 CoQueue wait_queue
; /* coroutines blocked on this request */
1594 * Remove an active request from the tracked requests list
1596 * This function should be called when a tracked request is completing.
1598 static void tracked_request_end(BdrvTrackedRequest
*req
)
1600 QLIST_REMOVE(req
, list
);
1601 qemu_co_queue_restart_all(&req
->wait_queue
);
1605 * Add an active request to the tracked requests list
1607 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1608 BlockDriverState
*bs
,
1610 int nb_sectors
, bool is_write
)
1612 *req
= (BdrvTrackedRequest
){
1614 .sector_num
= sector_num
,
1615 .nb_sectors
= nb_sectors
,
1616 .is_write
= is_write
,
1617 .co
= qemu_coroutine_self(),
1620 qemu_co_queue_init(&req
->wait_queue
);
1622 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1626 * Round a region to cluster boundaries
1628 static void round_to_clusters(BlockDriverState
*bs
,
1629 int64_t sector_num
, int nb_sectors
,
1630 int64_t *cluster_sector_num
,
1631 int *cluster_nb_sectors
)
1633 BlockDriverInfo bdi
;
1635 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1636 *cluster_sector_num
= sector_num
;
1637 *cluster_nb_sectors
= nb_sectors
;
1639 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1640 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1641 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1646 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1647 int64_t sector_num
, int nb_sectors
) {
1649 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1653 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1659 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1660 int64_t sector_num
, int nb_sectors
)
1662 BdrvTrackedRequest
*req
;
1663 int64_t cluster_sector_num
;
1664 int cluster_nb_sectors
;
1667 /* If we touch the same cluster it counts as an overlap. This guarantees
1668 * that allocating writes will be serialized and not race with each other
1669 * for the same cluster. For example, in copy-on-read it ensures that the
1670 * CoR read and write operations are atomic and guest writes cannot
1671 * interleave between them.
1673 round_to_clusters(bs
, sector_num
, nb_sectors
,
1674 &cluster_sector_num
, &cluster_nb_sectors
);
1678 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1679 if (tracked_request_overlaps(req
, cluster_sector_num
,
1680 cluster_nb_sectors
)) {
1681 /* Hitting this means there was a reentrant request, for
1682 * example, a block driver issuing nested requests. This must
1683 * never happen since it means deadlock.
1685 assert(qemu_coroutine_self() != req
->co
);
1687 qemu_co_queue_wait(&req
->wait_queue
);
1698 * -EINVAL - backing format specified, but no file
1699 * -ENOSPC - can't update the backing file because no space is left in the
1701 * -ENOTSUP - format driver doesn't support changing the backing file
1703 int bdrv_change_backing_file(BlockDriverState
*bs
,
1704 const char *backing_file
, const char *backing_fmt
)
1706 BlockDriver
*drv
= bs
->drv
;
1709 /* Backing file format doesn't make sense without a backing file */
1710 if (backing_fmt
&& !backing_file
) {
1714 if (drv
->bdrv_change_backing_file
!= NULL
) {
1715 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1721 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1722 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1728 * Finds the image layer in the chain that has 'bs' as its backing file.
1730 * active is the current topmost image.
1732 * Returns NULL if bs is not found in active's image chain,
1733 * or if active == bs.
1735 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
1736 BlockDriverState
*bs
)
1738 BlockDriverState
*overlay
= NULL
;
1739 BlockDriverState
*intermediate
;
1741 assert(active
!= NULL
);
1744 /* if bs is the same as active, then by definition it has no overlay
1750 intermediate
= active
;
1751 while (intermediate
->backing_hd
) {
1752 if (intermediate
->backing_hd
== bs
) {
1753 overlay
= intermediate
;
1756 intermediate
= intermediate
->backing_hd
;
1762 typedef struct BlkIntermediateStates
{
1763 BlockDriverState
*bs
;
1764 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
1765 } BlkIntermediateStates
;
1769 * Drops images above 'base' up to and including 'top', and sets the image
1770 * above 'top' to have base as its backing file.
1772 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1773 * information in 'bs' can be properly updated.
1775 * E.g., this will convert the following chain:
1776 * bottom <- base <- intermediate <- top <- active
1780 * bottom <- base <- active
1782 * It is allowed for bottom==base, in which case it converts:
1784 * base <- intermediate <- top <- active
1791 * if active == top, that is considered an error
1794 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
1795 BlockDriverState
*base
)
1797 BlockDriverState
*intermediate
;
1798 BlockDriverState
*base_bs
= NULL
;
1799 BlockDriverState
*new_top_bs
= NULL
;
1800 BlkIntermediateStates
*intermediate_state
, *next
;
1803 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
1804 QSIMPLEQ_INIT(&states_to_delete
);
1806 if (!top
->drv
|| !base
->drv
) {
1810 new_top_bs
= bdrv_find_overlay(active
, top
);
1812 if (new_top_bs
== NULL
) {
1813 /* we could not find the image above 'top', this is an error */
1817 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1818 * to do, no intermediate images */
1819 if (new_top_bs
->backing_hd
== base
) {
1826 /* now we will go down through the list, and add each BDS we find
1827 * into our deletion queue, until we hit the 'base'
1829 while (intermediate
) {
1830 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
1831 intermediate_state
->bs
= intermediate
;
1832 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
1834 if (intermediate
->backing_hd
== base
) {
1835 base_bs
= intermediate
->backing_hd
;
1838 intermediate
= intermediate
->backing_hd
;
1840 if (base_bs
== NULL
) {
1841 /* something went wrong, we did not end at the base. safely
1842 * unravel everything, and exit with error */
1846 /* success - we can delete the intermediate states, and link top->base */
1847 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
1848 base_bs
->drv
? base_bs
->drv
->format_name
: "");
1852 new_top_bs
->backing_hd
= base_bs
;
1855 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1856 /* so that bdrv_close() does not recursively close the chain */
1857 intermediate_state
->bs
->backing_hd
= NULL
;
1858 bdrv_delete(intermediate_state
->bs
);
1863 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1864 g_free(intermediate_state
);
1870 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1875 if (!bdrv_is_inserted(bs
))
1881 len
= bdrv_getlength(bs
);
1886 if ((offset
> len
) || (len
- offset
< size
))
1892 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1895 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1896 nb_sectors
* BDRV_SECTOR_SIZE
);
1899 typedef struct RwCo
{
1900 BlockDriverState
*bs
;
1908 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1910 RwCo
*rwco
= opaque
;
1912 if (!rwco
->is_write
) {
1913 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1914 rwco
->nb_sectors
, rwco
->qiov
, 0);
1916 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1917 rwco
->nb_sectors
, rwco
->qiov
, 0);
1922 * Process a synchronous request using coroutines
1924 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1925 int nb_sectors
, bool is_write
)
1928 struct iovec iov
= {
1929 .iov_base
= (void *)buf
,
1930 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1935 .sector_num
= sector_num
,
1936 .nb_sectors
= nb_sectors
,
1938 .is_write
= is_write
,
1942 qemu_iovec_init_external(&qiov
, &iov
, 1);
1945 * In sync call context, when the vcpu is blocked, this throttling timer
1946 * will not fire; so the I/O throttling function has to be disabled here
1947 * if it has been enabled.
1949 if (bs
->io_limits_enabled
) {
1950 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
1951 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
1952 bdrv_io_limits_disable(bs
);
1955 if (qemu_in_coroutine()) {
1956 /* Fast-path if already in coroutine context */
1957 bdrv_rw_co_entry(&rwco
);
1959 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1960 qemu_coroutine_enter(co
, &rwco
);
1961 while (rwco
.ret
== NOT_DONE
) {
1968 /* return < 0 if error. See bdrv_write() for the return codes */
1969 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1970 uint8_t *buf
, int nb_sectors
)
1972 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1975 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
1976 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
1977 uint8_t *buf
, int nb_sectors
)
1982 enabled
= bs
->io_limits_enabled
;
1983 bs
->io_limits_enabled
= false;
1984 ret
= bdrv_read(bs
, 0, buf
, 1);
1985 bs
->io_limits_enabled
= enabled
;
1989 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
1991 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1992 int nb_sectors
, int dirty
)
1995 unsigned long val
, idx
, bit
;
1997 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
1998 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
2000 for (; start
<= end
; start
++) {
2001 idx
= start
/ BITS_PER_LONG
;
2002 bit
= start
% BITS_PER_LONG
;
2003 val
= bs
->dirty_bitmap
[idx
];
2005 if (!(val
& (1UL << bit
))) {
2010 if (val
& (1UL << bit
)) {
2012 val
&= ~(1UL << bit
);
2015 bs
->dirty_bitmap
[idx
] = val
;
2019 /* Return < 0 if error. Important errors are:
2020 -EIO generic I/O error (may happen for all errors)
2021 -ENOMEDIUM No media inserted.
2022 -EINVAL Invalid sector number or nb_sectors
2023 -EACCES Trying to write a read-only device
2025 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2026 const uint8_t *buf
, int nb_sectors
)
2028 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
2031 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2032 void *buf
, int count1
)
2034 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2035 int len
, nb_sectors
, count
;
2040 /* first read to align to sector start */
2041 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2044 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2046 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2048 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2056 /* read the sectors "in place" */
2057 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2058 if (nb_sectors
> 0) {
2059 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2061 sector_num
+= nb_sectors
;
2062 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2067 /* add data from the last sector */
2069 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2071 memcpy(buf
, tmp_buf
, count
);
2076 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2077 const void *buf
, int count1
)
2079 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2080 int len
, nb_sectors
, count
;
2085 /* first write to align to sector start */
2086 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2089 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2091 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2093 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
2094 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2103 /* write the sectors "in place" */
2104 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2105 if (nb_sectors
> 0) {
2106 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2108 sector_num
+= nb_sectors
;
2109 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2114 /* add data from the last sector */
2116 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2118 memcpy(tmp_buf
, buf
, count
);
2119 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2126 * Writes to the file and ensures that no writes are reordered across this
2127 * request (acts as a barrier)
2129 * Returns 0 on success, -errno in error cases.
2131 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2132 const void *buf
, int count
)
2136 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2141 /* No flush needed for cache modes that already do it */
2142 if (bs
->enable_write_cache
) {
2149 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2150 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2152 /* Perform I/O through a temporary buffer so that users who scribble over
2153 * their read buffer while the operation is in progress do not end up
2154 * modifying the image file. This is critical for zero-copy guest I/O
2155 * where anything might happen inside guest memory.
2157 void *bounce_buffer
;
2159 BlockDriver
*drv
= bs
->drv
;
2161 QEMUIOVector bounce_qiov
;
2162 int64_t cluster_sector_num
;
2163 int cluster_nb_sectors
;
2167 /* Cover entire cluster so no additional backing file I/O is required when
2168 * allocating cluster in the image file.
2170 round_to_clusters(bs
, sector_num
, nb_sectors
,
2171 &cluster_sector_num
, &cluster_nb_sectors
);
2173 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2174 cluster_sector_num
, cluster_nb_sectors
);
2176 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2177 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2178 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2180 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2186 if (drv
->bdrv_co_write_zeroes
&&
2187 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2188 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2189 cluster_nb_sectors
);
2191 /* This does not change the data on the disk, it is not necessary
2192 * to flush even in cache=writethrough mode.
2194 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2199 /* It might be okay to ignore write errors for guest requests. If this
2200 * is a deliberate copy-on-read then we don't want to ignore the error.
2201 * Simply report it in all cases.
2206 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2207 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2208 nb_sectors
* BDRV_SECTOR_SIZE
);
2211 qemu_vfree(bounce_buffer
);
2216 * Handle a read request in coroutine context
2218 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
2219 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2220 BdrvRequestFlags flags
)
2222 BlockDriver
*drv
= bs
->drv
;
2223 BdrvTrackedRequest req
;
2229 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2233 /* throttling disk read I/O */
2234 if (bs
->io_limits_enabled
) {
2235 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
2238 if (bs
->copy_on_read
) {
2239 flags
|= BDRV_REQ_COPY_ON_READ
;
2241 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2242 bs
->copy_on_read_in_flight
++;
2245 if (bs
->copy_on_read_in_flight
) {
2246 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2249 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
2251 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2254 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2259 if (!ret
|| pnum
!= nb_sectors
) {
2260 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2265 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2268 tracked_request_end(&req
);
2270 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2271 bs
->copy_on_read_in_flight
--;
2277 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2278 int nb_sectors
, QEMUIOVector
*qiov
)
2280 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
2282 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
2285 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
2286 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2288 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
2290 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
2291 BDRV_REQ_COPY_ON_READ
);
2294 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
2295 int64_t sector_num
, int nb_sectors
)
2297 BlockDriver
*drv
= bs
->drv
;
2302 /* TODO Emulate only part of misaligned requests instead of letting block
2303 * drivers return -ENOTSUP and emulate everything */
2305 /* First try the efficient write zeroes operation */
2306 if (drv
->bdrv_co_write_zeroes
) {
2307 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2308 if (ret
!= -ENOTSUP
) {
2313 /* Fall back to bounce buffer if write zeroes is unsupported */
2314 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
2315 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
2316 memset(iov
.iov_base
, 0, iov
.iov_len
);
2317 qemu_iovec_init_external(&qiov
, &iov
, 1);
2319 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
2321 qemu_vfree(iov
.iov_base
);
2326 * Handle a write request in coroutine context
2328 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
2329 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2330 BdrvRequestFlags flags
)
2332 BlockDriver
*drv
= bs
->drv
;
2333 BdrvTrackedRequest req
;
2339 if (bs
->read_only
) {
2342 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2346 /* throttling disk write I/O */
2347 if (bs
->io_limits_enabled
) {
2348 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2351 if (bs
->copy_on_read_in_flight
) {
2352 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2355 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2357 if (flags
& BDRV_REQ_ZERO_WRITE
) {
2358 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2360 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2363 if (ret
== 0 && !bs
->enable_write_cache
) {
2364 ret
= bdrv_co_flush(bs
);
2367 if (bs
->dirty_bitmap
) {
2368 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2371 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2372 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2375 tracked_request_end(&req
);
2380 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2381 int nb_sectors
, QEMUIOVector
*qiov
)
2383 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2385 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2388 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2389 int64_t sector_num
, int nb_sectors
)
2391 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2393 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2394 BDRV_REQ_ZERO_WRITE
);
2398 * Truncate file to 'offset' bytes (needed only for file protocols)
2400 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2402 BlockDriver
*drv
= bs
->drv
;
2406 if (!drv
->bdrv_truncate
)
2410 if (bdrv_in_use(bs
))
2412 ret
= drv
->bdrv_truncate(bs
, offset
);
2414 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2415 bdrv_dev_resize_cb(bs
);
2421 * Length of a allocated file in bytes. Sparse files are counted by actual
2422 * allocated space. Return < 0 if error or unknown.
2424 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2426 BlockDriver
*drv
= bs
->drv
;
2430 if (drv
->bdrv_get_allocated_file_size
) {
2431 return drv
->bdrv_get_allocated_file_size(bs
);
2434 return bdrv_get_allocated_file_size(bs
->file
);
2440 * Length of a file in bytes. Return < 0 if error or unknown.
2442 int64_t bdrv_getlength(BlockDriverState
*bs
)
2444 BlockDriver
*drv
= bs
->drv
;
2448 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2449 if (drv
->bdrv_getlength
) {
2450 return drv
->bdrv_getlength(bs
);
2453 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2456 /* return 0 as number of sectors if no device present or error */
2457 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2460 length
= bdrv_getlength(bs
);
2464 length
= length
>> BDRV_SECTOR_BITS
;
2465 *nb_sectors_ptr
= length
;
2468 /* throttling disk io limits */
2469 void bdrv_set_io_limits(BlockDriverState
*bs
,
2470 BlockIOLimit
*io_limits
)
2472 bs
->io_limits
= *io_limits
;
2473 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2476 void bdrv_set_on_error(BlockDriverState
*bs
, BlockErrorAction on_read_error
,
2477 BlockErrorAction on_write_error
)
2479 bs
->on_read_error
= on_read_error
;
2480 bs
->on_write_error
= on_write_error
;
2483 BlockErrorAction
bdrv_get_on_error(BlockDriverState
*bs
, int is_read
)
2485 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2488 int bdrv_is_read_only(BlockDriverState
*bs
)
2490 return bs
->read_only
;
2493 int bdrv_is_sg(BlockDriverState
*bs
)
2498 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2500 return bs
->enable_write_cache
;
2503 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2505 bs
->enable_write_cache
= wce
;
2507 /* so a reopen() will preserve wce */
2509 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2511 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2515 int bdrv_is_encrypted(BlockDriverState
*bs
)
2517 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2519 return bs
->encrypted
;
2522 int bdrv_key_required(BlockDriverState
*bs
)
2524 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2526 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2528 return (bs
->encrypted
&& !bs
->valid_key
);
2531 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2534 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2535 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2541 if (!bs
->encrypted
) {
2543 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2546 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2549 } else if (!bs
->valid_key
) {
2551 /* call the change callback now, we skipped it on open */
2552 bdrv_dev_change_media_cb(bs
, true);
2557 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2559 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2562 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2567 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2568 it(opaque
, drv
->format_name
);
2572 BlockDriverState
*bdrv_find(const char *name
)
2574 BlockDriverState
*bs
;
2576 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2577 if (!strcmp(name
, bs
->device_name
)) {
2584 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2587 return QTAILQ_FIRST(&bdrv_states
);
2589 return QTAILQ_NEXT(bs
, list
);
2592 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2594 BlockDriverState
*bs
;
2596 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2601 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2603 return bs
->device_name
;
2606 int bdrv_get_flags(BlockDriverState
*bs
)
2608 return bs
->open_flags
;
2611 void bdrv_flush_all(void)
2613 BlockDriverState
*bs
;
2615 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2620 int bdrv_has_zero_init(BlockDriverState
*bs
)
2624 if (bs
->drv
->bdrv_has_zero_init
) {
2625 return bs
->drv
->bdrv_has_zero_init(bs
);
2631 typedef struct BdrvCoIsAllocatedData
{
2632 BlockDriverState
*bs
;
2638 } BdrvCoIsAllocatedData
;
2641 * Returns true iff the specified sector is present in the disk image. Drivers
2642 * not implementing the functionality are assumed to not support backing files,
2643 * hence all their sectors are reported as allocated.
2645 * If 'sector_num' is beyond the end of the disk image the return value is 0
2646 * and 'pnum' is set to 0.
2648 * 'pnum' is set to the number of sectors (including and immediately following
2649 * the specified sector) that are known to be in the same
2650 * allocated/unallocated state.
2652 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2653 * beyond the end of the disk image it will be clamped.
2655 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2656 int nb_sectors
, int *pnum
)
2660 if (sector_num
>= bs
->total_sectors
) {
2665 n
= bs
->total_sectors
- sector_num
;
2666 if (n
< nb_sectors
) {
2670 if (!bs
->drv
->bdrv_co_is_allocated
) {
2675 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2678 /* Coroutine wrapper for bdrv_is_allocated() */
2679 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2681 BdrvCoIsAllocatedData
*data
= opaque
;
2682 BlockDriverState
*bs
= data
->bs
;
2684 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2690 * Synchronous wrapper around bdrv_co_is_allocated().
2692 * See bdrv_co_is_allocated() for details.
2694 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2698 BdrvCoIsAllocatedData data
= {
2700 .sector_num
= sector_num
,
2701 .nb_sectors
= nb_sectors
,
2706 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2707 qemu_coroutine_enter(co
, &data
);
2708 while (!data
.done
) {
2715 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2717 * Return true if the given sector is allocated in any image between
2718 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2719 * sector is allocated in any image of the chain. Return false otherwise.
2721 * 'pnum' is set to the number of sectors (including and immediately following
2722 * the specified sector) that are known to be in the same
2723 * allocated/unallocated state.
2726 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2727 BlockDriverState
*base
,
2729 int nb_sectors
, int *pnum
)
2731 BlockDriverState
*intermediate
;
2732 int ret
, n
= nb_sectors
;
2735 while (intermediate
&& intermediate
!= base
) {
2737 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2747 * [sector_num, nb_sectors] is unallocated on top but intermediate
2750 * [sector_num+x, nr_sectors] allocated.
2752 if (n
> pnum_inter
) {
2756 intermediate
= intermediate
->backing_hd
;
2763 BlockInfoList
*qmp_query_block(Error
**errp
)
2765 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2766 BlockDriverState
*bs
;
2768 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2769 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2771 info
->value
= g_malloc0(sizeof(*info
->value
));
2772 info
->value
->device
= g_strdup(bs
->device_name
);
2773 info
->value
->type
= g_strdup("unknown");
2774 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2775 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2777 if (bdrv_dev_has_removable_media(bs
)) {
2778 info
->value
->has_tray_open
= true;
2779 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2782 if (bdrv_iostatus_is_enabled(bs
)) {
2783 info
->value
->has_io_status
= true;
2784 info
->value
->io_status
= bs
->iostatus
;
2788 info
->value
->has_inserted
= true;
2789 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2790 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2791 info
->value
->inserted
->ro
= bs
->read_only
;
2792 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2793 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2794 info
->value
->inserted
->encryption_key_missing
= bdrv_key_required(bs
);
2795 if (bs
->backing_file
[0]) {
2796 info
->value
->inserted
->has_backing_file
= true;
2797 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2800 info
->value
->inserted
->backing_file_depth
=
2801 bdrv_get_backing_file_depth(bs
);
2803 if (bs
->io_limits_enabled
) {
2804 info
->value
->inserted
->bps
=
2805 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2806 info
->value
->inserted
->bps_rd
=
2807 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2808 info
->value
->inserted
->bps_wr
=
2809 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2810 info
->value
->inserted
->iops
=
2811 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2812 info
->value
->inserted
->iops_rd
=
2813 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2814 info
->value
->inserted
->iops_wr
=
2815 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2819 /* XXX: waiting for the qapi to support GSList */
2821 head
= cur_item
= info
;
2823 cur_item
->next
= info
;
2831 /* Consider exposing this as a full fledged QMP command */
2832 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2836 s
= g_malloc0(sizeof(*s
));
2838 if (bs
->device_name
[0]) {
2839 s
->has_device
= true;
2840 s
->device
= g_strdup(bs
->device_name
);
2843 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2844 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2845 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2846 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2847 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2848 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2849 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2850 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2851 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2852 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2855 s
->has_parent
= true;
2856 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2862 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2864 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2865 BlockDriverState
*bs
;
2867 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2868 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2869 info
->value
= qmp_query_blockstat(bs
, NULL
);
2871 /* XXX: waiting for the qapi to support GSList */
2873 head
= cur_item
= info
;
2875 cur_item
->next
= info
;
2883 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2885 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2886 return bs
->backing_file
;
2887 else if (bs
->encrypted
)
2888 return bs
->filename
;
2893 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2894 char *filename
, int filename_size
)
2896 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2899 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2900 const uint8_t *buf
, int nb_sectors
)
2902 BlockDriver
*drv
= bs
->drv
;
2905 if (!drv
->bdrv_write_compressed
)
2907 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2910 if (bs
->dirty_bitmap
) {
2911 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2914 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2917 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2919 BlockDriver
*drv
= bs
->drv
;
2922 if (!drv
->bdrv_get_info
)
2924 memset(bdi
, 0, sizeof(*bdi
));
2925 return drv
->bdrv_get_info(bs
, bdi
);
2928 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2929 int64_t pos
, int size
)
2931 BlockDriver
*drv
= bs
->drv
;
2934 if (drv
->bdrv_save_vmstate
)
2935 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2937 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2941 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2942 int64_t pos
, int size
)
2944 BlockDriver
*drv
= bs
->drv
;
2947 if (drv
->bdrv_load_vmstate
)
2948 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2950 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2954 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2956 BlockDriver
*drv
= bs
->drv
;
2958 if (!drv
|| !drv
->bdrv_debug_event
) {
2962 drv
->bdrv_debug_event(bs
, event
);
2966 /**************************************************************/
2967 /* handling of snapshots */
2969 int bdrv_can_snapshot(BlockDriverState
*bs
)
2971 BlockDriver
*drv
= bs
->drv
;
2972 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
2976 if (!drv
->bdrv_snapshot_create
) {
2977 if (bs
->file
!= NULL
) {
2978 return bdrv_can_snapshot(bs
->file
);
2986 int bdrv_is_snapshot(BlockDriverState
*bs
)
2988 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2991 BlockDriverState
*bdrv_snapshots(void)
2993 BlockDriverState
*bs
;
2996 return bs_snapshots
;
3000 while ((bs
= bdrv_next(bs
))) {
3001 if (bdrv_can_snapshot(bs
)) {
3009 int bdrv_snapshot_create(BlockDriverState
*bs
,
3010 QEMUSnapshotInfo
*sn_info
)
3012 BlockDriver
*drv
= bs
->drv
;
3015 if (drv
->bdrv_snapshot_create
)
3016 return drv
->bdrv_snapshot_create(bs
, sn_info
);
3018 return bdrv_snapshot_create(bs
->file
, sn_info
);
3022 int bdrv_snapshot_goto(BlockDriverState
*bs
,
3023 const char *snapshot_id
)
3025 BlockDriver
*drv
= bs
->drv
;
3030 if (drv
->bdrv_snapshot_goto
)
3031 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
3034 drv
->bdrv_close(bs
);
3035 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
3036 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
3038 bdrv_delete(bs
->file
);
3048 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
3050 BlockDriver
*drv
= bs
->drv
;
3053 if (drv
->bdrv_snapshot_delete
)
3054 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
3056 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
3060 int bdrv_snapshot_list(BlockDriverState
*bs
,
3061 QEMUSnapshotInfo
**psn_info
)
3063 BlockDriver
*drv
= bs
->drv
;
3066 if (drv
->bdrv_snapshot_list
)
3067 return drv
->bdrv_snapshot_list(bs
, psn_info
);
3069 return bdrv_snapshot_list(bs
->file
, psn_info
);
3073 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
3074 const char *snapshot_name
)
3076 BlockDriver
*drv
= bs
->drv
;
3080 if (!bs
->read_only
) {
3083 if (drv
->bdrv_snapshot_load_tmp
) {
3084 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
3089 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3090 const char *backing_file
)
3096 if (bs
->backing_hd
) {
3097 if (strcmp(bs
->backing_file
, backing_file
) == 0) {
3098 return bs
->backing_hd
;
3100 return bdrv_find_backing_image(bs
->backing_hd
, backing_file
);
3107 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3113 if (!bs
->backing_hd
) {
3117 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3120 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
3122 BlockDriverState
*curr_bs
= NULL
;
3130 while (curr_bs
->backing_hd
) {
3131 curr_bs
= curr_bs
->backing_hd
;
3136 #define NB_SUFFIXES 4
3138 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
3140 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
3145 snprintf(buf
, buf_size
, "%" PRId64
, size
);
3148 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
3149 if (size
< (10 * base
)) {
3150 snprintf(buf
, buf_size
, "%0.1f%c",
3151 (double)size
/ base
,
3154 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
3155 snprintf(buf
, buf_size
, "%" PRId64
"%c",
3156 ((size
+ (base
>> 1)) / base
),
3166 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
3168 char buf1
[128], date_buf
[128], clock_buf
[128];
3178 snprintf(buf
, buf_size
,
3179 "%-10s%-20s%7s%20s%15s",
3180 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3184 ptm
= localtime(&ti
);
3185 strftime(date_buf
, sizeof(date_buf
),
3186 "%Y-%m-%d %H:%M:%S", ptm
);
3188 localtime_r(&ti
, &tm
);
3189 strftime(date_buf
, sizeof(date_buf
),
3190 "%Y-%m-%d %H:%M:%S", &tm
);
3192 secs
= sn
->vm_clock_nsec
/ 1000000000;
3193 snprintf(clock_buf
, sizeof(clock_buf
),
3194 "%02d:%02d:%02d.%03d",
3196 (int)((secs
/ 60) % 60),
3198 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
3199 snprintf(buf
, buf_size
,
3200 "%-10s%-20s%7s%20s%15s",
3201 sn
->id_str
, sn
->name
,
3202 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
3209 /**************************************************************/
3212 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3213 QEMUIOVector
*qiov
, int nb_sectors
,
3214 BlockDriverCompletionFunc
*cb
, void *opaque
)
3216 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3218 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3222 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3223 QEMUIOVector
*qiov
, int nb_sectors
,
3224 BlockDriverCompletionFunc
*cb
, void *opaque
)
3226 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3228 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3233 typedef struct MultiwriteCB
{
3238 BlockDriverCompletionFunc
*cb
;
3240 QEMUIOVector
*free_qiov
;
3244 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3248 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3249 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3250 if (mcb
->callbacks
[i
].free_qiov
) {
3251 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3253 g_free(mcb
->callbacks
[i
].free_qiov
);
3257 static void multiwrite_cb(void *opaque
, int ret
)
3259 MultiwriteCB
*mcb
= opaque
;
3261 trace_multiwrite_cb(mcb
, ret
);
3263 if (ret
< 0 && !mcb
->error
) {
3267 mcb
->num_requests
--;
3268 if (mcb
->num_requests
== 0) {
3269 multiwrite_user_cb(mcb
);
3274 static int multiwrite_req_compare(const void *a
, const void *b
)
3276 const BlockRequest
*req1
= a
, *req2
= b
;
3279 * Note that we can't simply subtract req2->sector from req1->sector
3280 * here as that could overflow the return value.
3282 if (req1
->sector
> req2
->sector
) {
3284 } else if (req1
->sector
< req2
->sector
) {
3292 * Takes a bunch of requests and tries to merge them. Returns the number of
3293 * requests that remain after merging.
3295 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3296 int num_reqs
, MultiwriteCB
*mcb
)
3300 // Sort requests by start sector
3301 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3303 // Check if adjacent requests touch the same clusters. If so, combine them,
3304 // filling up gaps with zero sectors.
3306 for (i
= 1; i
< num_reqs
; i
++) {
3308 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3310 // Handle exactly sequential writes and overlapping writes.
3311 if (reqs
[i
].sector
<= oldreq_last
) {
3315 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3321 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3322 qemu_iovec_init(qiov
,
3323 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3325 // Add the first request to the merged one. If the requests are
3326 // overlapping, drop the last sectors of the first request.
3327 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3328 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
3330 // We should need to add any zeros between the two requests
3331 assert (reqs
[i
].sector
<= oldreq_last
);
3333 // Add the second request
3334 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
3336 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3337 reqs
[outidx
].qiov
= qiov
;
3339 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3342 reqs
[outidx
].sector
= reqs
[i
].sector
;
3343 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3344 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3352 * Submit multiple AIO write requests at once.
3354 * On success, the function returns 0 and all requests in the reqs array have
3355 * been submitted. In error case this function returns -1, and any of the
3356 * requests may or may not be submitted yet. In particular, this means that the
3357 * callback will be called for some of the requests, for others it won't. The
3358 * caller must check the error field of the BlockRequest to wait for the right
3359 * callbacks (if error != 0, no callback will be called).
3361 * The implementation may modify the contents of the reqs array, e.g. to merge
3362 * requests. However, the fields opaque and error are left unmodified as they
3363 * are used to signal failure for a single request to the caller.
3365 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3370 /* don't submit writes if we don't have a medium */
3371 if (bs
->drv
== NULL
) {
3372 for (i
= 0; i
< num_reqs
; i
++) {
3373 reqs
[i
].error
= -ENOMEDIUM
;
3378 if (num_reqs
== 0) {
3382 // Create MultiwriteCB structure
3383 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3384 mcb
->num_requests
= 0;
3385 mcb
->num_callbacks
= num_reqs
;
3387 for (i
= 0; i
< num_reqs
; i
++) {
3388 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3389 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3392 // Check for mergable requests
3393 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3395 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3397 /* Run the aio requests. */
3398 mcb
->num_requests
= num_reqs
;
3399 for (i
= 0; i
< num_reqs
; i
++) {
3400 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3401 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3407 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3409 acb
->pool
->cancel(acb
);
3412 /* block I/O throttling */
3413 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3414 bool is_write
, double elapsed_time
, uint64_t *wait
)
3416 uint64_t bps_limit
= 0;
3417 double bytes_limit
, bytes_base
, bytes_res
;
3418 double slice_time
, wait_time
;
3420 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3421 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3422 } else if (bs
->io_limits
.bps
[is_write
]) {
3423 bps_limit
= bs
->io_limits
.bps
[is_write
];
3432 slice_time
= bs
->slice_end
- bs
->slice_start
;
3433 slice_time
/= (NANOSECONDS_PER_SECOND
);
3434 bytes_limit
= bps_limit
* slice_time
;
3435 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3436 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3437 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3440 /* bytes_base: the bytes of data which have been read/written; and
3441 * it is obtained from the history statistic info.
3442 * bytes_res: the remaining bytes of data which need to be read/written.
3443 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3444 * the total time for completing reading/writting all data.
3446 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3448 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3456 /* Calc approx time to dispatch */
3457 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3459 /* When the I/O rate at runtime exceeds the limits,
3460 * bs->slice_end need to be extended in order that the current statistic
3461 * info can be kept until the timer fire, so it is increased and tuned
3462 * based on the result of experiment.
3464 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3465 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3467 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3473 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3474 double elapsed_time
, uint64_t *wait
)
3476 uint64_t iops_limit
= 0;
3477 double ios_limit
, ios_base
;
3478 double slice_time
, wait_time
;
3480 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3481 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3482 } else if (bs
->io_limits
.iops
[is_write
]) {
3483 iops_limit
= bs
->io_limits
.iops
[is_write
];
3492 slice_time
= bs
->slice_end
- bs
->slice_start
;
3493 slice_time
/= (NANOSECONDS_PER_SECOND
);
3494 ios_limit
= iops_limit
* slice_time
;
3495 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3496 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3497 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3500 if (ios_base
+ 1 <= ios_limit
) {
3508 /* Calc approx time to dispatch */
3509 wait_time
= (ios_base
+ 1) / iops_limit
;
3510 if (wait_time
> elapsed_time
) {
3511 wait_time
= wait_time
- elapsed_time
;
3516 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3517 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3519 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3525 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3526 bool is_write
, int64_t *wait
)
3528 int64_t now
, max_wait
;
3529 uint64_t bps_wait
= 0, iops_wait
= 0;
3530 double elapsed_time
;
3531 int bps_ret
, iops_ret
;
3533 now
= qemu_get_clock_ns(vm_clock
);
3534 if ((bs
->slice_start
< now
)
3535 && (bs
->slice_end
> now
)) {
3536 bs
->slice_end
= now
+ bs
->slice_time
;
3538 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3539 bs
->slice_start
= now
;
3540 bs
->slice_end
= now
+ bs
->slice_time
;
3542 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3543 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3545 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3546 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3549 elapsed_time
= now
- bs
->slice_start
;
3550 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3552 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3553 is_write
, elapsed_time
, &bps_wait
);
3554 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3555 elapsed_time
, &iops_wait
);
3556 if (bps_ret
|| iops_ret
) {
3557 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3562 now
= qemu_get_clock_ns(vm_clock
);
3563 if (bs
->slice_end
< now
+ max_wait
) {
3564 bs
->slice_end
= now
+ max_wait
;
3577 /**************************************************************/
3578 /* async block device emulation */
3580 typedef struct BlockDriverAIOCBSync
{
3581 BlockDriverAIOCB common
;
3584 /* vector translation state */
3588 } BlockDriverAIOCBSync
;
3590 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3592 BlockDriverAIOCBSync
*acb
=
3593 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3594 qemu_bh_delete(acb
->bh
);
3596 qemu_aio_release(acb
);
3599 static AIOPool bdrv_em_aio_pool
= {
3600 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3601 .cancel
= bdrv_aio_cancel_em
,
3604 static void bdrv_aio_bh_cb(void *opaque
)
3606 BlockDriverAIOCBSync
*acb
= opaque
;
3609 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3610 qemu_vfree(acb
->bounce
);
3611 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3612 qemu_bh_delete(acb
->bh
);
3614 qemu_aio_release(acb
);
3617 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3621 BlockDriverCompletionFunc
*cb
,
3626 BlockDriverAIOCBSync
*acb
;
3628 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3629 acb
->is_write
= is_write
;
3631 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3632 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3635 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3636 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3638 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3641 qemu_bh_schedule(acb
->bh
);
3643 return &acb
->common
;
3646 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3647 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3648 BlockDriverCompletionFunc
*cb
, void *opaque
)
3650 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3653 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3654 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3655 BlockDriverCompletionFunc
*cb
, void *opaque
)
3657 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3661 typedef struct BlockDriverAIOCBCoroutine
{
3662 BlockDriverAIOCB common
;
3666 } BlockDriverAIOCBCoroutine
;
3668 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3673 static AIOPool bdrv_em_co_aio_pool
= {
3674 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3675 .cancel
= bdrv_aio_co_cancel_em
,
3678 static void bdrv_co_em_bh(void *opaque
)
3680 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3682 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3683 qemu_bh_delete(acb
->bh
);
3684 qemu_aio_release(acb
);
3687 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3688 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3690 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3691 BlockDriverState
*bs
= acb
->common
.bs
;
3693 if (!acb
->is_write
) {
3694 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3695 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3697 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3698 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3701 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3702 qemu_bh_schedule(acb
->bh
);
3705 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3709 BlockDriverCompletionFunc
*cb
,
3714 BlockDriverAIOCBCoroutine
*acb
;
3716 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3717 acb
->req
.sector
= sector_num
;
3718 acb
->req
.nb_sectors
= nb_sectors
;
3719 acb
->req
.qiov
= qiov
;
3720 acb
->is_write
= is_write
;
3722 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3723 qemu_coroutine_enter(co
, acb
);
3725 return &acb
->common
;
3728 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3730 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3731 BlockDriverState
*bs
= acb
->common
.bs
;
3733 acb
->req
.error
= bdrv_co_flush(bs
);
3734 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3735 qemu_bh_schedule(acb
->bh
);
3738 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3739 BlockDriverCompletionFunc
*cb
, void *opaque
)
3741 trace_bdrv_aio_flush(bs
, opaque
);
3744 BlockDriverAIOCBCoroutine
*acb
;
3746 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3747 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3748 qemu_coroutine_enter(co
, acb
);
3750 return &acb
->common
;
3753 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3755 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3756 BlockDriverState
*bs
= acb
->common
.bs
;
3758 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3759 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3760 qemu_bh_schedule(acb
->bh
);
3763 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3764 int64_t sector_num
, int nb_sectors
,
3765 BlockDriverCompletionFunc
*cb
, void *opaque
)
3768 BlockDriverAIOCBCoroutine
*acb
;
3770 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3772 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3773 acb
->req
.sector
= sector_num
;
3774 acb
->req
.nb_sectors
= nb_sectors
;
3775 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3776 qemu_coroutine_enter(co
, acb
);
3778 return &acb
->common
;
3781 void bdrv_init(void)
3783 module_call_init(MODULE_INIT_BLOCK
);
3786 void bdrv_init_with_whitelist(void)
3788 use_bdrv_whitelist
= 1;
3792 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3793 BlockDriverCompletionFunc
*cb
, void *opaque
)
3795 BlockDriverAIOCB
*acb
;
3797 if (pool
->free_aiocb
) {
3798 acb
= pool
->free_aiocb
;
3799 pool
->free_aiocb
= acb
->next
;
3801 acb
= g_malloc0(pool
->aiocb_size
);
3806 acb
->opaque
= opaque
;
3810 void qemu_aio_release(void *p
)
3812 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3813 AIOPool
*pool
= acb
->pool
;
3814 acb
->next
= pool
->free_aiocb
;
3815 pool
->free_aiocb
= acb
;
3818 /**************************************************************/
3819 /* Coroutine block device emulation */
3821 typedef struct CoroutineIOCompletion
{
3822 Coroutine
*coroutine
;
3824 } CoroutineIOCompletion
;
3826 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3828 CoroutineIOCompletion
*co
= opaque
;
3831 qemu_coroutine_enter(co
->coroutine
, NULL
);
3834 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3835 int nb_sectors
, QEMUIOVector
*iov
,
3838 CoroutineIOCompletion co
= {
3839 .coroutine
= qemu_coroutine_self(),
3841 BlockDriverAIOCB
*acb
;
3844 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3845 bdrv_co_io_em_complete
, &co
);
3847 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3848 bdrv_co_io_em_complete
, &co
);
3851 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3855 qemu_coroutine_yield();
3860 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3861 int64_t sector_num
, int nb_sectors
,
3864 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3867 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3868 int64_t sector_num
, int nb_sectors
,
3871 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3874 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3876 RwCo
*rwco
= opaque
;
3878 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3881 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3885 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3889 /* Write back cached data to the OS even with cache=unsafe */
3890 if (bs
->drv
->bdrv_co_flush_to_os
) {
3891 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3897 /* But don't actually force it to the disk with cache=unsafe */
3898 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3902 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3903 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
3904 } else if (bs
->drv
->bdrv_aio_flush
) {
3905 BlockDriverAIOCB
*acb
;
3906 CoroutineIOCompletion co
= {
3907 .coroutine
= qemu_coroutine_self(),
3910 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
3914 qemu_coroutine_yield();
3919 * Some block drivers always operate in either writethrough or unsafe
3920 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3921 * know how the server works (because the behaviour is hardcoded or
3922 * depends on server-side configuration), so we can't ensure that
3923 * everything is safe on disk. Returning an error doesn't work because
3924 * that would break guests even if the server operates in writethrough
3927 * Let's hope the user knows what he's doing.
3935 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
3936 * in the case of cache=unsafe, so there are no useless flushes.
3939 return bdrv_co_flush(bs
->file
);
3942 void bdrv_invalidate_cache(BlockDriverState
*bs
)
3944 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
3945 bs
->drv
->bdrv_invalidate_cache(bs
);
3949 void bdrv_invalidate_cache_all(void)
3951 BlockDriverState
*bs
;
3953 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3954 bdrv_invalidate_cache(bs
);
3958 void bdrv_clear_incoming_migration_all(void)
3960 BlockDriverState
*bs
;
3962 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3963 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
3967 int bdrv_flush(BlockDriverState
*bs
)
3975 if (qemu_in_coroutine()) {
3976 /* Fast-path if already in coroutine context */
3977 bdrv_flush_co_entry(&rwco
);
3979 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
3980 qemu_coroutine_enter(co
, &rwco
);
3981 while (rwco
.ret
== NOT_DONE
) {
3989 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
3991 RwCo
*rwco
= opaque
;
3993 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
3996 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4001 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4003 } else if (bs
->read_only
) {
4005 } else if (bs
->drv
->bdrv_co_discard
) {
4006 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
4007 } else if (bs
->drv
->bdrv_aio_discard
) {
4008 BlockDriverAIOCB
*acb
;
4009 CoroutineIOCompletion co
= {
4010 .coroutine
= qemu_coroutine_self(),
4013 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4014 bdrv_co_io_em_complete
, &co
);
4018 qemu_coroutine_yield();
4026 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4031 .sector_num
= sector_num
,
4032 .nb_sectors
= nb_sectors
,
4036 if (qemu_in_coroutine()) {
4037 /* Fast-path if already in coroutine context */
4038 bdrv_discard_co_entry(&rwco
);
4040 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4041 qemu_coroutine_enter(co
, &rwco
);
4042 while (rwco
.ret
== NOT_DONE
) {
4050 /**************************************************************/
4051 /* removable device support */
4054 * Return TRUE if the media is present
4056 int bdrv_is_inserted(BlockDriverState
*bs
)
4058 BlockDriver
*drv
= bs
->drv
;
4062 if (!drv
->bdrv_is_inserted
)
4064 return drv
->bdrv_is_inserted(bs
);
4068 * Return whether the media changed since the last call to this
4069 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4071 int bdrv_media_changed(BlockDriverState
*bs
)
4073 BlockDriver
*drv
= bs
->drv
;
4075 if (drv
&& drv
->bdrv_media_changed
) {
4076 return drv
->bdrv_media_changed(bs
);
4082 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4084 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4086 BlockDriver
*drv
= bs
->drv
;
4088 if (drv
&& drv
->bdrv_eject
) {
4089 drv
->bdrv_eject(bs
, eject_flag
);
4092 if (bs
->device_name
[0] != '\0') {
4093 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4098 * Lock or unlock the media (if it is locked, the user won't be able
4099 * to eject it manually).
4101 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4103 BlockDriver
*drv
= bs
->drv
;
4105 trace_bdrv_lock_medium(bs
, locked
);
4107 if (drv
&& drv
->bdrv_lock_medium
) {
4108 drv
->bdrv_lock_medium(bs
, locked
);
4112 /* needed for generic scsi interface */
4114 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
4116 BlockDriver
*drv
= bs
->drv
;
4118 if (drv
&& drv
->bdrv_ioctl
)
4119 return drv
->bdrv_ioctl(bs
, req
, buf
);
4123 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
4124 unsigned long int req
, void *buf
,
4125 BlockDriverCompletionFunc
*cb
, void *opaque
)
4127 BlockDriver
*drv
= bs
->drv
;
4129 if (drv
&& drv
->bdrv_aio_ioctl
)
4130 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
4134 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
4136 bs
->buffer_alignment
= align
;
4139 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
4141 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
4144 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
4146 int64_t bitmap_size
;
4148 bs
->dirty_count
= 0;
4150 if (!bs
->dirty_bitmap
) {
4151 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
4152 BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
- 1;
4153 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
;
4155 bs
->dirty_bitmap
= g_new0(unsigned long, bitmap_size
);
4158 if (bs
->dirty_bitmap
) {
4159 g_free(bs
->dirty_bitmap
);
4160 bs
->dirty_bitmap
= NULL
;
4165 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4167 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
4169 if (bs
->dirty_bitmap
&&
4170 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
4171 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
4172 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
4178 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4181 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
4184 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4186 return bs
->dirty_count
;
4189 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4191 assert(bs
->in_use
!= in_use
);
4192 bs
->in_use
= in_use
;
4195 int bdrv_in_use(BlockDriverState
*bs
)
4200 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4202 bs
->iostatus_enabled
= true;
4203 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4206 /* The I/O status is only enabled if the drive explicitly
4207 * enables it _and_ the VM is configured to stop on errors */
4208 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4210 return (bs
->iostatus_enabled
&&
4211 (bs
->on_write_error
== BLOCK_ERR_STOP_ENOSPC
||
4212 bs
->on_write_error
== BLOCK_ERR_STOP_ANY
||
4213 bs
->on_read_error
== BLOCK_ERR_STOP_ANY
));
4216 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4218 bs
->iostatus_enabled
= false;
4221 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4223 if (bdrv_iostatus_is_enabled(bs
)) {
4224 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4228 /* XXX: Today this is set by device models because it makes the implementation
4229 quite simple. However, the block layer knows about the error, so it's
4230 possible to implement this without device models being involved */
4231 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4233 if (bdrv_iostatus_is_enabled(bs
) &&
4234 bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4236 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4237 BLOCK_DEVICE_IO_STATUS_FAILED
;
4242 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4243 enum BlockAcctType type
)
4245 assert(type
< BDRV_MAX_IOTYPE
);
4247 cookie
->bytes
= bytes
;
4248 cookie
->start_time_ns
= get_clock();
4249 cookie
->type
= type
;
4253 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4255 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4257 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4258 bs
->nr_ops
[cookie
->type
]++;
4259 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4262 int bdrv_img_create(const char *filename
, const char *fmt
,
4263 const char *base_filename
, const char *base_fmt
,
4264 char *options
, uint64_t img_size
, int flags
)
4266 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4267 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4268 BlockDriverState
*bs
= NULL
;
4269 BlockDriver
*drv
, *proto_drv
;
4270 BlockDriver
*backing_drv
= NULL
;
4273 /* Find driver and parse its options */
4274 drv
= bdrv_find_format(fmt
);
4276 error_report("Unknown file format '%s'", fmt
);
4281 proto_drv
= bdrv_find_protocol(filename
);
4283 error_report("Unknown protocol '%s'", filename
);
4288 create_options
= append_option_parameters(create_options
,
4289 drv
->create_options
);
4290 create_options
= append_option_parameters(create_options
,
4291 proto_drv
->create_options
);
4293 /* Create parameter list with default values */
4294 param
= parse_option_parameters("", create_options
, param
);
4296 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4298 /* Parse -o options */
4300 param
= parse_option_parameters(options
, create_options
, param
);
4301 if (param
== NULL
) {
4302 error_report("Invalid options for file format '%s'.", fmt
);
4308 if (base_filename
) {
4309 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4311 error_report("Backing file not supported for file format '%s'",
4319 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4320 error_report("Backing file format not supported for file "
4321 "format '%s'", fmt
);
4327 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4328 if (backing_file
&& backing_file
->value
.s
) {
4329 if (!strcmp(filename
, backing_file
->value
.s
)) {
4330 error_report("Error: Trying to create an image with the "
4331 "same filename as the backing file");
4337 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4338 if (backing_fmt
&& backing_fmt
->value
.s
) {
4339 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4341 error_report("Unknown backing file format '%s'",
4342 backing_fmt
->value
.s
);
4348 // The size for the image must always be specified, with one exception:
4349 // If we are using a backing file, we can obtain the size from there
4350 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4351 if (size
&& size
->value
.n
== -1) {
4352 if (backing_file
&& backing_file
->value
.s
) {
4357 /* backing files always opened read-only */
4359 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4363 ret
= bdrv_open(bs
, backing_file
->value
.s
, back_flags
, backing_drv
);
4365 error_report("Could not open '%s'", backing_file
->value
.s
);
4368 bdrv_get_geometry(bs
, &size
);
4371 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4372 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4374 error_report("Image creation needs a size parameter");
4380 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4381 print_option_parameters(param
);
4384 ret
= bdrv_create(drv
, filename
, param
);
4387 if (ret
== -ENOTSUP
) {
4388 error_report("Formatting or formatting option not supported for "
4389 "file format '%s'", fmt
);
4390 } else if (ret
== -EFBIG
) {
4391 error_report("The image size is too large for file format '%s'",
4394 error_report("%s: error while creating %s: %s", filename
, fmt
,
4400 free_option_parameters(create_options
);
4401 free_option_parameters(param
);
4410 void *block_job_create(const BlockJobType
*job_type
, BlockDriverState
*bs
,
4411 int64_t speed
, BlockDriverCompletionFunc
*cb
,
4412 void *opaque
, Error
**errp
)
4416 if (bs
->job
|| bdrv_in_use(bs
)) {
4417 error_set(errp
, QERR_DEVICE_IN_USE
, bdrv_get_device_name(bs
));
4420 bdrv_set_in_use(bs
, 1);
4422 job
= g_malloc0(job_type
->instance_size
);
4423 job
->job_type
= job_type
;
4426 job
->opaque
= opaque
;
4430 /* Only set speed when necessary to avoid NotSupported error */
4432 Error
*local_err
= NULL
;
4434 block_job_set_speed(job
, speed
, &local_err
);
4435 if (error_is_set(&local_err
)) {
4438 bdrv_set_in_use(bs
, 0);
4439 error_propagate(errp
, local_err
);
4446 void block_job_complete(BlockJob
*job
, int ret
)
4448 BlockDriverState
*bs
= job
->bs
;
4450 assert(bs
->job
== job
);
4451 job
->cb(job
->opaque
, ret
);
4454 bdrv_set_in_use(bs
, 0);
4457 void block_job_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
4459 Error
*local_err
= NULL
;
4461 if (!job
->job_type
->set_speed
) {
4462 error_set(errp
, QERR_NOT_SUPPORTED
);
4465 job
->job_type
->set_speed(job
, speed
, &local_err
);
4466 if (error_is_set(&local_err
)) {
4467 error_propagate(errp
, local_err
);
4474 void block_job_cancel(BlockJob
*job
)
4476 job
->cancelled
= true;
4477 if (job
->co
&& !job
->busy
) {
4478 qemu_coroutine_enter(job
->co
, NULL
);
4482 bool block_job_is_cancelled(BlockJob
*job
)
4484 return job
->cancelled
;
4487 struct BlockCancelData
{
4489 BlockDriverCompletionFunc
*cb
;
4495 static void block_job_cancel_cb(void *opaque
, int ret
)
4497 struct BlockCancelData
*data
= opaque
;
4499 data
->cancelled
= block_job_is_cancelled(data
->job
);
4501 data
->cb(data
->opaque
, ret
);
4504 int block_job_cancel_sync(BlockJob
*job
)
4506 struct BlockCancelData data
;
4507 BlockDriverState
*bs
= job
->bs
;
4509 assert(bs
->job
== job
);
4511 /* Set up our own callback to store the result and chain to
4512 * the original callback.
4516 data
.opaque
= job
->opaque
;
4517 data
.ret
= -EINPROGRESS
;
4518 job
->cb
= block_job_cancel_cb
;
4519 job
->opaque
= &data
;
4520 block_job_cancel(job
);
4521 while (data
.ret
== -EINPROGRESS
) {
4524 return (data
.cancelled
&& data
.ret
== 0) ? -ECANCELED
: data
.ret
;
4527 void block_job_sleep_ns(BlockJob
*job
, QEMUClock
*clock
, int64_t ns
)
4529 /* Check cancellation *before* setting busy = false, too! */
4530 if (!block_job_is_cancelled(job
)) {
4532 co_sleep_ns(clock
, ns
);