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"
33 #include "qemu-coroutine.h"
34 #include "qmp-commands.h"
35 #include "qemu-timer.h"
38 #include <sys/types.h>
40 #include <sys/ioctl.h>
41 #include <sys/queue.h>
51 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
54 BDRV_REQ_COPY_ON_READ
= 0x1,
55 BDRV_REQ_ZERO_WRITE
= 0x2,
58 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
59 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
60 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
61 BlockDriverCompletionFunc
*cb
, void *opaque
);
62 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
63 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
64 BlockDriverCompletionFunc
*cb
, void *opaque
);
65 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
66 int64_t sector_num
, int nb_sectors
,
68 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
69 int64_t sector_num
, int nb_sectors
,
71 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
72 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
73 BdrvRequestFlags flags
);
74 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
75 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
76 BdrvRequestFlags flags
);
77 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
81 BlockDriverCompletionFunc
*cb
,
84 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
85 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
86 int64_t sector_num
, int nb_sectors
);
88 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
89 bool is_write
, double elapsed_time
, uint64_t *wait
);
90 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
91 double elapsed_time
, uint64_t *wait
);
92 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
93 bool is_write
, int64_t *wait
);
95 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
96 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
98 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
99 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
101 /* The device to use for VM snapshots */
102 static BlockDriverState
*bs_snapshots
;
104 /* If non-zero, use only whitelisted block drivers */
105 static int use_bdrv_whitelist
;
108 static int is_windows_drive_prefix(const char *filename
)
110 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
111 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
115 int is_windows_drive(const char *filename
)
117 if (is_windows_drive_prefix(filename
) &&
120 if (strstart(filename
, "\\\\.\\", NULL
) ||
121 strstart(filename
, "//./", NULL
))
127 /* throttling disk I/O limits */
128 void bdrv_io_limits_disable(BlockDriverState
*bs
)
130 bs
->io_limits_enabled
= false;
132 while (qemu_co_queue_next(&bs
->throttled_reqs
));
134 if (bs
->block_timer
) {
135 qemu_del_timer(bs
->block_timer
);
136 qemu_free_timer(bs
->block_timer
);
137 bs
->block_timer
= NULL
;
143 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
146 static void bdrv_block_timer(void *opaque
)
148 BlockDriverState
*bs
= opaque
;
150 qemu_co_queue_next(&bs
->throttled_reqs
);
153 void bdrv_io_limits_enable(BlockDriverState
*bs
)
155 qemu_co_queue_init(&bs
->throttled_reqs
);
156 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
157 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
158 bs
->slice_start
= qemu_get_clock_ns(vm_clock
);
159 bs
->slice_end
= bs
->slice_start
+ bs
->slice_time
;
160 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
161 bs
->io_limits_enabled
= true;
164 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
166 BlockIOLimit
*io_limits
= &bs
->io_limits
;
167 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
168 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
169 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
170 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
171 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
172 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
175 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
176 bool is_write
, int nb_sectors
)
178 int64_t wait_time
= -1;
180 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
181 qemu_co_queue_wait(&bs
->throttled_reqs
);
184 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
185 * throttled requests will not be dequeued until the current request is
186 * allowed to be serviced. So if the current request still exceeds the
187 * limits, it will be inserted to the head. All requests followed it will
188 * be still in throttled_reqs queue.
191 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
192 qemu_mod_timer(bs
->block_timer
,
193 wait_time
+ qemu_get_clock_ns(vm_clock
));
194 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
197 qemu_co_queue_next(&bs
->throttled_reqs
);
200 /* check if the path starts with "<protocol>:" */
201 static int path_has_protocol(const char *path
)
206 if (is_windows_drive(path
) ||
207 is_windows_drive_prefix(path
)) {
210 p
= path
+ strcspn(path
, ":/\\");
212 p
= path
+ strcspn(path
, ":/");
218 int path_is_absolute(const char *path
)
221 /* specific case for names like: "\\.\d:" */
222 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
225 return (*path
== '/' || *path
== '\\');
227 return (*path
== '/');
231 /* if filename is absolute, just copy it to dest. Otherwise, build a
232 path to it by considering it is relative to base_path. URL are
234 void path_combine(char *dest
, int dest_size
,
235 const char *base_path
,
236 const char *filename
)
243 if (path_is_absolute(filename
)) {
244 pstrcpy(dest
, dest_size
, filename
);
246 p
= strchr(base_path
, ':');
251 p1
= strrchr(base_path
, '/');
255 p2
= strrchr(base_path
, '\\');
267 if (len
> dest_size
- 1)
269 memcpy(dest
, base_path
, len
);
271 pstrcat(dest
, dest_size
, filename
);
275 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
277 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
278 pstrcpy(dest
, sz
, bs
->backing_file
);
280 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
284 void bdrv_register(BlockDriver
*bdrv
)
286 /* Block drivers without coroutine functions need emulation */
287 if (!bdrv
->bdrv_co_readv
) {
288 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
289 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
291 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
292 * the block driver lacks aio we need to emulate that too.
294 if (!bdrv
->bdrv_aio_readv
) {
295 /* add AIO emulation layer */
296 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
297 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
301 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
304 /* create a new block device (by default it is empty) */
305 BlockDriverState
*bdrv_new(const char *device_name
)
307 BlockDriverState
*bs
;
309 bs
= g_malloc0(sizeof(BlockDriverState
));
310 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
311 if (device_name
[0] != '\0') {
312 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
314 bdrv_iostatus_disable(bs
);
318 BlockDriver
*bdrv_find_format(const char *format_name
)
321 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
322 if (!strcmp(drv1
->format_name
, format_name
)) {
329 static int bdrv_is_whitelisted(BlockDriver
*drv
)
331 static const char *whitelist
[] = {
332 CONFIG_BDRV_WHITELIST
337 return 1; /* no whitelist, anything goes */
339 for (p
= whitelist
; *p
; p
++) {
340 if (!strcmp(drv
->format_name
, *p
)) {
347 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
)
349 BlockDriver
*drv
= bdrv_find_format(format_name
);
350 return drv
&& bdrv_is_whitelisted(drv
) ? drv
: NULL
;
353 typedef struct CreateCo
{
356 QEMUOptionParameter
*options
;
360 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
362 CreateCo
*cco
= opaque
;
365 cco
->ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
);
368 int bdrv_create(BlockDriver
*drv
, const char* filename
,
369 QEMUOptionParameter
*options
)
376 .filename
= g_strdup(filename
),
381 if (!drv
->bdrv_create
) {
386 if (qemu_in_coroutine()) {
387 /* Fast-path if already in coroutine context */
388 bdrv_create_co_entry(&cco
);
390 co
= qemu_coroutine_create(bdrv_create_co_entry
);
391 qemu_coroutine_enter(co
, &cco
);
392 while (cco
.ret
== NOT_DONE
) {
400 g_free(cco
.filename
);
404 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
408 drv
= bdrv_find_protocol(filename
);
413 return bdrv_create(drv
, filename
, options
);
417 * Create a uniquely-named empty temporary file.
418 * Return 0 upon success, otherwise a negative errno value.
420 int get_tmp_filename(char *filename
, int size
)
423 char temp_dir
[MAX_PATH
];
424 /* GetTempFileName requires that its output buffer (4th param)
425 have length MAX_PATH or greater. */
426 assert(size
>= MAX_PATH
);
427 return (GetTempPath(MAX_PATH
, temp_dir
)
428 && GetTempFileName(temp_dir
, "qem", 0, filename
)
429 ? 0 : -GetLastError());
433 tmpdir
= getenv("TMPDIR");
436 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
439 fd
= mkstemp(filename
);
443 if (close(fd
) != 0) {
452 * Detect host devices. By convention, /dev/cdrom[N] is always
453 * recognized as a host CDROM.
455 static BlockDriver
*find_hdev_driver(const char *filename
)
457 int score_max
= 0, score
;
458 BlockDriver
*drv
= NULL
, *d
;
460 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
461 if (d
->bdrv_probe_device
) {
462 score
= d
->bdrv_probe_device(filename
);
463 if (score
> score_max
) {
473 BlockDriver
*bdrv_find_protocol(const char *filename
)
480 /* TODO Drivers without bdrv_file_open must be specified explicitly */
483 * XXX(hch): we really should not let host device detection
484 * override an explicit protocol specification, but moving this
485 * later breaks access to device names with colons in them.
486 * Thanks to the brain-dead persistent naming schemes on udev-
487 * based Linux systems those actually are quite common.
489 drv1
= find_hdev_driver(filename
);
494 if (!path_has_protocol(filename
)) {
495 return bdrv_find_format("file");
497 p
= strchr(filename
, ':');
500 if (len
> sizeof(protocol
) - 1)
501 len
= sizeof(protocol
) - 1;
502 memcpy(protocol
, filename
, len
);
503 protocol
[len
] = '\0';
504 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
505 if (drv1
->protocol_name
&&
506 !strcmp(drv1
->protocol_name
, protocol
)) {
513 static int find_image_format(const char *filename
, BlockDriver
**pdrv
)
515 int ret
, score
, score_max
;
516 BlockDriver
*drv1
, *drv
;
518 BlockDriverState
*bs
;
520 ret
= bdrv_file_open(&bs
, filename
, 0);
526 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
527 if (bs
->sg
|| !bdrv_is_inserted(bs
)) {
529 drv
= bdrv_find_format("raw");
537 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
546 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
547 if (drv1
->bdrv_probe
) {
548 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
549 if (score
> score_max
) {
563 * Set the current 'total_sectors' value
565 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
567 BlockDriver
*drv
= bs
->drv
;
569 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
573 /* query actual device if possible, otherwise just trust the hint */
574 if (drv
->bdrv_getlength
) {
575 int64_t length
= drv
->bdrv_getlength(bs
);
579 hint
= length
>> BDRV_SECTOR_BITS
;
582 bs
->total_sectors
= hint
;
587 * Set open flags for a given cache mode
589 * Return 0 on success, -1 if the cache mode was invalid.
591 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
593 *flags
&= ~BDRV_O_CACHE_MASK
;
595 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
596 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
597 } else if (!strcmp(mode
, "directsync")) {
598 *flags
|= BDRV_O_NOCACHE
;
599 } else if (!strcmp(mode
, "writeback")) {
600 *flags
|= BDRV_O_CACHE_WB
;
601 } else if (!strcmp(mode
, "unsafe")) {
602 *flags
|= BDRV_O_CACHE_WB
;
603 *flags
|= BDRV_O_NO_FLUSH
;
604 } else if (!strcmp(mode
, "writethrough")) {
605 /* this is the default */
614 * The copy-on-read flag is actually a reference count so multiple users may
615 * use the feature without worrying about clobbering its previous state.
616 * Copy-on-read stays enabled until all users have called to disable it.
618 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
623 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
625 assert(bs
->copy_on_read
> 0);
630 * Common part for opening disk images and files
632 static int bdrv_open_common(BlockDriverState
*bs
, const char *filename
,
633 int flags
, BlockDriver
*drv
)
638 assert(bs
->file
== NULL
);
640 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
642 bs
->open_flags
= flags
;
643 bs
->buffer_alignment
= 512;
645 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
646 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
647 bdrv_enable_copy_on_read(bs
);
650 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
652 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
657 bs
->opaque
= g_malloc0(drv
->instance_size
);
659 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
660 open_flags
= flags
| BDRV_O_CACHE_WB
;
663 * Clear flags that are internal to the block layer before opening the
666 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
669 * Snapshots should be writable.
671 if (bs
->is_temporary
) {
672 open_flags
|= BDRV_O_RDWR
;
675 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
677 /* Open the image, either directly or using a protocol */
678 if (drv
->bdrv_file_open
) {
679 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
681 ret
= bdrv_file_open(&bs
->file
, filename
, open_flags
);
683 ret
= drv
->bdrv_open(bs
, open_flags
);
691 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
697 if (bs
->is_temporary
) {
705 bdrv_delete(bs
->file
);
715 * Opens a file using a protocol (file, host_device, nbd, ...)
717 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
719 BlockDriverState
*bs
;
723 drv
= bdrv_find_protocol(filename
);
729 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
740 * Opens a disk image (raw, qcow2, vmdk, ...)
742 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int flags
,
746 char tmp_filename
[PATH_MAX
];
748 if (flags
& BDRV_O_SNAPSHOT
) {
749 BlockDriverState
*bs1
;
752 BlockDriver
*bdrv_qcow2
;
753 QEMUOptionParameter
*options
;
754 char backing_filename
[PATH_MAX
];
756 /* if snapshot, we create a temporary backing file and open it
757 instead of opening 'filename' directly */
759 /* if there is a backing file, use it */
761 ret
= bdrv_open(bs1
, filename
, 0, drv
);
766 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
768 if (bs1
->drv
&& bs1
->drv
->protocol_name
)
773 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
778 /* Real path is meaningless for protocols */
780 snprintf(backing_filename
, sizeof(backing_filename
),
782 else if (!realpath(filename
, backing_filename
))
785 bdrv_qcow2
= bdrv_find_format("qcow2");
786 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
788 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
789 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
791 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
795 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
796 free_option_parameters(options
);
801 filename
= tmp_filename
;
803 bs
->is_temporary
= 1;
806 /* Find the right image format driver */
808 ret
= find_image_format(filename
, &drv
);
812 goto unlink_and_fail
;
815 if (flags
& BDRV_O_RDWR
) {
816 flags
|= BDRV_O_ALLOW_RDWR
;
820 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
822 goto unlink_and_fail
;
825 /* If there is a backing file, use it */
826 if ((flags
& BDRV_O_NO_BACKING
) == 0 && bs
->backing_file
[0] != '\0') {
827 char backing_filename
[PATH_MAX
];
829 BlockDriver
*back_drv
= NULL
;
831 bs
->backing_hd
= bdrv_new("");
832 bdrv_get_full_backing_filename(bs
, backing_filename
,
833 sizeof(backing_filename
));
835 if (bs
->backing_format
[0] != '\0') {
836 back_drv
= bdrv_find_format(bs
->backing_format
);
839 /* backing files always opened read-only */
841 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
843 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, back_flags
, back_drv
);
850 if (!bdrv_key_required(bs
)) {
851 bdrv_dev_change_media_cb(bs
, true);
854 /* throttling disk I/O limits */
855 if (bs
->io_limits_enabled
) {
856 bdrv_io_limits_enable(bs
);
862 if (bs
->is_temporary
) {
868 typedef struct BlockReopenQueueEntry
{
870 BDRVReopenState state
;
871 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
872 } BlockReopenQueueEntry
;
875 * Adds a BlockDriverState to a simple queue for an atomic, transactional
876 * reopen of multiple devices.
878 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
879 * already performed, or alternatively may be NULL a new BlockReopenQueue will
880 * be created and initialized. This newly created BlockReopenQueue should be
881 * passed back in for subsequent calls that are intended to be of the same
884 * bs is the BlockDriverState to add to the reopen queue.
886 * flags contains the open flags for the associated bs
888 * returns a pointer to bs_queue, which is either the newly allocated
889 * bs_queue, or the existing bs_queue being used.
892 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
893 BlockDriverState
*bs
, int flags
)
897 BlockReopenQueueEntry
*bs_entry
;
898 if (bs_queue
== NULL
) {
899 bs_queue
= g_new0(BlockReopenQueue
, 1);
900 QSIMPLEQ_INIT(bs_queue
);
904 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
907 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
908 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
910 bs_entry
->state
.bs
= bs
;
911 bs_entry
->state
.flags
= flags
;
917 * Reopen multiple BlockDriverStates atomically & transactionally.
919 * The queue passed in (bs_queue) must have been built up previous
920 * via bdrv_reopen_queue().
922 * Reopens all BDS specified in the queue, with the appropriate
923 * flags. All devices are prepared for reopen, and failure of any
924 * device will cause all device changes to be abandonded, and intermediate
927 * If all devices prepare successfully, then the changes are committed
931 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
934 BlockReopenQueueEntry
*bs_entry
, *next
;
935 Error
*local_err
= NULL
;
937 assert(bs_queue
!= NULL
);
941 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
942 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
943 error_propagate(errp
, local_err
);
946 bs_entry
->prepared
= true;
949 /* If we reach this point, we have success and just need to apply the
952 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
953 bdrv_reopen_commit(&bs_entry
->state
);
959 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
960 if (ret
&& bs_entry
->prepared
) {
961 bdrv_reopen_abort(&bs_entry
->state
);
970 /* Reopen a single BlockDriverState with the specified flags. */
971 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
974 Error
*local_err
= NULL
;
975 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
977 ret
= bdrv_reopen_multiple(queue
, &local_err
);
978 if (local_err
!= NULL
) {
979 error_propagate(errp
, local_err
);
986 * Prepares a BlockDriverState for reopen. All changes are staged in the
987 * 'opaque' field of the BDRVReopenState, which is used and allocated by
988 * the block driver layer .bdrv_reopen_prepare()
990 * bs is the BlockDriverState to reopen
991 * flags are the new open flags
992 * queue is the reopen queue
994 * Returns 0 on success, non-zero on error. On error errp will be set
997 * On failure, bdrv_reopen_abort() will be called to clean up any data.
998 * It is the responsibility of the caller to then call the abort() or
999 * commit() for any other BDS that have been left in a prepare() state
1002 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1006 Error
*local_err
= NULL
;
1009 assert(reopen_state
!= NULL
);
1010 assert(reopen_state
->bs
->drv
!= NULL
);
1011 drv
= reopen_state
->bs
->drv
;
1013 /* if we are to stay read-only, do not allow permission change
1015 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1016 reopen_state
->flags
& BDRV_O_RDWR
) {
1017 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1018 reopen_state
->bs
->device_name
);
1023 ret
= bdrv_flush(reopen_state
->bs
);
1025 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1030 if (drv
->bdrv_reopen_prepare
) {
1031 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1033 if (local_err
!= NULL
) {
1034 error_propagate(errp
, local_err
);
1036 error_set(errp
, QERR_OPEN_FILE_FAILED
,
1037 reopen_state
->bs
->filename
);
1042 /* It is currently mandatory to have a bdrv_reopen_prepare()
1043 * handler for each supported drv. */
1044 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1045 drv
->format_name
, reopen_state
->bs
->device_name
,
1046 "reopening of file");
1058 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1059 * makes them final by swapping the staging BlockDriverState contents into
1060 * the active BlockDriverState contents.
1062 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1066 assert(reopen_state
!= NULL
);
1067 drv
= reopen_state
->bs
->drv
;
1068 assert(drv
!= NULL
);
1070 /* If there are any driver level actions to take */
1071 if (drv
->bdrv_reopen_commit
) {
1072 drv
->bdrv_reopen_commit(reopen_state
);
1075 /* set BDS specific flags now */
1076 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1077 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1079 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1083 * Abort the reopen, and delete and free the staged changes in
1086 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1090 assert(reopen_state
!= NULL
);
1091 drv
= reopen_state
->bs
->drv
;
1092 assert(drv
!= NULL
);
1094 if (drv
->bdrv_reopen_abort
) {
1095 drv
->bdrv_reopen_abort(reopen_state
);
1100 void bdrv_close(BlockDriverState
*bs
)
1105 block_job_cancel_sync(bs
->job
);
1109 if (bs
== bs_snapshots
) {
1110 bs_snapshots
= NULL
;
1112 if (bs
->backing_hd
) {
1113 bdrv_delete(bs
->backing_hd
);
1114 bs
->backing_hd
= NULL
;
1116 bs
->drv
->bdrv_close(bs
);
1119 if (bs
->is_temporary
) {
1120 unlink(bs
->filename
);
1125 bs
->copy_on_read
= 0;
1126 bs
->backing_file
[0] = '\0';
1127 bs
->backing_format
[0] = '\0';
1128 bs
->total_sectors
= 0;
1134 if (bs
->file
!= NULL
) {
1135 bdrv_delete(bs
->file
);
1140 bdrv_dev_change_media_cb(bs
, false);
1142 /*throttling disk I/O limits*/
1143 if (bs
->io_limits_enabled
) {
1144 bdrv_io_limits_disable(bs
);
1148 void bdrv_close_all(void)
1150 BlockDriverState
*bs
;
1152 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1158 * Wait for pending requests to complete across all BlockDriverStates
1160 * This function does not flush data to disk, use bdrv_flush_all() for that
1161 * after calling this function.
1163 * Note that completion of an asynchronous I/O operation can trigger any
1164 * number of other I/O operations on other devices---for example a coroutine
1165 * can be arbitrarily complex and a constant flow of I/O can come until the
1166 * coroutine is complete. Because of this, it is not possible to have a
1167 * function to drain a single device's I/O queue.
1169 void bdrv_drain_all(void)
1171 BlockDriverState
*bs
;
1175 busy
= qemu_aio_wait();
1177 /* FIXME: We do not have timer support here, so this is effectively
1180 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1181 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
1182 qemu_co_queue_restart_all(&bs
->throttled_reqs
);
1188 /* If requests are still pending there is a bug somewhere */
1189 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1190 assert(QLIST_EMPTY(&bs
->tracked_requests
));
1191 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
1195 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1196 Also, NULL terminate the device_name to prevent double remove */
1197 void bdrv_make_anon(BlockDriverState
*bs
)
1199 if (bs
->device_name
[0] != '\0') {
1200 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
1202 bs
->device_name
[0] = '\0';
1205 static void bdrv_rebind(BlockDriverState
*bs
)
1207 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1208 bs
->drv
->bdrv_rebind(bs
);
1212 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1213 BlockDriverState
*bs_src
)
1215 /* move some fields that need to stay attached to the device */
1216 bs_dest
->open_flags
= bs_src
->open_flags
;
1219 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1220 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1221 bs_dest
->dev
= bs_src
->dev
;
1222 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
1223 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1225 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1227 /* i/o timing parameters */
1228 bs_dest
->slice_time
= bs_src
->slice_time
;
1229 bs_dest
->slice_start
= bs_src
->slice_start
;
1230 bs_dest
->slice_end
= bs_src
->slice_end
;
1231 bs_dest
->io_limits
= bs_src
->io_limits
;
1232 bs_dest
->io_base
= bs_src
->io_base
;
1233 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
1234 bs_dest
->block_timer
= bs_src
->block_timer
;
1235 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1238 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1239 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1242 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1243 bs_dest
->iostatus
= bs_src
->iostatus
;
1246 bs_dest
->dirty_count
= bs_src
->dirty_count
;
1247 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1250 bs_dest
->in_use
= bs_src
->in_use
;
1251 bs_dest
->job
= bs_src
->job
;
1253 /* keep the same entry in bdrv_states */
1254 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1255 bs_src
->device_name
);
1256 bs_dest
->list
= bs_src
->list
;
1260 * Swap bs contents for two image chains while they are live,
1261 * while keeping required fields on the BlockDriverState that is
1262 * actually attached to a device.
1264 * This will modify the BlockDriverState fields, and swap contents
1265 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1267 * bs_new is required to be anonymous.
1269 * This function does not create any image files.
1271 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1273 BlockDriverState tmp
;
1275 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1276 assert(bs_new
->device_name
[0] == '\0');
1277 assert(bs_new
->dirty_bitmap
== NULL
);
1278 assert(bs_new
->job
== NULL
);
1279 assert(bs_new
->dev
== NULL
);
1280 assert(bs_new
->in_use
== 0);
1281 assert(bs_new
->io_limits_enabled
== false);
1282 assert(bs_new
->block_timer
== NULL
);
1288 /* there are some fields that should not be swapped, move them back */
1289 bdrv_move_feature_fields(&tmp
, bs_old
);
1290 bdrv_move_feature_fields(bs_old
, bs_new
);
1291 bdrv_move_feature_fields(bs_new
, &tmp
);
1293 /* bs_new shouldn't be in bdrv_states even after the swap! */
1294 assert(bs_new
->device_name
[0] == '\0');
1296 /* Check a few fields that should remain attached to the device */
1297 assert(bs_new
->dev
== NULL
);
1298 assert(bs_new
->job
== NULL
);
1299 assert(bs_new
->in_use
== 0);
1300 assert(bs_new
->io_limits_enabled
== false);
1301 assert(bs_new
->block_timer
== NULL
);
1303 bdrv_rebind(bs_new
);
1304 bdrv_rebind(bs_old
);
1308 * Add new bs contents at the top of an image chain while the chain is
1309 * live, while keeping required fields on the top layer.
1311 * This will modify the BlockDriverState fields, and swap contents
1312 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1314 * bs_new is required to be anonymous.
1316 * This function does not create any image files.
1318 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1320 bdrv_swap(bs_new
, bs_top
);
1322 /* The contents of 'tmp' will become bs_top, as we are
1323 * swapping bs_new and bs_top contents. */
1324 bs_top
->backing_hd
= bs_new
;
1325 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1326 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1328 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1329 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1332 void bdrv_delete(BlockDriverState
*bs
)
1336 assert(!bs
->in_use
);
1338 /* remove from list, if necessary */
1343 assert(bs
!= bs_snapshots
);
1347 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1348 /* TODO change to DeviceState *dev when all users are qdevified */
1354 bdrv_iostatus_reset(bs
);
1358 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1359 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1361 if (bdrv_attach_dev(bs
, dev
) < 0) {
1366 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1367 /* TODO change to DeviceState *dev when all users are qdevified */
1369 assert(bs
->dev
== dev
);
1372 bs
->dev_opaque
= NULL
;
1373 bs
->buffer_alignment
= 512;
1376 /* TODO change to return DeviceState * when all users are qdevified */
1377 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1382 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1386 bs
->dev_opaque
= opaque
;
1387 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1388 bs_snapshots
= NULL
;
1392 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1393 enum MonitorEvent ev
,
1394 BlockErrorAction action
, bool is_read
)
1397 const char *action_str
;
1400 case BDRV_ACTION_REPORT
:
1401 action_str
= "report";
1403 case BDRV_ACTION_IGNORE
:
1404 action_str
= "ignore";
1406 case BDRV_ACTION_STOP
:
1407 action_str
= "stop";
1413 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1416 is_read
? "read" : "write");
1417 monitor_protocol_event(ev
, data
);
1419 qobject_decref(data
);
1422 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1426 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1427 bdrv_get_device_name(bs
), ejected
);
1428 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1430 qobject_decref(data
);
1433 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1435 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1436 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1437 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1438 if (tray_was_closed
) {
1440 bdrv_emit_qmp_eject_event(bs
, true);
1444 bdrv_emit_qmp_eject_event(bs
, false);
1449 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1451 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1454 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1456 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1457 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1461 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1463 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1464 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1469 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1471 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1472 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1476 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1478 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1479 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1485 * Run consistency checks on an image
1487 * Returns 0 if the check could be completed (it doesn't mean that the image is
1488 * free of errors) or -errno when an internal error occurred. The results of the
1489 * check are stored in res.
1491 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1493 if (bs
->drv
->bdrv_check
== NULL
) {
1497 memset(res
, 0, sizeof(*res
));
1498 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1501 #define COMMIT_BUF_SECTORS 2048
1503 /* commit COW file into the raw image */
1504 int bdrv_commit(BlockDriverState
*bs
)
1506 BlockDriver
*drv
= bs
->drv
;
1507 int64_t sector
, total_sectors
;
1508 int n
, ro
, open_flags
;
1511 char filename
[PATH_MAX
];
1516 if (!bs
->backing_hd
) {
1520 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1524 ro
= bs
->backing_hd
->read_only
;
1525 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1526 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
1527 open_flags
= bs
->backing_hd
->open_flags
;
1530 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
1535 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1536 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1538 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1539 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1541 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1546 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1553 if (drv
->bdrv_make_empty
) {
1554 ret
= drv
->bdrv_make_empty(bs
);
1559 * Make sure all data we wrote to the backing device is actually
1563 bdrv_flush(bs
->backing_hd
);
1569 /* ignoring error return here */
1570 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
1576 int bdrv_commit_all(void)
1578 BlockDriverState
*bs
;
1580 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1581 int ret
= bdrv_commit(bs
);
1589 struct BdrvTrackedRequest
{
1590 BlockDriverState
*bs
;
1594 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1595 Coroutine
*co
; /* owner, used for deadlock detection */
1596 CoQueue wait_queue
; /* coroutines blocked on this request */
1600 * Remove an active request from the tracked requests list
1602 * This function should be called when a tracked request is completing.
1604 static void tracked_request_end(BdrvTrackedRequest
*req
)
1606 QLIST_REMOVE(req
, list
);
1607 qemu_co_queue_restart_all(&req
->wait_queue
);
1611 * Add an active request to the tracked requests list
1613 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1614 BlockDriverState
*bs
,
1616 int nb_sectors
, bool is_write
)
1618 *req
= (BdrvTrackedRequest
){
1620 .sector_num
= sector_num
,
1621 .nb_sectors
= nb_sectors
,
1622 .is_write
= is_write
,
1623 .co
= qemu_coroutine_self(),
1626 qemu_co_queue_init(&req
->wait_queue
);
1628 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1632 * Round a region to cluster boundaries
1634 static void round_to_clusters(BlockDriverState
*bs
,
1635 int64_t sector_num
, int nb_sectors
,
1636 int64_t *cluster_sector_num
,
1637 int *cluster_nb_sectors
)
1639 BlockDriverInfo bdi
;
1641 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1642 *cluster_sector_num
= sector_num
;
1643 *cluster_nb_sectors
= nb_sectors
;
1645 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1646 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1647 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1652 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1653 int64_t sector_num
, int nb_sectors
) {
1655 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1659 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1665 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1666 int64_t sector_num
, int nb_sectors
)
1668 BdrvTrackedRequest
*req
;
1669 int64_t cluster_sector_num
;
1670 int cluster_nb_sectors
;
1673 /* If we touch the same cluster it counts as an overlap. This guarantees
1674 * that allocating writes will be serialized and not race with each other
1675 * for the same cluster. For example, in copy-on-read it ensures that the
1676 * CoR read and write operations are atomic and guest writes cannot
1677 * interleave between them.
1679 round_to_clusters(bs
, sector_num
, nb_sectors
,
1680 &cluster_sector_num
, &cluster_nb_sectors
);
1684 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1685 if (tracked_request_overlaps(req
, cluster_sector_num
,
1686 cluster_nb_sectors
)) {
1687 /* Hitting this means there was a reentrant request, for
1688 * example, a block driver issuing nested requests. This must
1689 * never happen since it means deadlock.
1691 assert(qemu_coroutine_self() != req
->co
);
1693 qemu_co_queue_wait(&req
->wait_queue
);
1704 * -EINVAL - backing format specified, but no file
1705 * -ENOSPC - can't update the backing file because no space is left in the
1707 * -ENOTSUP - format driver doesn't support changing the backing file
1709 int bdrv_change_backing_file(BlockDriverState
*bs
,
1710 const char *backing_file
, const char *backing_fmt
)
1712 BlockDriver
*drv
= bs
->drv
;
1715 /* Backing file format doesn't make sense without a backing file */
1716 if (backing_fmt
&& !backing_file
) {
1720 if (drv
->bdrv_change_backing_file
!= NULL
) {
1721 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1727 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
1728 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
1734 * Finds the image layer in the chain that has 'bs' as its backing file.
1736 * active is the current topmost image.
1738 * Returns NULL if bs is not found in active's image chain,
1739 * or if active == bs.
1741 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
1742 BlockDriverState
*bs
)
1744 BlockDriverState
*overlay
= NULL
;
1745 BlockDriverState
*intermediate
;
1747 assert(active
!= NULL
);
1750 /* if bs is the same as active, then by definition it has no overlay
1756 intermediate
= active
;
1757 while (intermediate
->backing_hd
) {
1758 if (intermediate
->backing_hd
== bs
) {
1759 overlay
= intermediate
;
1762 intermediate
= intermediate
->backing_hd
;
1768 typedef struct BlkIntermediateStates
{
1769 BlockDriverState
*bs
;
1770 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
1771 } BlkIntermediateStates
;
1775 * Drops images above 'base' up to and including 'top', and sets the image
1776 * above 'top' to have base as its backing file.
1778 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1779 * information in 'bs' can be properly updated.
1781 * E.g., this will convert the following chain:
1782 * bottom <- base <- intermediate <- top <- active
1786 * bottom <- base <- active
1788 * It is allowed for bottom==base, in which case it converts:
1790 * base <- intermediate <- top <- active
1797 * if active == top, that is considered an error
1800 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
1801 BlockDriverState
*base
)
1803 BlockDriverState
*intermediate
;
1804 BlockDriverState
*base_bs
= NULL
;
1805 BlockDriverState
*new_top_bs
= NULL
;
1806 BlkIntermediateStates
*intermediate_state
, *next
;
1809 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
1810 QSIMPLEQ_INIT(&states_to_delete
);
1812 if (!top
->drv
|| !base
->drv
) {
1816 new_top_bs
= bdrv_find_overlay(active
, top
);
1818 if (new_top_bs
== NULL
) {
1819 /* we could not find the image above 'top', this is an error */
1823 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1824 * to do, no intermediate images */
1825 if (new_top_bs
->backing_hd
== base
) {
1832 /* now we will go down through the list, and add each BDS we find
1833 * into our deletion queue, until we hit the 'base'
1835 while (intermediate
) {
1836 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
1837 intermediate_state
->bs
= intermediate
;
1838 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
1840 if (intermediate
->backing_hd
== base
) {
1841 base_bs
= intermediate
->backing_hd
;
1844 intermediate
= intermediate
->backing_hd
;
1846 if (base_bs
== NULL
) {
1847 /* something went wrong, we did not end at the base. safely
1848 * unravel everything, and exit with error */
1852 /* success - we can delete the intermediate states, and link top->base */
1853 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
1854 base_bs
->drv
? base_bs
->drv
->format_name
: "");
1858 new_top_bs
->backing_hd
= base_bs
;
1861 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1862 /* so that bdrv_close() does not recursively close the chain */
1863 intermediate_state
->bs
->backing_hd
= NULL
;
1864 bdrv_delete(intermediate_state
->bs
);
1869 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
1870 g_free(intermediate_state
);
1876 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1881 if (!bdrv_is_inserted(bs
))
1887 len
= bdrv_getlength(bs
);
1892 if ((offset
> len
) || (len
- offset
< size
))
1898 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1901 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1902 nb_sectors
* BDRV_SECTOR_SIZE
);
1905 typedef struct RwCo
{
1906 BlockDriverState
*bs
;
1914 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1916 RwCo
*rwco
= opaque
;
1918 if (!rwco
->is_write
) {
1919 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1920 rwco
->nb_sectors
, rwco
->qiov
, 0);
1922 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1923 rwco
->nb_sectors
, rwco
->qiov
, 0);
1928 * Process a synchronous request using coroutines
1930 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1931 int nb_sectors
, bool is_write
)
1934 struct iovec iov
= {
1935 .iov_base
= (void *)buf
,
1936 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1941 .sector_num
= sector_num
,
1942 .nb_sectors
= nb_sectors
,
1944 .is_write
= is_write
,
1948 qemu_iovec_init_external(&qiov
, &iov
, 1);
1951 * In sync call context, when the vcpu is blocked, this throttling timer
1952 * will not fire; so the I/O throttling function has to be disabled here
1953 * if it has been enabled.
1955 if (bs
->io_limits_enabled
) {
1956 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
1957 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
1958 bdrv_io_limits_disable(bs
);
1961 if (qemu_in_coroutine()) {
1962 /* Fast-path if already in coroutine context */
1963 bdrv_rw_co_entry(&rwco
);
1965 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1966 qemu_coroutine_enter(co
, &rwco
);
1967 while (rwco
.ret
== NOT_DONE
) {
1974 /* return < 0 if error. See bdrv_write() for the return codes */
1975 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1976 uint8_t *buf
, int nb_sectors
)
1978 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1981 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
1982 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
1983 uint8_t *buf
, int nb_sectors
)
1988 enabled
= bs
->io_limits_enabled
;
1989 bs
->io_limits_enabled
= false;
1990 ret
= bdrv_read(bs
, 0, buf
, 1);
1991 bs
->io_limits_enabled
= enabled
;
1995 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
1997 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1998 int nb_sectors
, int dirty
)
2001 unsigned long val
, idx
, bit
;
2003 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
2004 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
2006 for (; start
<= end
; start
++) {
2007 idx
= start
/ BITS_PER_LONG
;
2008 bit
= start
% BITS_PER_LONG
;
2009 val
= bs
->dirty_bitmap
[idx
];
2011 if (!(val
& (1UL << bit
))) {
2016 if (val
& (1UL << bit
)) {
2018 val
&= ~(1UL << bit
);
2021 bs
->dirty_bitmap
[idx
] = val
;
2025 /* Return < 0 if error. Important errors are:
2026 -EIO generic I/O error (may happen for all errors)
2027 -ENOMEDIUM No media inserted.
2028 -EINVAL Invalid sector number or nb_sectors
2029 -EACCES Trying to write a read-only device
2031 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2032 const uint8_t *buf
, int nb_sectors
)
2034 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
2037 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2038 void *buf
, int count1
)
2040 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2041 int len
, nb_sectors
, count
;
2046 /* first read to align to sector start */
2047 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2050 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2052 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2054 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2062 /* read the sectors "in place" */
2063 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2064 if (nb_sectors
> 0) {
2065 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2067 sector_num
+= nb_sectors
;
2068 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2073 /* add data from the last sector */
2075 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2077 memcpy(buf
, tmp_buf
, count
);
2082 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2083 const void *buf
, int count1
)
2085 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2086 int len
, nb_sectors
, count
;
2091 /* first write to align to sector start */
2092 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2095 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2097 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2099 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
2100 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2109 /* write the sectors "in place" */
2110 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2111 if (nb_sectors
> 0) {
2112 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2114 sector_num
+= nb_sectors
;
2115 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2120 /* add data from the last sector */
2122 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2124 memcpy(tmp_buf
, buf
, count
);
2125 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2132 * Writes to the file and ensures that no writes are reordered across this
2133 * request (acts as a barrier)
2135 * Returns 0 on success, -errno in error cases.
2137 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2138 const void *buf
, int count
)
2142 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2147 /* No flush needed for cache modes that already do it */
2148 if (bs
->enable_write_cache
) {
2155 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2156 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2158 /* Perform I/O through a temporary buffer so that users who scribble over
2159 * their read buffer while the operation is in progress do not end up
2160 * modifying the image file. This is critical for zero-copy guest I/O
2161 * where anything might happen inside guest memory.
2163 void *bounce_buffer
;
2165 BlockDriver
*drv
= bs
->drv
;
2167 QEMUIOVector bounce_qiov
;
2168 int64_t cluster_sector_num
;
2169 int cluster_nb_sectors
;
2173 /* Cover entire cluster so no additional backing file I/O is required when
2174 * allocating cluster in the image file.
2176 round_to_clusters(bs
, sector_num
, nb_sectors
,
2177 &cluster_sector_num
, &cluster_nb_sectors
);
2179 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2180 cluster_sector_num
, cluster_nb_sectors
);
2182 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2183 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2184 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2186 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2192 if (drv
->bdrv_co_write_zeroes
&&
2193 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2194 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2195 cluster_nb_sectors
);
2197 /* This does not change the data on the disk, it is not necessary
2198 * to flush even in cache=writethrough mode.
2200 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2205 /* It might be okay to ignore write errors for guest requests. If this
2206 * is a deliberate copy-on-read then we don't want to ignore the error.
2207 * Simply report it in all cases.
2212 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2213 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2214 nb_sectors
* BDRV_SECTOR_SIZE
);
2217 qemu_vfree(bounce_buffer
);
2222 * Handle a read request in coroutine context
2224 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
2225 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2226 BdrvRequestFlags flags
)
2228 BlockDriver
*drv
= bs
->drv
;
2229 BdrvTrackedRequest req
;
2235 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2239 /* throttling disk read I/O */
2240 if (bs
->io_limits_enabled
) {
2241 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
2244 if (bs
->copy_on_read
) {
2245 flags
|= BDRV_REQ_COPY_ON_READ
;
2247 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2248 bs
->copy_on_read_in_flight
++;
2251 if (bs
->copy_on_read_in_flight
) {
2252 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2255 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
2257 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2260 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2265 if (!ret
|| pnum
!= nb_sectors
) {
2266 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2271 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2274 tracked_request_end(&req
);
2276 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2277 bs
->copy_on_read_in_flight
--;
2283 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2284 int nb_sectors
, QEMUIOVector
*qiov
)
2286 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
2288 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
2291 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
2292 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2294 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
2296 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
2297 BDRV_REQ_COPY_ON_READ
);
2300 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
2301 int64_t sector_num
, int nb_sectors
)
2303 BlockDriver
*drv
= bs
->drv
;
2308 /* TODO Emulate only part of misaligned requests instead of letting block
2309 * drivers return -ENOTSUP and emulate everything */
2311 /* First try the efficient write zeroes operation */
2312 if (drv
->bdrv_co_write_zeroes
) {
2313 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2314 if (ret
!= -ENOTSUP
) {
2319 /* Fall back to bounce buffer if write zeroes is unsupported */
2320 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
2321 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
2322 memset(iov
.iov_base
, 0, iov
.iov_len
);
2323 qemu_iovec_init_external(&qiov
, &iov
, 1);
2325 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
2327 qemu_vfree(iov
.iov_base
);
2332 * Handle a write request in coroutine context
2334 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
2335 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2336 BdrvRequestFlags flags
)
2338 BlockDriver
*drv
= bs
->drv
;
2339 BdrvTrackedRequest req
;
2345 if (bs
->read_only
) {
2348 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2352 /* throttling disk write I/O */
2353 if (bs
->io_limits_enabled
) {
2354 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2357 if (bs
->copy_on_read_in_flight
) {
2358 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2361 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2363 if (flags
& BDRV_REQ_ZERO_WRITE
) {
2364 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2366 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2369 if (ret
== 0 && !bs
->enable_write_cache
) {
2370 ret
= bdrv_co_flush(bs
);
2373 if (bs
->dirty_bitmap
) {
2374 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2377 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2378 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2381 tracked_request_end(&req
);
2386 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2387 int nb_sectors
, QEMUIOVector
*qiov
)
2389 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2391 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2394 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2395 int64_t sector_num
, int nb_sectors
)
2397 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2399 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2400 BDRV_REQ_ZERO_WRITE
);
2404 * Truncate file to 'offset' bytes (needed only for file protocols)
2406 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2408 BlockDriver
*drv
= bs
->drv
;
2412 if (!drv
->bdrv_truncate
)
2416 if (bdrv_in_use(bs
))
2418 ret
= drv
->bdrv_truncate(bs
, offset
);
2420 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2421 bdrv_dev_resize_cb(bs
);
2427 * Length of a allocated file in bytes. Sparse files are counted by actual
2428 * allocated space. Return < 0 if error or unknown.
2430 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2432 BlockDriver
*drv
= bs
->drv
;
2436 if (drv
->bdrv_get_allocated_file_size
) {
2437 return drv
->bdrv_get_allocated_file_size(bs
);
2440 return bdrv_get_allocated_file_size(bs
->file
);
2446 * Length of a file in bytes. Return < 0 if error or unknown.
2448 int64_t bdrv_getlength(BlockDriverState
*bs
)
2450 BlockDriver
*drv
= bs
->drv
;
2454 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2455 if (drv
->bdrv_getlength
) {
2456 return drv
->bdrv_getlength(bs
);
2459 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2462 /* return 0 as number of sectors if no device present or error */
2463 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2466 length
= bdrv_getlength(bs
);
2470 length
= length
>> BDRV_SECTOR_BITS
;
2471 *nb_sectors_ptr
= length
;
2474 /* throttling disk io limits */
2475 void bdrv_set_io_limits(BlockDriverState
*bs
,
2476 BlockIOLimit
*io_limits
)
2478 bs
->io_limits
= *io_limits
;
2479 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2482 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2483 BlockdevOnError on_write_error
)
2485 bs
->on_read_error
= on_read_error
;
2486 bs
->on_write_error
= on_write_error
;
2489 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2491 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2494 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2496 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2499 case BLOCKDEV_ON_ERROR_ENOSPC
:
2500 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
2501 case BLOCKDEV_ON_ERROR_STOP
:
2502 return BDRV_ACTION_STOP
;
2503 case BLOCKDEV_ON_ERROR_REPORT
:
2504 return BDRV_ACTION_REPORT
;
2505 case BLOCKDEV_ON_ERROR_IGNORE
:
2506 return BDRV_ACTION_IGNORE
;
2512 /* This is done by device models because, while the block layer knows
2513 * about the error, it does not know whether an operation comes from
2514 * the device or the block layer (from a job, for example).
2516 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2517 bool is_read
, int error
)
2520 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
2521 if (action
== BDRV_ACTION_STOP
) {
2522 vm_stop(RUN_STATE_IO_ERROR
);
2523 bdrv_iostatus_set_err(bs
, error
);
2527 int bdrv_is_read_only(BlockDriverState
*bs
)
2529 return bs
->read_only
;
2532 int bdrv_is_sg(BlockDriverState
*bs
)
2537 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2539 return bs
->enable_write_cache
;
2542 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2544 bs
->enable_write_cache
= wce
;
2546 /* so a reopen() will preserve wce */
2548 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2550 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2554 int bdrv_is_encrypted(BlockDriverState
*bs
)
2556 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2558 return bs
->encrypted
;
2561 int bdrv_key_required(BlockDriverState
*bs
)
2563 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2565 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2567 return (bs
->encrypted
&& !bs
->valid_key
);
2570 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2573 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2574 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2580 if (!bs
->encrypted
) {
2582 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2585 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2588 } else if (!bs
->valid_key
) {
2590 /* call the change callback now, we skipped it on open */
2591 bdrv_dev_change_media_cb(bs
, true);
2596 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2598 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2601 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2606 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2607 it(opaque
, drv
->format_name
);
2611 BlockDriverState
*bdrv_find(const char *name
)
2613 BlockDriverState
*bs
;
2615 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2616 if (!strcmp(name
, bs
->device_name
)) {
2623 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2626 return QTAILQ_FIRST(&bdrv_states
);
2628 return QTAILQ_NEXT(bs
, list
);
2631 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2633 BlockDriverState
*bs
;
2635 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2640 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2642 return bs
->device_name
;
2645 int bdrv_get_flags(BlockDriverState
*bs
)
2647 return bs
->open_flags
;
2650 void bdrv_flush_all(void)
2652 BlockDriverState
*bs
;
2654 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2659 int bdrv_has_zero_init(BlockDriverState
*bs
)
2663 if (bs
->drv
->bdrv_has_zero_init
) {
2664 return bs
->drv
->bdrv_has_zero_init(bs
);
2670 typedef struct BdrvCoIsAllocatedData
{
2671 BlockDriverState
*bs
;
2677 } BdrvCoIsAllocatedData
;
2680 * Returns true iff the specified sector is present in the disk image. Drivers
2681 * not implementing the functionality are assumed to not support backing files,
2682 * hence all their sectors are reported as allocated.
2684 * If 'sector_num' is beyond the end of the disk image the return value is 0
2685 * and 'pnum' is set to 0.
2687 * 'pnum' is set to the number of sectors (including and immediately following
2688 * the specified sector) that are known to be in the same
2689 * allocated/unallocated state.
2691 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2692 * beyond the end of the disk image it will be clamped.
2694 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2695 int nb_sectors
, int *pnum
)
2699 if (sector_num
>= bs
->total_sectors
) {
2704 n
= bs
->total_sectors
- sector_num
;
2705 if (n
< nb_sectors
) {
2709 if (!bs
->drv
->bdrv_co_is_allocated
) {
2714 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2717 /* Coroutine wrapper for bdrv_is_allocated() */
2718 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2720 BdrvCoIsAllocatedData
*data
= opaque
;
2721 BlockDriverState
*bs
= data
->bs
;
2723 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2729 * Synchronous wrapper around bdrv_co_is_allocated().
2731 * See bdrv_co_is_allocated() for details.
2733 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2737 BdrvCoIsAllocatedData data
= {
2739 .sector_num
= sector_num
,
2740 .nb_sectors
= nb_sectors
,
2745 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2746 qemu_coroutine_enter(co
, &data
);
2747 while (!data
.done
) {
2754 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2756 * Return true if the given sector is allocated in any image between
2757 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2758 * sector is allocated in any image of the chain. Return false otherwise.
2760 * 'pnum' is set to the number of sectors (including and immediately following
2761 * the specified sector) that are known to be in the same
2762 * allocated/unallocated state.
2765 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
2766 BlockDriverState
*base
,
2768 int nb_sectors
, int *pnum
)
2770 BlockDriverState
*intermediate
;
2771 int ret
, n
= nb_sectors
;
2774 while (intermediate
&& intermediate
!= base
) {
2776 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
2786 * [sector_num, nb_sectors] is unallocated on top but intermediate
2789 * [sector_num+x, nr_sectors] allocated.
2791 if (n
> pnum_inter
) {
2795 intermediate
= intermediate
->backing_hd
;
2802 BlockInfoList
*qmp_query_block(Error
**errp
)
2804 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2805 BlockDriverState
*bs
;
2807 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2808 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2810 info
->value
= g_malloc0(sizeof(*info
->value
));
2811 info
->value
->device
= g_strdup(bs
->device_name
);
2812 info
->value
->type
= g_strdup("unknown");
2813 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2814 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2816 if (bdrv_dev_has_removable_media(bs
)) {
2817 info
->value
->has_tray_open
= true;
2818 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2821 if (bdrv_iostatus_is_enabled(bs
)) {
2822 info
->value
->has_io_status
= true;
2823 info
->value
->io_status
= bs
->iostatus
;
2827 info
->value
->has_inserted
= true;
2828 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2829 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2830 info
->value
->inserted
->ro
= bs
->read_only
;
2831 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2832 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2833 info
->value
->inserted
->encryption_key_missing
= bdrv_key_required(bs
);
2834 if (bs
->backing_file
[0]) {
2835 info
->value
->inserted
->has_backing_file
= true;
2836 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2839 info
->value
->inserted
->backing_file_depth
=
2840 bdrv_get_backing_file_depth(bs
);
2842 if (bs
->io_limits_enabled
) {
2843 info
->value
->inserted
->bps
=
2844 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2845 info
->value
->inserted
->bps_rd
=
2846 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2847 info
->value
->inserted
->bps_wr
=
2848 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2849 info
->value
->inserted
->iops
=
2850 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2851 info
->value
->inserted
->iops_rd
=
2852 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2853 info
->value
->inserted
->iops_wr
=
2854 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2858 /* XXX: waiting for the qapi to support GSList */
2860 head
= cur_item
= info
;
2862 cur_item
->next
= info
;
2870 /* Consider exposing this as a full fledged QMP command */
2871 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2875 s
= g_malloc0(sizeof(*s
));
2877 if (bs
->device_name
[0]) {
2878 s
->has_device
= true;
2879 s
->device
= g_strdup(bs
->device_name
);
2882 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2883 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2884 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2885 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2886 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2887 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2888 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2889 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2890 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2891 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2894 s
->has_parent
= true;
2895 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2901 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2903 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2904 BlockDriverState
*bs
;
2906 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2907 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2908 info
->value
= qmp_query_blockstat(bs
, NULL
);
2910 /* XXX: waiting for the qapi to support GSList */
2912 head
= cur_item
= info
;
2914 cur_item
->next
= info
;
2922 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2924 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2925 return bs
->backing_file
;
2926 else if (bs
->encrypted
)
2927 return bs
->filename
;
2932 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2933 char *filename
, int filename_size
)
2935 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2938 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2939 const uint8_t *buf
, int nb_sectors
)
2941 BlockDriver
*drv
= bs
->drv
;
2944 if (!drv
->bdrv_write_compressed
)
2946 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2949 if (bs
->dirty_bitmap
) {
2950 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2953 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2956 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2958 BlockDriver
*drv
= bs
->drv
;
2961 if (!drv
->bdrv_get_info
)
2963 memset(bdi
, 0, sizeof(*bdi
));
2964 return drv
->bdrv_get_info(bs
, bdi
);
2967 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2968 int64_t pos
, int size
)
2970 BlockDriver
*drv
= bs
->drv
;
2973 if (drv
->bdrv_save_vmstate
)
2974 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2976 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2980 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2981 int64_t pos
, int size
)
2983 BlockDriver
*drv
= bs
->drv
;
2986 if (drv
->bdrv_load_vmstate
)
2987 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2989 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2993 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2995 BlockDriver
*drv
= bs
->drv
;
2997 if (!drv
|| !drv
->bdrv_debug_event
) {
3001 drv
->bdrv_debug_event(bs
, event
);
3005 /**************************************************************/
3006 /* handling of snapshots */
3008 int bdrv_can_snapshot(BlockDriverState
*bs
)
3010 BlockDriver
*drv
= bs
->drv
;
3011 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3015 if (!drv
->bdrv_snapshot_create
) {
3016 if (bs
->file
!= NULL
) {
3017 return bdrv_can_snapshot(bs
->file
);
3025 int bdrv_is_snapshot(BlockDriverState
*bs
)
3027 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3030 BlockDriverState
*bdrv_snapshots(void)
3032 BlockDriverState
*bs
;
3035 return bs_snapshots
;
3039 while ((bs
= bdrv_next(bs
))) {
3040 if (bdrv_can_snapshot(bs
)) {
3048 int bdrv_snapshot_create(BlockDriverState
*bs
,
3049 QEMUSnapshotInfo
*sn_info
)
3051 BlockDriver
*drv
= bs
->drv
;
3054 if (drv
->bdrv_snapshot_create
)
3055 return drv
->bdrv_snapshot_create(bs
, sn_info
);
3057 return bdrv_snapshot_create(bs
->file
, sn_info
);
3061 int bdrv_snapshot_goto(BlockDriverState
*bs
,
3062 const char *snapshot_id
)
3064 BlockDriver
*drv
= bs
->drv
;
3069 if (drv
->bdrv_snapshot_goto
)
3070 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
3073 drv
->bdrv_close(bs
);
3074 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
3075 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
3077 bdrv_delete(bs
->file
);
3087 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
3089 BlockDriver
*drv
= bs
->drv
;
3092 if (drv
->bdrv_snapshot_delete
)
3093 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
3095 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
3099 int bdrv_snapshot_list(BlockDriverState
*bs
,
3100 QEMUSnapshotInfo
**psn_info
)
3102 BlockDriver
*drv
= bs
->drv
;
3105 if (drv
->bdrv_snapshot_list
)
3106 return drv
->bdrv_snapshot_list(bs
, psn_info
);
3108 return bdrv_snapshot_list(bs
->file
, psn_info
);
3112 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
3113 const char *snapshot_name
)
3115 BlockDriver
*drv
= bs
->drv
;
3119 if (!bs
->read_only
) {
3122 if (drv
->bdrv_snapshot_load_tmp
) {
3123 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
3128 /* backing_file can either be relative, or absolute, or a protocol. If it is
3129 * relative, it must be relative to the chain. So, passing in bs->filename
3130 * from a BDS as backing_file should not be done, as that may be relative to
3131 * the CWD rather than the chain. */
3132 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3133 const char *backing_file
)
3135 char *filename_full
= NULL
;
3136 char *backing_file_full
= NULL
;
3137 char *filename_tmp
= NULL
;
3138 int is_protocol
= 0;
3139 BlockDriverState
*curr_bs
= NULL
;
3140 BlockDriverState
*retval
= NULL
;
3142 if (!bs
|| !bs
->drv
|| !backing_file
) {
3146 filename_full
= g_malloc(PATH_MAX
);
3147 backing_file_full
= g_malloc(PATH_MAX
);
3148 filename_tmp
= g_malloc(PATH_MAX
);
3150 is_protocol
= path_has_protocol(backing_file
);
3152 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3154 /* If either of the filename paths is actually a protocol, then
3155 * compare unmodified paths; otherwise make paths relative */
3156 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3157 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3158 retval
= curr_bs
->backing_hd
;
3162 /* If not an absolute filename path, make it relative to the current
3163 * image's filename path */
3164 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3167 /* We are going to compare absolute pathnames */
3168 if (!realpath(filename_tmp
, filename_full
)) {
3172 /* We need to make sure the backing filename we are comparing against
3173 * is relative to the current image filename (or absolute) */
3174 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3175 curr_bs
->backing_file
);
3177 if (!realpath(filename_tmp
, backing_file_full
)) {
3181 if (strcmp(backing_file_full
, filename_full
) == 0) {
3182 retval
= curr_bs
->backing_hd
;
3188 g_free(filename_full
);
3189 g_free(backing_file_full
);
3190 g_free(filename_tmp
);
3194 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3200 if (!bs
->backing_hd
) {
3204 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3207 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
3209 BlockDriverState
*curr_bs
= NULL
;
3217 while (curr_bs
->backing_hd
) {
3218 curr_bs
= curr_bs
->backing_hd
;
3223 #define NB_SUFFIXES 4
3225 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
3227 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
3232 snprintf(buf
, buf_size
, "%" PRId64
, size
);
3235 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
3236 if (size
< (10 * base
)) {
3237 snprintf(buf
, buf_size
, "%0.1f%c",
3238 (double)size
/ base
,
3241 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
3242 snprintf(buf
, buf_size
, "%" PRId64
"%c",
3243 ((size
+ (base
>> 1)) / base
),
3253 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
3255 char buf1
[128], date_buf
[128], clock_buf
[128];
3265 snprintf(buf
, buf_size
,
3266 "%-10s%-20s%7s%20s%15s",
3267 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3271 ptm
= localtime(&ti
);
3272 strftime(date_buf
, sizeof(date_buf
),
3273 "%Y-%m-%d %H:%M:%S", ptm
);
3275 localtime_r(&ti
, &tm
);
3276 strftime(date_buf
, sizeof(date_buf
),
3277 "%Y-%m-%d %H:%M:%S", &tm
);
3279 secs
= sn
->vm_clock_nsec
/ 1000000000;
3280 snprintf(clock_buf
, sizeof(clock_buf
),
3281 "%02d:%02d:%02d.%03d",
3283 (int)((secs
/ 60) % 60),
3285 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
3286 snprintf(buf
, buf_size
,
3287 "%-10s%-20s%7s%20s%15s",
3288 sn
->id_str
, sn
->name
,
3289 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
3296 /**************************************************************/
3299 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3300 QEMUIOVector
*qiov
, int nb_sectors
,
3301 BlockDriverCompletionFunc
*cb
, void *opaque
)
3303 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3305 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3309 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3310 QEMUIOVector
*qiov
, int nb_sectors
,
3311 BlockDriverCompletionFunc
*cb
, void *opaque
)
3313 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3315 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3320 typedef struct MultiwriteCB
{
3325 BlockDriverCompletionFunc
*cb
;
3327 QEMUIOVector
*free_qiov
;
3331 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3335 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3336 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3337 if (mcb
->callbacks
[i
].free_qiov
) {
3338 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3340 g_free(mcb
->callbacks
[i
].free_qiov
);
3344 static void multiwrite_cb(void *opaque
, int ret
)
3346 MultiwriteCB
*mcb
= opaque
;
3348 trace_multiwrite_cb(mcb
, ret
);
3350 if (ret
< 0 && !mcb
->error
) {
3354 mcb
->num_requests
--;
3355 if (mcb
->num_requests
== 0) {
3356 multiwrite_user_cb(mcb
);
3361 static int multiwrite_req_compare(const void *a
, const void *b
)
3363 const BlockRequest
*req1
= a
, *req2
= b
;
3366 * Note that we can't simply subtract req2->sector from req1->sector
3367 * here as that could overflow the return value.
3369 if (req1
->sector
> req2
->sector
) {
3371 } else if (req1
->sector
< req2
->sector
) {
3379 * Takes a bunch of requests and tries to merge them. Returns the number of
3380 * requests that remain after merging.
3382 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3383 int num_reqs
, MultiwriteCB
*mcb
)
3387 // Sort requests by start sector
3388 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3390 // Check if adjacent requests touch the same clusters. If so, combine them,
3391 // filling up gaps with zero sectors.
3393 for (i
= 1; i
< num_reqs
; i
++) {
3395 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3397 // Handle exactly sequential writes and overlapping writes.
3398 if (reqs
[i
].sector
<= oldreq_last
) {
3402 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3408 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3409 qemu_iovec_init(qiov
,
3410 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3412 // Add the first request to the merged one. If the requests are
3413 // overlapping, drop the last sectors of the first request.
3414 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3415 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
3417 // We should need to add any zeros between the two requests
3418 assert (reqs
[i
].sector
<= oldreq_last
);
3420 // Add the second request
3421 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
3423 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3424 reqs
[outidx
].qiov
= qiov
;
3426 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3429 reqs
[outidx
].sector
= reqs
[i
].sector
;
3430 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3431 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3439 * Submit multiple AIO write requests at once.
3441 * On success, the function returns 0 and all requests in the reqs array have
3442 * been submitted. In error case this function returns -1, and any of the
3443 * requests may or may not be submitted yet. In particular, this means that the
3444 * callback will be called for some of the requests, for others it won't. The
3445 * caller must check the error field of the BlockRequest to wait for the right
3446 * callbacks (if error != 0, no callback will be called).
3448 * The implementation may modify the contents of the reqs array, e.g. to merge
3449 * requests. However, the fields opaque and error are left unmodified as they
3450 * are used to signal failure for a single request to the caller.
3452 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3457 /* don't submit writes if we don't have a medium */
3458 if (bs
->drv
== NULL
) {
3459 for (i
= 0; i
< num_reqs
; i
++) {
3460 reqs
[i
].error
= -ENOMEDIUM
;
3465 if (num_reqs
== 0) {
3469 // Create MultiwriteCB structure
3470 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3471 mcb
->num_requests
= 0;
3472 mcb
->num_callbacks
= num_reqs
;
3474 for (i
= 0; i
< num_reqs
; i
++) {
3475 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3476 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3479 // Check for mergable requests
3480 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3482 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3484 /* Run the aio requests. */
3485 mcb
->num_requests
= num_reqs
;
3486 for (i
= 0; i
< num_reqs
; i
++) {
3487 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3488 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3494 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3496 acb
->pool
->cancel(acb
);
3499 /* block I/O throttling */
3500 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3501 bool is_write
, double elapsed_time
, uint64_t *wait
)
3503 uint64_t bps_limit
= 0;
3504 double bytes_limit
, bytes_base
, bytes_res
;
3505 double slice_time
, wait_time
;
3507 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3508 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3509 } else if (bs
->io_limits
.bps
[is_write
]) {
3510 bps_limit
= bs
->io_limits
.bps
[is_write
];
3519 slice_time
= bs
->slice_end
- bs
->slice_start
;
3520 slice_time
/= (NANOSECONDS_PER_SECOND
);
3521 bytes_limit
= bps_limit
* slice_time
;
3522 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3523 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3524 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3527 /* bytes_base: the bytes of data which have been read/written; and
3528 * it is obtained from the history statistic info.
3529 * bytes_res: the remaining bytes of data which need to be read/written.
3530 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3531 * the total time for completing reading/writting all data.
3533 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3535 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3543 /* Calc approx time to dispatch */
3544 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3546 /* When the I/O rate at runtime exceeds the limits,
3547 * bs->slice_end need to be extended in order that the current statistic
3548 * info can be kept until the timer fire, so it is increased and tuned
3549 * based on the result of experiment.
3551 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3552 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3554 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3560 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3561 double elapsed_time
, uint64_t *wait
)
3563 uint64_t iops_limit
= 0;
3564 double ios_limit
, ios_base
;
3565 double slice_time
, wait_time
;
3567 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3568 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3569 } else if (bs
->io_limits
.iops
[is_write
]) {
3570 iops_limit
= bs
->io_limits
.iops
[is_write
];
3579 slice_time
= bs
->slice_end
- bs
->slice_start
;
3580 slice_time
/= (NANOSECONDS_PER_SECOND
);
3581 ios_limit
= iops_limit
* slice_time
;
3582 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3583 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3584 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3587 if (ios_base
+ 1 <= ios_limit
) {
3595 /* Calc approx time to dispatch */
3596 wait_time
= (ios_base
+ 1) / iops_limit
;
3597 if (wait_time
> elapsed_time
) {
3598 wait_time
= wait_time
- elapsed_time
;
3603 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3604 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3606 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3612 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3613 bool is_write
, int64_t *wait
)
3615 int64_t now
, max_wait
;
3616 uint64_t bps_wait
= 0, iops_wait
= 0;
3617 double elapsed_time
;
3618 int bps_ret
, iops_ret
;
3620 now
= qemu_get_clock_ns(vm_clock
);
3621 if ((bs
->slice_start
< now
)
3622 && (bs
->slice_end
> now
)) {
3623 bs
->slice_end
= now
+ bs
->slice_time
;
3625 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3626 bs
->slice_start
= now
;
3627 bs
->slice_end
= now
+ bs
->slice_time
;
3629 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3630 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3632 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3633 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3636 elapsed_time
= now
- bs
->slice_start
;
3637 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3639 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3640 is_write
, elapsed_time
, &bps_wait
);
3641 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3642 elapsed_time
, &iops_wait
);
3643 if (bps_ret
|| iops_ret
) {
3644 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3649 now
= qemu_get_clock_ns(vm_clock
);
3650 if (bs
->slice_end
< now
+ max_wait
) {
3651 bs
->slice_end
= now
+ max_wait
;
3664 /**************************************************************/
3665 /* async block device emulation */
3667 typedef struct BlockDriverAIOCBSync
{
3668 BlockDriverAIOCB common
;
3671 /* vector translation state */
3675 } BlockDriverAIOCBSync
;
3677 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3679 BlockDriverAIOCBSync
*acb
=
3680 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3681 qemu_bh_delete(acb
->bh
);
3683 qemu_aio_release(acb
);
3686 static AIOPool bdrv_em_aio_pool
= {
3687 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3688 .cancel
= bdrv_aio_cancel_em
,
3691 static void bdrv_aio_bh_cb(void *opaque
)
3693 BlockDriverAIOCBSync
*acb
= opaque
;
3696 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3697 qemu_vfree(acb
->bounce
);
3698 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3699 qemu_bh_delete(acb
->bh
);
3701 qemu_aio_release(acb
);
3704 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3708 BlockDriverCompletionFunc
*cb
,
3713 BlockDriverAIOCBSync
*acb
;
3715 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3716 acb
->is_write
= is_write
;
3718 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3719 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3722 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3723 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3725 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3728 qemu_bh_schedule(acb
->bh
);
3730 return &acb
->common
;
3733 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3734 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3735 BlockDriverCompletionFunc
*cb
, void *opaque
)
3737 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3740 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3741 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3742 BlockDriverCompletionFunc
*cb
, void *opaque
)
3744 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3748 typedef struct BlockDriverAIOCBCoroutine
{
3749 BlockDriverAIOCB common
;
3753 } BlockDriverAIOCBCoroutine
;
3755 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3760 static AIOPool bdrv_em_co_aio_pool
= {
3761 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3762 .cancel
= bdrv_aio_co_cancel_em
,
3765 static void bdrv_co_em_bh(void *opaque
)
3767 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3769 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3770 qemu_bh_delete(acb
->bh
);
3771 qemu_aio_release(acb
);
3774 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3775 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3777 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3778 BlockDriverState
*bs
= acb
->common
.bs
;
3780 if (!acb
->is_write
) {
3781 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3782 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3784 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3785 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3788 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3789 qemu_bh_schedule(acb
->bh
);
3792 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3796 BlockDriverCompletionFunc
*cb
,
3801 BlockDriverAIOCBCoroutine
*acb
;
3803 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3804 acb
->req
.sector
= sector_num
;
3805 acb
->req
.nb_sectors
= nb_sectors
;
3806 acb
->req
.qiov
= qiov
;
3807 acb
->is_write
= is_write
;
3809 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3810 qemu_coroutine_enter(co
, acb
);
3812 return &acb
->common
;
3815 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3817 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3818 BlockDriverState
*bs
= acb
->common
.bs
;
3820 acb
->req
.error
= bdrv_co_flush(bs
);
3821 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3822 qemu_bh_schedule(acb
->bh
);
3825 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3826 BlockDriverCompletionFunc
*cb
, void *opaque
)
3828 trace_bdrv_aio_flush(bs
, opaque
);
3831 BlockDriverAIOCBCoroutine
*acb
;
3833 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3834 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3835 qemu_coroutine_enter(co
, acb
);
3837 return &acb
->common
;
3840 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3842 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3843 BlockDriverState
*bs
= acb
->common
.bs
;
3845 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3846 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3847 qemu_bh_schedule(acb
->bh
);
3850 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3851 int64_t sector_num
, int nb_sectors
,
3852 BlockDriverCompletionFunc
*cb
, void *opaque
)
3855 BlockDriverAIOCBCoroutine
*acb
;
3857 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3859 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3860 acb
->req
.sector
= sector_num
;
3861 acb
->req
.nb_sectors
= nb_sectors
;
3862 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3863 qemu_coroutine_enter(co
, acb
);
3865 return &acb
->common
;
3868 void bdrv_init(void)
3870 module_call_init(MODULE_INIT_BLOCK
);
3873 void bdrv_init_with_whitelist(void)
3875 use_bdrv_whitelist
= 1;
3879 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3880 BlockDriverCompletionFunc
*cb
, void *opaque
)
3882 BlockDriverAIOCB
*acb
;
3884 if (pool
->free_aiocb
) {
3885 acb
= pool
->free_aiocb
;
3886 pool
->free_aiocb
= acb
->next
;
3888 acb
= g_malloc0(pool
->aiocb_size
);
3893 acb
->opaque
= opaque
;
3897 void qemu_aio_release(void *p
)
3899 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3900 AIOPool
*pool
= acb
->pool
;
3901 acb
->next
= pool
->free_aiocb
;
3902 pool
->free_aiocb
= acb
;
3905 /**************************************************************/
3906 /* Coroutine block device emulation */
3908 typedef struct CoroutineIOCompletion
{
3909 Coroutine
*coroutine
;
3911 } CoroutineIOCompletion
;
3913 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3915 CoroutineIOCompletion
*co
= opaque
;
3918 qemu_coroutine_enter(co
->coroutine
, NULL
);
3921 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3922 int nb_sectors
, QEMUIOVector
*iov
,
3925 CoroutineIOCompletion co
= {
3926 .coroutine
= qemu_coroutine_self(),
3928 BlockDriverAIOCB
*acb
;
3931 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3932 bdrv_co_io_em_complete
, &co
);
3934 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3935 bdrv_co_io_em_complete
, &co
);
3938 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3942 qemu_coroutine_yield();
3947 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3948 int64_t sector_num
, int nb_sectors
,
3951 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3954 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3955 int64_t sector_num
, int nb_sectors
,
3958 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3961 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3963 RwCo
*rwco
= opaque
;
3965 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3968 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3972 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3976 /* Write back cached data to the OS even with cache=unsafe */
3977 if (bs
->drv
->bdrv_co_flush_to_os
) {
3978 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3984 /* But don't actually force it to the disk with cache=unsafe */
3985 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3989 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3990 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
3991 } else if (bs
->drv
->bdrv_aio_flush
) {
3992 BlockDriverAIOCB
*acb
;
3993 CoroutineIOCompletion co
= {
3994 .coroutine
= qemu_coroutine_self(),
3997 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4001 qemu_coroutine_yield();
4006 * Some block drivers always operate in either writethrough or unsafe
4007 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4008 * know how the server works (because the behaviour is hardcoded or
4009 * depends on server-side configuration), so we can't ensure that
4010 * everything is safe on disk. Returning an error doesn't work because
4011 * that would break guests even if the server operates in writethrough
4014 * Let's hope the user knows what he's doing.
4022 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4023 * in the case of cache=unsafe, so there are no useless flushes.
4026 return bdrv_co_flush(bs
->file
);
4029 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4031 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4032 bs
->drv
->bdrv_invalidate_cache(bs
);
4036 void bdrv_invalidate_cache_all(void)
4038 BlockDriverState
*bs
;
4040 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4041 bdrv_invalidate_cache(bs
);
4045 void bdrv_clear_incoming_migration_all(void)
4047 BlockDriverState
*bs
;
4049 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4050 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4054 int bdrv_flush(BlockDriverState
*bs
)
4062 if (qemu_in_coroutine()) {
4063 /* Fast-path if already in coroutine context */
4064 bdrv_flush_co_entry(&rwco
);
4066 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4067 qemu_coroutine_enter(co
, &rwco
);
4068 while (rwco
.ret
== NOT_DONE
) {
4076 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4078 RwCo
*rwco
= opaque
;
4080 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4083 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4088 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4090 } else if (bs
->read_only
) {
4092 } else if (bs
->drv
->bdrv_co_discard
) {
4093 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
4094 } else if (bs
->drv
->bdrv_aio_discard
) {
4095 BlockDriverAIOCB
*acb
;
4096 CoroutineIOCompletion co
= {
4097 .coroutine
= qemu_coroutine_self(),
4100 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4101 bdrv_co_io_em_complete
, &co
);
4105 qemu_coroutine_yield();
4113 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4118 .sector_num
= sector_num
,
4119 .nb_sectors
= nb_sectors
,
4123 if (qemu_in_coroutine()) {
4124 /* Fast-path if already in coroutine context */
4125 bdrv_discard_co_entry(&rwco
);
4127 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4128 qemu_coroutine_enter(co
, &rwco
);
4129 while (rwco
.ret
== NOT_DONE
) {
4137 /**************************************************************/
4138 /* removable device support */
4141 * Return TRUE if the media is present
4143 int bdrv_is_inserted(BlockDriverState
*bs
)
4145 BlockDriver
*drv
= bs
->drv
;
4149 if (!drv
->bdrv_is_inserted
)
4151 return drv
->bdrv_is_inserted(bs
);
4155 * Return whether the media changed since the last call to this
4156 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4158 int bdrv_media_changed(BlockDriverState
*bs
)
4160 BlockDriver
*drv
= bs
->drv
;
4162 if (drv
&& drv
->bdrv_media_changed
) {
4163 return drv
->bdrv_media_changed(bs
);
4169 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4171 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4173 BlockDriver
*drv
= bs
->drv
;
4175 if (drv
&& drv
->bdrv_eject
) {
4176 drv
->bdrv_eject(bs
, eject_flag
);
4179 if (bs
->device_name
[0] != '\0') {
4180 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4185 * Lock or unlock the media (if it is locked, the user won't be able
4186 * to eject it manually).
4188 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4190 BlockDriver
*drv
= bs
->drv
;
4192 trace_bdrv_lock_medium(bs
, locked
);
4194 if (drv
&& drv
->bdrv_lock_medium
) {
4195 drv
->bdrv_lock_medium(bs
, locked
);
4199 /* needed for generic scsi interface */
4201 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
4203 BlockDriver
*drv
= bs
->drv
;
4205 if (drv
&& drv
->bdrv_ioctl
)
4206 return drv
->bdrv_ioctl(bs
, req
, buf
);
4210 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
4211 unsigned long int req
, void *buf
,
4212 BlockDriverCompletionFunc
*cb
, void *opaque
)
4214 BlockDriver
*drv
= bs
->drv
;
4216 if (drv
&& drv
->bdrv_aio_ioctl
)
4217 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
4221 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
4223 bs
->buffer_alignment
= align
;
4226 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
4228 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
4231 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
4233 int64_t bitmap_size
;
4235 bs
->dirty_count
= 0;
4237 if (!bs
->dirty_bitmap
) {
4238 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
4239 BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
- 1;
4240 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* BITS_PER_LONG
;
4242 bs
->dirty_bitmap
= g_new0(unsigned long, bitmap_size
);
4245 if (bs
->dirty_bitmap
) {
4246 g_free(bs
->dirty_bitmap
);
4247 bs
->dirty_bitmap
= NULL
;
4252 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4254 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
4256 if (bs
->dirty_bitmap
&&
4257 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
4258 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
4259 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
4265 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4268 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
4271 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4273 return bs
->dirty_count
;
4276 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4278 assert(bs
->in_use
!= in_use
);
4279 bs
->in_use
= in_use
;
4282 int bdrv_in_use(BlockDriverState
*bs
)
4287 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4289 bs
->iostatus_enabled
= true;
4290 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4293 /* The I/O status is only enabled if the drive explicitly
4294 * enables it _and_ the VM is configured to stop on errors */
4295 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4297 return (bs
->iostatus_enabled
&&
4298 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
4299 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
4300 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
4303 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4305 bs
->iostatus_enabled
= false;
4308 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4310 if (bdrv_iostatus_is_enabled(bs
)) {
4311 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4315 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4317 assert(bdrv_iostatus_is_enabled(bs
));
4318 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4319 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4320 BLOCK_DEVICE_IO_STATUS_FAILED
;
4325 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4326 enum BlockAcctType type
)
4328 assert(type
< BDRV_MAX_IOTYPE
);
4330 cookie
->bytes
= bytes
;
4331 cookie
->start_time_ns
= get_clock();
4332 cookie
->type
= type
;
4336 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4338 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4340 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4341 bs
->nr_ops
[cookie
->type
]++;
4342 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4345 int bdrv_img_create(const char *filename
, const char *fmt
,
4346 const char *base_filename
, const char *base_fmt
,
4347 char *options
, uint64_t img_size
, int flags
)
4349 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4350 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4351 BlockDriverState
*bs
= NULL
;
4352 BlockDriver
*drv
, *proto_drv
;
4353 BlockDriver
*backing_drv
= NULL
;
4356 /* Find driver and parse its options */
4357 drv
= bdrv_find_format(fmt
);
4359 error_report("Unknown file format '%s'", fmt
);
4364 proto_drv
= bdrv_find_protocol(filename
);
4366 error_report("Unknown protocol '%s'", filename
);
4371 create_options
= append_option_parameters(create_options
,
4372 drv
->create_options
);
4373 create_options
= append_option_parameters(create_options
,
4374 proto_drv
->create_options
);
4376 /* Create parameter list with default values */
4377 param
= parse_option_parameters("", create_options
, param
);
4379 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4381 /* Parse -o options */
4383 param
= parse_option_parameters(options
, create_options
, param
);
4384 if (param
== NULL
) {
4385 error_report("Invalid options for file format '%s'.", fmt
);
4391 if (base_filename
) {
4392 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4394 error_report("Backing file not supported for file format '%s'",
4402 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4403 error_report("Backing file format not supported for file "
4404 "format '%s'", fmt
);
4410 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4411 if (backing_file
&& backing_file
->value
.s
) {
4412 if (!strcmp(filename
, backing_file
->value
.s
)) {
4413 error_report("Error: Trying to create an image with the "
4414 "same filename as the backing file");
4420 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4421 if (backing_fmt
&& backing_fmt
->value
.s
) {
4422 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4424 error_report("Unknown backing file format '%s'",
4425 backing_fmt
->value
.s
);
4431 // The size for the image must always be specified, with one exception:
4432 // If we are using a backing file, we can obtain the size from there
4433 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4434 if (size
&& size
->value
.n
== -1) {
4435 if (backing_file
&& backing_file
->value
.s
) {
4440 /* backing files always opened read-only */
4442 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4446 ret
= bdrv_open(bs
, backing_file
->value
.s
, back_flags
, backing_drv
);
4448 error_report("Could not open '%s'", backing_file
->value
.s
);
4451 bdrv_get_geometry(bs
, &size
);
4454 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4455 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4457 error_report("Image creation needs a size parameter");
4463 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4464 print_option_parameters(param
);
4467 ret
= bdrv_create(drv
, filename
, param
);
4470 if (ret
== -ENOTSUP
) {
4471 error_report("Formatting or formatting option not supported for "
4472 "file format '%s'", fmt
);
4473 } else if (ret
== -EFBIG
) {
4474 error_report("The image size is too large for file format '%s'",
4477 error_report("%s: error while creating %s: %s", filename
, fmt
,
4483 free_option_parameters(create_options
);
4484 free_option_parameters(param
);