2 * QEMU System Emulator block driver
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "config-host.h"
25 #include "qemu-common.h"
28 #include "block_int.h"
31 #include "qemu-coroutine.h"
32 #include "qmp-commands.h"
33 #include "qemu-timer.h"
36 #include <sys/types.h>
38 #include <sys/ioctl.h>
39 #include <sys/queue.h>
49 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
52 BDRV_REQ_COPY_ON_READ
= 0x1,
53 BDRV_REQ_ZERO_WRITE
= 0x2,
56 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
57 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
58 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
59 BlockDriverCompletionFunc
*cb
, void *opaque
);
60 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
61 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
62 BlockDriverCompletionFunc
*cb
, void *opaque
);
63 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
64 int64_t sector_num
, int nb_sectors
,
66 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
67 int64_t sector_num
, int nb_sectors
,
69 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
70 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
71 BdrvRequestFlags flags
);
72 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
73 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
74 BdrvRequestFlags flags
);
75 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
79 BlockDriverCompletionFunc
*cb
,
82 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
84 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
85 bool is_write
, double elapsed_time
, uint64_t *wait
);
86 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
87 double elapsed_time
, uint64_t *wait
);
88 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
89 bool is_write
, int64_t *wait
);
91 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
92 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
94 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
95 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
97 /* The device to use for VM snapshots */
98 static BlockDriverState
*bs_snapshots
;
100 /* If non-zero, use only whitelisted block drivers */
101 static int use_bdrv_whitelist
;
104 static int is_windows_drive_prefix(const char *filename
)
106 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
107 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
111 int is_windows_drive(const char *filename
)
113 if (is_windows_drive_prefix(filename
) &&
116 if (strstart(filename
, "\\\\.\\", NULL
) ||
117 strstart(filename
, "//./", NULL
))
123 /* throttling disk I/O limits */
124 void bdrv_io_limits_disable(BlockDriverState
*bs
)
126 bs
->io_limits_enabled
= false;
128 while (qemu_co_queue_next(&bs
->throttled_reqs
));
130 if (bs
->block_timer
) {
131 qemu_del_timer(bs
->block_timer
);
132 qemu_free_timer(bs
->block_timer
);
133 bs
->block_timer
= NULL
;
139 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
142 static void bdrv_block_timer(void *opaque
)
144 BlockDriverState
*bs
= opaque
;
146 qemu_co_queue_next(&bs
->throttled_reqs
);
149 void bdrv_io_limits_enable(BlockDriverState
*bs
)
151 qemu_co_queue_init(&bs
->throttled_reqs
);
152 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
153 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
154 bs
->slice_start
= qemu_get_clock_ns(vm_clock
);
155 bs
->slice_end
= bs
->slice_start
+ bs
->slice_time
;
156 memset(&bs
->io_base
, 0, sizeof(bs
->io_base
));
157 bs
->io_limits_enabled
= true;
160 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
162 BlockIOLimit
*io_limits
= &bs
->io_limits
;
163 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
164 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
165 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
166 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
167 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
168 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
171 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
172 bool is_write
, int nb_sectors
)
174 int64_t wait_time
= -1;
176 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
177 qemu_co_queue_wait(&bs
->throttled_reqs
);
180 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
181 * throttled requests will not be dequeued until the current request is
182 * allowed to be serviced. So if the current request still exceeds the
183 * limits, it will be inserted to the head. All requests followed it will
184 * be still in throttled_reqs queue.
187 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
188 qemu_mod_timer(bs
->block_timer
,
189 wait_time
+ qemu_get_clock_ns(vm_clock
));
190 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
193 qemu_co_queue_next(&bs
->throttled_reqs
);
196 /* check if the path starts with "<protocol>:" */
197 static int path_has_protocol(const char *path
)
200 if (is_windows_drive(path
) ||
201 is_windows_drive_prefix(path
)) {
206 return strchr(path
, ':') != NULL
;
209 int path_is_absolute(const char *path
)
213 /* specific case for names like: "\\.\d:" */
214 if (*path
== '/' || *path
== '\\')
217 p
= strchr(path
, ':');
223 return (*p
== '/' || *p
== '\\');
229 /* if filename is absolute, just copy it to dest. Otherwise, build a
230 path to it by considering it is relative to base_path. URL are
232 void path_combine(char *dest
, int dest_size
,
233 const char *base_path
,
234 const char *filename
)
241 if (path_is_absolute(filename
)) {
242 pstrcpy(dest
, dest_size
, filename
);
244 p
= strchr(base_path
, ':');
249 p1
= strrchr(base_path
, '/');
253 p2
= strrchr(base_path
, '\\');
265 if (len
> dest_size
- 1)
267 memcpy(dest
, base_path
, len
);
269 pstrcat(dest
, dest_size
, filename
);
273 void bdrv_register(BlockDriver
*bdrv
)
275 /* Block drivers without coroutine functions need emulation */
276 if (!bdrv
->bdrv_co_readv
) {
277 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
278 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
280 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
281 * the block driver lacks aio we need to emulate that too.
283 if (!bdrv
->bdrv_aio_readv
) {
284 /* add AIO emulation layer */
285 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
286 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
290 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
293 /* create a new block device (by default it is empty) */
294 BlockDriverState
*bdrv_new(const char *device_name
)
296 BlockDriverState
*bs
;
298 bs
= g_malloc0(sizeof(BlockDriverState
));
299 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
300 if (device_name
[0] != '\0') {
301 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
303 bdrv_iostatus_disable(bs
);
307 BlockDriver
*bdrv_find_format(const char *format_name
)
310 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
311 if (!strcmp(drv1
->format_name
, format_name
)) {
318 static int bdrv_is_whitelisted(BlockDriver
*drv
)
320 static const char *whitelist
[] = {
321 CONFIG_BDRV_WHITELIST
326 return 1; /* no whitelist, anything goes */
328 for (p
= whitelist
; *p
; p
++) {
329 if (!strcmp(drv
->format_name
, *p
)) {
336 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
)
338 BlockDriver
*drv
= bdrv_find_format(format_name
);
339 return drv
&& bdrv_is_whitelisted(drv
) ? drv
: NULL
;
342 int bdrv_create(BlockDriver
*drv
, const char* filename
,
343 QEMUOptionParameter
*options
)
345 if (!drv
->bdrv_create
)
348 return drv
->bdrv_create(filename
, options
);
351 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
355 drv
= bdrv_find_protocol(filename
);
360 return bdrv_create(drv
, filename
, options
);
364 void get_tmp_filename(char *filename
, int size
)
366 char temp_dir
[MAX_PATH
];
368 GetTempPath(MAX_PATH
, temp_dir
);
369 GetTempFileName(temp_dir
, "qem", 0, filename
);
372 void get_tmp_filename(char *filename
, int size
)
376 /* XXX: race condition possible */
377 tmpdir
= getenv("TMPDIR");
380 snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
);
381 fd
= mkstemp(filename
);
387 * Detect host devices. By convention, /dev/cdrom[N] is always
388 * recognized as a host CDROM.
390 static BlockDriver
*find_hdev_driver(const char *filename
)
392 int score_max
= 0, score
;
393 BlockDriver
*drv
= NULL
, *d
;
395 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
396 if (d
->bdrv_probe_device
) {
397 score
= d
->bdrv_probe_device(filename
);
398 if (score
> score_max
) {
408 BlockDriver
*bdrv_find_protocol(const char *filename
)
415 /* TODO Drivers without bdrv_file_open must be specified explicitly */
418 * XXX(hch): we really should not let host device detection
419 * override an explicit protocol specification, but moving this
420 * later breaks access to device names with colons in them.
421 * Thanks to the brain-dead persistent naming schemes on udev-
422 * based Linux systems those actually are quite common.
424 drv1
= find_hdev_driver(filename
);
429 if (!path_has_protocol(filename
)) {
430 return bdrv_find_format("file");
432 p
= strchr(filename
, ':');
435 if (len
> sizeof(protocol
) - 1)
436 len
= sizeof(protocol
) - 1;
437 memcpy(protocol
, filename
, len
);
438 protocol
[len
] = '\0';
439 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
440 if (drv1
->protocol_name
&&
441 !strcmp(drv1
->protocol_name
, protocol
)) {
448 static int find_image_format(const char *filename
, BlockDriver
**pdrv
)
450 int ret
, score
, score_max
;
451 BlockDriver
*drv1
, *drv
;
453 BlockDriverState
*bs
;
455 ret
= bdrv_file_open(&bs
, filename
, 0);
461 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
462 if (bs
->sg
|| !bdrv_is_inserted(bs
)) {
464 drv
= bdrv_find_format("raw");
472 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
481 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
482 if (drv1
->bdrv_probe
) {
483 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
484 if (score
> score_max
) {
498 * Set the current 'total_sectors' value
500 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
502 BlockDriver
*drv
= bs
->drv
;
504 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
508 /* query actual device if possible, otherwise just trust the hint */
509 if (drv
->bdrv_getlength
) {
510 int64_t length
= drv
->bdrv_getlength(bs
);
514 hint
= length
>> BDRV_SECTOR_BITS
;
517 bs
->total_sectors
= hint
;
522 * Set open flags for a given cache mode
524 * Return 0 on success, -1 if the cache mode was invalid.
526 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
528 *flags
&= ~BDRV_O_CACHE_MASK
;
530 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
531 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
532 } else if (!strcmp(mode
, "directsync")) {
533 *flags
|= BDRV_O_NOCACHE
;
534 } else if (!strcmp(mode
, "writeback")) {
535 *flags
|= BDRV_O_CACHE_WB
;
536 } else if (!strcmp(mode
, "unsafe")) {
537 *flags
|= BDRV_O_CACHE_WB
;
538 *flags
|= BDRV_O_NO_FLUSH
;
539 } else if (!strcmp(mode
, "writethrough")) {
540 /* this is the default */
549 * The copy-on-read flag is actually a reference count so multiple users may
550 * use the feature without worrying about clobbering its previous state.
551 * Copy-on-read stays enabled until all users have called to disable it.
553 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
558 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
560 assert(bs
->copy_on_read
> 0);
565 * Common part for opening disk images and files
567 static int bdrv_open_common(BlockDriverState
*bs
, const char *filename
,
568 int flags
, BlockDriver
*drv
)
574 trace_bdrv_open_common(bs
, filename
, flags
, drv
->format_name
);
577 bs
->total_sectors
= 0;
581 bs
->open_flags
= flags
;
583 bs
->buffer_alignment
= 512;
585 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
586 if ((flags
& BDRV_O_RDWR
) && (flags
& BDRV_O_COPY_ON_READ
)) {
587 bdrv_enable_copy_on_read(bs
);
590 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
591 bs
->backing_file
[0] = '\0';
593 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
)) {
598 bs
->opaque
= g_malloc0(drv
->instance_size
);
600 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
603 * Clear flags that are internal to the block layer before opening the
606 open_flags
= flags
& ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
609 * Snapshots should be writable.
611 if (bs
->is_temporary
) {
612 open_flags
|= BDRV_O_RDWR
;
615 bs
->keep_read_only
= bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
617 /* Open the image, either directly or using a protocol */
618 if (drv
->bdrv_file_open
) {
619 ret
= drv
->bdrv_file_open(bs
, filename
, open_flags
);
621 ret
= bdrv_file_open(&bs
->file
, filename
, open_flags
);
623 ret
= drv
->bdrv_open(bs
, open_flags
);
631 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
637 if (bs
->is_temporary
) {
645 bdrv_delete(bs
->file
);
655 * Opens a file using a protocol (file, host_device, nbd, ...)
657 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
, int flags
)
659 BlockDriverState
*bs
;
663 drv
= bdrv_find_protocol(filename
);
669 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
680 * Opens a disk image (raw, qcow2, vmdk, ...)
682 int bdrv_open(BlockDriverState
*bs
, const char *filename
, int flags
,
686 char tmp_filename
[PATH_MAX
];
688 if (flags
& BDRV_O_SNAPSHOT
) {
689 BlockDriverState
*bs1
;
692 BlockDriver
*bdrv_qcow2
;
693 QEMUOptionParameter
*options
;
694 char backing_filename
[PATH_MAX
];
696 /* if snapshot, we create a temporary backing file and open it
697 instead of opening 'filename' directly */
699 /* if there is a backing file, use it */
701 ret
= bdrv_open(bs1
, filename
, 0, drv
);
706 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
708 if (bs1
->drv
&& bs1
->drv
->protocol_name
)
713 get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
715 /* Real path is meaningless for protocols */
717 snprintf(backing_filename
, sizeof(backing_filename
),
719 else if (!realpath(filename
, backing_filename
))
722 bdrv_qcow2
= bdrv_find_format("qcow2");
723 options
= parse_option_parameters("", bdrv_qcow2
->create_options
, NULL
);
725 set_option_parameter_int(options
, BLOCK_OPT_SIZE
, total_size
);
726 set_option_parameter(options
, BLOCK_OPT_BACKING_FILE
, backing_filename
);
728 set_option_parameter(options
, BLOCK_OPT_BACKING_FMT
,
732 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, options
);
733 free_option_parameters(options
);
738 filename
= tmp_filename
;
740 bs
->is_temporary
= 1;
743 /* Find the right image format driver */
745 ret
= find_image_format(filename
, &drv
);
749 goto unlink_and_fail
;
753 ret
= bdrv_open_common(bs
, filename
, flags
, drv
);
755 goto unlink_and_fail
;
758 /* If there is a backing file, use it */
759 if ((flags
& BDRV_O_NO_BACKING
) == 0 && bs
->backing_file
[0] != '\0') {
760 char backing_filename
[PATH_MAX
];
762 BlockDriver
*back_drv
= NULL
;
764 bs
->backing_hd
= bdrv_new("");
766 if (path_has_protocol(bs
->backing_file
)) {
767 pstrcpy(backing_filename
, sizeof(backing_filename
),
770 path_combine(backing_filename
, sizeof(backing_filename
),
771 filename
, bs
->backing_file
);
774 if (bs
->backing_format
[0] != '\0') {
775 back_drv
= bdrv_find_format(bs
->backing_format
);
778 /* backing files always opened read-only */
780 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
782 ret
= bdrv_open(bs
->backing_hd
, backing_filename
, back_flags
, back_drv
);
787 if (bs
->is_temporary
) {
788 bs
->backing_hd
->keep_read_only
= !(flags
& BDRV_O_RDWR
);
790 /* base image inherits from "parent" */
791 bs
->backing_hd
->keep_read_only
= bs
->keep_read_only
;
795 if (!bdrv_key_required(bs
)) {
796 bdrv_dev_change_media_cb(bs
, true);
799 /* throttling disk I/O limits */
800 if (bs
->io_limits_enabled
) {
801 bdrv_io_limits_enable(bs
);
807 if (bs
->is_temporary
) {
813 void bdrv_close(BlockDriverState
*bs
)
816 if (bs
== bs_snapshots
) {
819 if (bs
->backing_hd
) {
820 bdrv_delete(bs
->backing_hd
);
821 bs
->backing_hd
= NULL
;
823 bs
->drv
->bdrv_close(bs
);
826 if (bs
->is_temporary
) {
827 unlink(bs
->filename
);
832 bs
->copy_on_read
= 0;
834 if (bs
->file
!= NULL
) {
835 bdrv_close(bs
->file
);
838 bdrv_dev_change_media_cb(bs
, false);
841 /*throttling disk I/O limits*/
842 if (bs
->io_limits_enabled
) {
843 bdrv_io_limits_disable(bs
);
847 void bdrv_close_all(void)
849 BlockDriverState
*bs
;
851 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
857 * Wait for pending requests to complete across all BlockDriverStates
859 * This function does not flush data to disk, use bdrv_flush_all() for that
860 * after calling this function.
862 void bdrv_drain_all(void)
864 BlockDriverState
*bs
;
868 /* If requests are still pending there is a bug somewhere */
869 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
870 assert(QLIST_EMPTY(&bs
->tracked_requests
));
871 assert(qemu_co_queue_empty(&bs
->throttled_reqs
));
875 /* make a BlockDriverState anonymous by removing from bdrv_state list.
876 Also, NULL terminate the device_name to prevent double remove */
877 void bdrv_make_anon(BlockDriverState
*bs
)
879 if (bs
->device_name
[0] != '\0') {
880 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
882 bs
->device_name
[0] = '\0';
885 void bdrv_delete(BlockDriverState
*bs
)
889 /* remove from list, if necessary */
893 if (bs
->file
!= NULL
) {
894 bdrv_delete(bs
->file
);
897 assert(bs
!= bs_snapshots
);
901 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
902 /* TODO change to DeviceState *dev when all users are qdevified */
908 bdrv_iostatus_reset(bs
);
912 /* TODO qdevified devices don't use this, remove when devices are qdevified */
913 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
915 if (bdrv_attach_dev(bs
, dev
) < 0) {
920 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
921 /* TODO change to DeviceState *dev when all users are qdevified */
923 assert(bs
->dev
== dev
);
926 bs
->dev_opaque
= NULL
;
927 bs
->buffer_alignment
= 512;
930 /* TODO change to return DeviceState * when all users are qdevified */
931 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
936 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
940 bs
->dev_opaque
= opaque
;
941 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
946 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
947 BlockQMPEventAction action
, int is_read
)
950 const char *action_str
;
953 case BDRV_ACTION_REPORT
:
954 action_str
= "report";
956 case BDRV_ACTION_IGNORE
:
957 action_str
= "ignore";
959 case BDRV_ACTION_STOP
:
966 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
969 is_read
? "read" : "write");
970 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR
, data
);
972 qobject_decref(data
);
975 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
977 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
978 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
982 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
984 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
987 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
989 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
990 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
994 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
996 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
997 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1002 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1004 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1005 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1009 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1011 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1012 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1018 * Run consistency checks on an image
1020 * Returns 0 if the check could be completed (it doesn't mean that the image is
1021 * free of errors) or -errno when an internal error occurred. The results of the
1022 * check are stored in res.
1024 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
)
1026 if (bs
->drv
->bdrv_check
== NULL
) {
1030 memset(res
, 0, sizeof(*res
));
1031 return bs
->drv
->bdrv_check(bs
, res
);
1034 #define COMMIT_BUF_SECTORS 2048
1036 /* commit COW file into the raw image */
1037 int bdrv_commit(BlockDriverState
*bs
)
1039 BlockDriver
*drv
= bs
->drv
;
1040 BlockDriver
*backing_drv
;
1041 int64_t sector
, total_sectors
;
1042 int n
, ro
, open_flags
;
1043 int ret
= 0, rw_ret
= 0;
1045 char filename
[1024];
1046 BlockDriverState
*bs_rw
, *bs_ro
;
1051 if (!bs
->backing_hd
) {
1055 if (bs
->backing_hd
->keep_read_only
) {
1059 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1063 backing_drv
= bs
->backing_hd
->drv
;
1064 ro
= bs
->backing_hd
->read_only
;
1065 strncpy(filename
, bs
->backing_hd
->filename
, sizeof(filename
));
1066 open_flags
= bs
->backing_hd
->open_flags
;
1070 bdrv_delete(bs
->backing_hd
);
1071 bs
->backing_hd
= NULL
;
1072 bs_rw
= bdrv_new("");
1073 rw_ret
= bdrv_open(bs_rw
, filename
, open_flags
| BDRV_O_RDWR
,
1077 /* try to re-open read-only */
1078 bs_ro
= bdrv_new("");
1079 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1083 /* drive not functional anymore */
1087 bs
->backing_hd
= bs_ro
;
1090 bs
->backing_hd
= bs_rw
;
1093 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1094 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1096 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1097 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1099 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1104 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1111 if (drv
->bdrv_make_empty
) {
1112 ret
= drv
->bdrv_make_empty(bs
);
1117 * Make sure all data we wrote to the backing device is actually
1121 bdrv_flush(bs
->backing_hd
);
1128 bdrv_delete(bs
->backing_hd
);
1129 bs
->backing_hd
= NULL
;
1130 bs_ro
= bdrv_new("");
1131 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1135 /* drive not functional anymore */
1139 bs
->backing_hd
= bs_ro
;
1140 bs
->backing_hd
->keep_read_only
= 0;
1146 void bdrv_commit_all(void)
1148 BlockDriverState
*bs
;
1150 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1155 struct BdrvTrackedRequest
{
1156 BlockDriverState
*bs
;
1160 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1161 Coroutine
*co
; /* owner, used for deadlock detection */
1162 CoQueue wait_queue
; /* coroutines blocked on this request */
1166 * Remove an active request from the tracked requests list
1168 * This function should be called when a tracked request is completing.
1170 static void tracked_request_end(BdrvTrackedRequest
*req
)
1172 QLIST_REMOVE(req
, list
);
1173 qemu_co_queue_restart_all(&req
->wait_queue
);
1177 * Add an active request to the tracked requests list
1179 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1180 BlockDriverState
*bs
,
1182 int nb_sectors
, bool is_write
)
1184 *req
= (BdrvTrackedRequest
){
1186 .sector_num
= sector_num
,
1187 .nb_sectors
= nb_sectors
,
1188 .is_write
= is_write
,
1189 .co
= qemu_coroutine_self(),
1192 qemu_co_queue_init(&req
->wait_queue
);
1194 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1198 * Round a region to cluster boundaries
1200 static void round_to_clusters(BlockDriverState
*bs
,
1201 int64_t sector_num
, int nb_sectors
,
1202 int64_t *cluster_sector_num
,
1203 int *cluster_nb_sectors
)
1205 BlockDriverInfo bdi
;
1207 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1208 *cluster_sector_num
= sector_num
;
1209 *cluster_nb_sectors
= nb_sectors
;
1211 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1212 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1213 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1218 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1219 int64_t sector_num
, int nb_sectors
) {
1221 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1225 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1231 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1232 int64_t sector_num
, int nb_sectors
)
1234 BdrvTrackedRequest
*req
;
1235 int64_t cluster_sector_num
;
1236 int cluster_nb_sectors
;
1239 /* If we touch the same cluster it counts as an overlap. This guarantees
1240 * that allocating writes will be serialized and not race with each other
1241 * for the same cluster. For example, in copy-on-read it ensures that the
1242 * CoR read and write operations are atomic and guest writes cannot
1243 * interleave between them.
1245 round_to_clusters(bs
, sector_num
, nb_sectors
,
1246 &cluster_sector_num
, &cluster_nb_sectors
);
1250 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1251 if (tracked_request_overlaps(req
, cluster_sector_num
,
1252 cluster_nb_sectors
)) {
1253 /* Hitting this means there was a reentrant request, for
1254 * example, a block driver issuing nested requests. This must
1255 * never happen since it means deadlock.
1257 assert(qemu_coroutine_self() != req
->co
);
1259 qemu_co_queue_wait(&req
->wait_queue
);
1270 * -EINVAL - backing format specified, but no file
1271 * -ENOSPC - can't update the backing file because no space is left in the
1273 * -ENOTSUP - format driver doesn't support changing the backing file
1275 int bdrv_change_backing_file(BlockDriverState
*bs
,
1276 const char *backing_file
, const char *backing_fmt
)
1278 BlockDriver
*drv
= bs
->drv
;
1280 if (drv
->bdrv_change_backing_file
!= NULL
) {
1281 return drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1287 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1292 if (!bdrv_is_inserted(bs
))
1298 len
= bdrv_getlength(bs
);
1303 if ((offset
> len
) || (len
- offset
< size
))
1309 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1312 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1313 nb_sectors
* BDRV_SECTOR_SIZE
);
1316 typedef struct RwCo
{
1317 BlockDriverState
*bs
;
1325 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1327 RwCo
*rwco
= opaque
;
1329 if (!rwco
->is_write
) {
1330 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1331 rwco
->nb_sectors
, rwco
->qiov
, 0);
1333 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1334 rwco
->nb_sectors
, rwco
->qiov
, 0);
1339 * Process a synchronous request using coroutines
1341 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1342 int nb_sectors
, bool is_write
)
1345 struct iovec iov
= {
1346 .iov_base
= (void *)buf
,
1347 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1352 .sector_num
= sector_num
,
1353 .nb_sectors
= nb_sectors
,
1355 .is_write
= is_write
,
1359 qemu_iovec_init_external(&qiov
, &iov
, 1);
1361 if (qemu_in_coroutine()) {
1362 /* Fast-path if already in coroutine context */
1363 bdrv_rw_co_entry(&rwco
);
1365 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1366 qemu_coroutine_enter(co
, &rwco
);
1367 while (rwco
.ret
== NOT_DONE
) {
1374 /* return < 0 if error. See bdrv_write() for the return codes */
1375 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1376 uint8_t *buf
, int nb_sectors
)
1378 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1381 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1382 int nb_sectors
, int dirty
)
1385 unsigned long val
, idx
, bit
;
1387 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
1388 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
1390 for (; start
<= end
; start
++) {
1391 idx
= start
/ (sizeof(unsigned long) * 8);
1392 bit
= start
% (sizeof(unsigned long) * 8);
1393 val
= bs
->dirty_bitmap
[idx
];
1395 if (!(val
& (1UL << bit
))) {
1400 if (val
& (1UL << bit
)) {
1402 val
&= ~(1UL << bit
);
1405 bs
->dirty_bitmap
[idx
] = val
;
1409 /* Return < 0 if error. Important errors are:
1410 -EIO generic I/O error (may happen for all errors)
1411 -ENOMEDIUM No media inserted.
1412 -EINVAL Invalid sector number or nb_sectors
1413 -EACCES Trying to write a read-only device
1415 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
1416 const uint8_t *buf
, int nb_sectors
)
1418 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
1421 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
1422 void *buf
, int count1
)
1424 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1425 int len
, nb_sectors
, count
;
1430 /* first read to align to sector start */
1431 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1434 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1436 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1438 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
1446 /* read the sectors "in place" */
1447 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1448 if (nb_sectors
> 0) {
1449 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1451 sector_num
+= nb_sectors
;
1452 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1457 /* add data from the last sector */
1459 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1461 memcpy(buf
, tmp_buf
, count
);
1466 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
1467 const void *buf
, int count1
)
1469 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1470 int len
, nb_sectors
, count
;
1475 /* first write to align to sector start */
1476 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1479 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1481 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1483 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
1484 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1493 /* write the sectors "in place" */
1494 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1495 if (nb_sectors
> 0) {
1496 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1498 sector_num
+= nb_sectors
;
1499 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1504 /* add data from the last sector */
1506 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1508 memcpy(tmp_buf
, buf
, count
);
1509 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1516 * Writes to the file and ensures that no writes are reordered across this
1517 * request (acts as a barrier)
1519 * Returns 0 on success, -errno in error cases.
1521 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
1522 const void *buf
, int count
)
1526 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
1531 /* No flush needed for cache modes that use O_DSYNC */
1532 if ((bs
->open_flags
& BDRV_O_CACHE_WB
) != 0) {
1539 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
1540 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1542 /* Perform I/O through a temporary buffer so that users who scribble over
1543 * their read buffer while the operation is in progress do not end up
1544 * modifying the image file. This is critical for zero-copy guest I/O
1545 * where anything might happen inside guest memory.
1547 void *bounce_buffer
;
1549 BlockDriver
*drv
= bs
->drv
;
1551 QEMUIOVector bounce_qiov
;
1552 int64_t cluster_sector_num
;
1553 int cluster_nb_sectors
;
1557 /* Cover entire cluster so no additional backing file I/O is required when
1558 * allocating cluster in the image file.
1560 round_to_clusters(bs
, sector_num
, nb_sectors
,
1561 &cluster_sector_num
, &cluster_nb_sectors
);
1563 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
1564 cluster_sector_num
, cluster_nb_sectors
);
1566 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
1567 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
1568 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
1570 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
1576 if (drv
->bdrv_co_write_zeroes
&&
1577 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
1578 ret
= drv
->bdrv_co_write_zeroes(bs
, cluster_sector_num
,
1579 cluster_nb_sectors
);
1581 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
1586 /* It might be okay to ignore write errors for guest requests. If this
1587 * is a deliberate copy-on-read then we don't want to ignore the error.
1588 * Simply report it in all cases.
1593 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
1594 qemu_iovec_from_buffer(qiov
, bounce_buffer
+ skip_bytes
,
1595 nb_sectors
* BDRV_SECTOR_SIZE
);
1598 qemu_vfree(bounce_buffer
);
1603 * Handle a read request in coroutine context
1605 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
1606 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1607 BdrvRequestFlags flags
)
1609 BlockDriver
*drv
= bs
->drv
;
1610 BdrvTrackedRequest req
;
1616 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1620 /* throttling disk read I/O */
1621 if (bs
->io_limits_enabled
) {
1622 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
1625 if (bs
->copy_on_read
) {
1626 flags
|= BDRV_REQ_COPY_ON_READ
;
1628 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1629 bs
->copy_on_read_in_flight
++;
1632 if (bs
->copy_on_read_in_flight
) {
1633 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1636 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
1638 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1641 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
1646 if (!ret
|| pnum
!= nb_sectors
) {
1647 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
1652 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
1655 tracked_request_end(&req
);
1657 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1658 bs
->copy_on_read_in_flight
--;
1664 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1665 int nb_sectors
, QEMUIOVector
*qiov
)
1667 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
1669 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
1672 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
1673 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1675 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
1677 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
1678 BDRV_REQ_COPY_ON_READ
);
1681 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
1682 int64_t sector_num
, int nb_sectors
)
1684 BlockDriver
*drv
= bs
->drv
;
1689 /* First try the efficient write zeroes operation */
1690 if (drv
->bdrv_co_write_zeroes
) {
1691 return drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1694 /* Fall back to bounce buffer if write zeroes is unsupported */
1695 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
1696 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
1697 memset(iov
.iov_base
, 0, iov
.iov_len
);
1698 qemu_iovec_init_external(&qiov
, &iov
, 1);
1700 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
1702 qemu_vfree(iov
.iov_base
);
1707 * Handle a write request in coroutine context
1709 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
1710 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1711 BdrvRequestFlags flags
)
1713 BlockDriver
*drv
= bs
->drv
;
1714 BdrvTrackedRequest req
;
1720 if (bs
->read_only
) {
1723 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1727 /* throttling disk write I/O */
1728 if (bs
->io_limits_enabled
) {
1729 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
1732 if (bs
->copy_on_read_in_flight
) {
1733 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1736 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
1738 if (flags
& BDRV_REQ_ZERO_WRITE
) {
1739 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
1741 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
1744 if (bs
->dirty_bitmap
) {
1745 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
1748 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
1749 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
1752 tracked_request_end(&req
);
1757 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
1758 int nb_sectors
, QEMUIOVector
*qiov
)
1760 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
1762 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
1765 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
1766 int64_t sector_num
, int nb_sectors
)
1768 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1770 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
1771 BDRV_REQ_ZERO_WRITE
);
1775 * Truncate file to 'offset' bytes (needed only for file protocols)
1777 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
1779 BlockDriver
*drv
= bs
->drv
;
1783 if (!drv
->bdrv_truncate
)
1787 if (bdrv_in_use(bs
))
1789 ret
= drv
->bdrv_truncate(bs
, offset
);
1791 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
1792 bdrv_dev_resize_cb(bs
);
1798 * Length of a allocated file in bytes. Sparse files are counted by actual
1799 * allocated space. Return < 0 if error or unknown.
1801 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
1803 BlockDriver
*drv
= bs
->drv
;
1807 if (drv
->bdrv_get_allocated_file_size
) {
1808 return drv
->bdrv_get_allocated_file_size(bs
);
1811 return bdrv_get_allocated_file_size(bs
->file
);
1817 * Length of a file in bytes. Return < 0 if error or unknown.
1819 int64_t bdrv_getlength(BlockDriverState
*bs
)
1821 BlockDriver
*drv
= bs
->drv
;
1825 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
1826 if (drv
->bdrv_getlength
) {
1827 return drv
->bdrv_getlength(bs
);
1830 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1833 /* return 0 as number of sectors if no device present or error */
1834 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
1837 length
= bdrv_getlength(bs
);
1841 length
= length
>> BDRV_SECTOR_BITS
;
1842 *nb_sectors_ptr
= length
;
1846 uint8_t boot_ind
; /* 0x80 - active */
1847 uint8_t head
; /* starting head */
1848 uint8_t sector
; /* starting sector */
1849 uint8_t cyl
; /* starting cylinder */
1850 uint8_t sys_ind
; /* What partition type */
1851 uint8_t end_head
; /* end head */
1852 uint8_t end_sector
; /* end sector */
1853 uint8_t end_cyl
; /* end cylinder */
1854 uint32_t start_sect
; /* starting sector counting from 0 */
1855 uint32_t nr_sects
; /* nr of sectors in partition */
1858 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1859 static int guess_disk_lchs(BlockDriverState
*bs
,
1860 int *pcylinders
, int *pheads
, int *psectors
)
1862 uint8_t buf
[BDRV_SECTOR_SIZE
];
1863 int ret
, i
, heads
, sectors
, cylinders
;
1864 struct partition
*p
;
1866 uint64_t nb_sectors
;
1868 bdrv_get_geometry(bs
, &nb_sectors
);
1870 ret
= bdrv_read(bs
, 0, buf
, 1);
1873 /* test msdos magic */
1874 if (buf
[510] != 0x55 || buf
[511] != 0xaa)
1876 for(i
= 0; i
< 4; i
++) {
1877 p
= ((struct partition
*)(buf
+ 0x1be)) + i
;
1878 nr_sects
= le32_to_cpu(p
->nr_sects
);
1879 if (nr_sects
&& p
->end_head
) {
1880 /* We make the assumption that the partition terminates on
1881 a cylinder boundary */
1882 heads
= p
->end_head
+ 1;
1883 sectors
= p
->end_sector
& 63;
1886 cylinders
= nb_sectors
/ (heads
* sectors
);
1887 if (cylinders
< 1 || cylinders
> 16383)
1890 *psectors
= sectors
;
1891 *pcylinders
= cylinders
;
1893 printf("guessed geometry: LCHS=%d %d %d\n",
1894 cylinders
, heads
, sectors
);
1902 void bdrv_guess_geometry(BlockDriverState
*bs
, int *pcyls
, int *pheads
, int *psecs
)
1904 int translation
, lba_detected
= 0;
1905 int cylinders
, heads
, secs
;
1906 uint64_t nb_sectors
;
1908 /* if a geometry hint is available, use it */
1909 bdrv_get_geometry(bs
, &nb_sectors
);
1910 bdrv_get_geometry_hint(bs
, &cylinders
, &heads
, &secs
);
1911 translation
= bdrv_get_translation_hint(bs
);
1912 if (cylinders
!= 0) {
1917 if (guess_disk_lchs(bs
, &cylinders
, &heads
, &secs
) == 0) {
1919 /* if heads > 16, it means that a BIOS LBA
1920 translation was active, so the default
1921 hardware geometry is OK */
1923 goto default_geometry
;
1928 /* disable any translation to be in sync with
1929 the logical geometry */
1930 if (translation
== BIOS_ATA_TRANSLATION_AUTO
) {
1931 bdrv_set_translation_hint(bs
,
1932 BIOS_ATA_TRANSLATION_NONE
);
1937 /* if no geometry, use a standard physical disk geometry */
1938 cylinders
= nb_sectors
/ (16 * 63);
1940 if (cylinders
> 16383)
1942 else if (cylinders
< 2)
1947 if ((lba_detected
== 1) && (translation
== BIOS_ATA_TRANSLATION_AUTO
)) {
1948 if ((*pcyls
* *pheads
) <= 131072) {
1949 bdrv_set_translation_hint(bs
,
1950 BIOS_ATA_TRANSLATION_LARGE
);
1952 bdrv_set_translation_hint(bs
,
1953 BIOS_ATA_TRANSLATION_LBA
);
1957 bdrv_set_geometry_hint(bs
, *pcyls
, *pheads
, *psecs
);
1961 void bdrv_set_geometry_hint(BlockDriverState
*bs
,
1962 int cyls
, int heads
, int secs
)
1969 void bdrv_set_translation_hint(BlockDriverState
*bs
, int translation
)
1971 bs
->translation
= translation
;
1974 void bdrv_get_geometry_hint(BlockDriverState
*bs
,
1975 int *pcyls
, int *pheads
, int *psecs
)
1978 *pheads
= bs
->heads
;
1982 /* throttling disk io limits */
1983 void bdrv_set_io_limits(BlockDriverState
*bs
,
1984 BlockIOLimit
*io_limits
)
1986 bs
->io_limits
= *io_limits
;
1987 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
1990 /* Recognize floppy formats */
1991 typedef struct FDFormat
{
1998 static const FDFormat fd_formats
[] = {
1999 /* First entry is default format */
2000 /* 1.44 MB 3"1/2 floppy disks */
2001 { FDRIVE_DRV_144
, 18, 80, 1, },
2002 { FDRIVE_DRV_144
, 20, 80, 1, },
2003 { FDRIVE_DRV_144
, 21, 80, 1, },
2004 { FDRIVE_DRV_144
, 21, 82, 1, },
2005 { FDRIVE_DRV_144
, 21, 83, 1, },
2006 { FDRIVE_DRV_144
, 22, 80, 1, },
2007 { FDRIVE_DRV_144
, 23, 80, 1, },
2008 { FDRIVE_DRV_144
, 24, 80, 1, },
2009 /* 2.88 MB 3"1/2 floppy disks */
2010 { FDRIVE_DRV_288
, 36, 80, 1, },
2011 { FDRIVE_DRV_288
, 39, 80, 1, },
2012 { FDRIVE_DRV_288
, 40, 80, 1, },
2013 { FDRIVE_DRV_288
, 44, 80, 1, },
2014 { FDRIVE_DRV_288
, 48, 80, 1, },
2015 /* 720 kB 3"1/2 floppy disks */
2016 { FDRIVE_DRV_144
, 9, 80, 1, },
2017 { FDRIVE_DRV_144
, 10, 80, 1, },
2018 { FDRIVE_DRV_144
, 10, 82, 1, },
2019 { FDRIVE_DRV_144
, 10, 83, 1, },
2020 { FDRIVE_DRV_144
, 13, 80, 1, },
2021 { FDRIVE_DRV_144
, 14, 80, 1, },
2022 /* 1.2 MB 5"1/4 floppy disks */
2023 { FDRIVE_DRV_120
, 15, 80, 1, },
2024 { FDRIVE_DRV_120
, 18, 80, 1, },
2025 { FDRIVE_DRV_120
, 18, 82, 1, },
2026 { FDRIVE_DRV_120
, 18, 83, 1, },
2027 { FDRIVE_DRV_120
, 20, 80, 1, },
2028 /* 720 kB 5"1/4 floppy disks */
2029 { FDRIVE_DRV_120
, 9, 80, 1, },
2030 { FDRIVE_DRV_120
, 11, 80, 1, },
2031 /* 360 kB 5"1/4 floppy disks */
2032 { FDRIVE_DRV_120
, 9, 40, 1, },
2033 { FDRIVE_DRV_120
, 9, 40, 0, },
2034 { FDRIVE_DRV_120
, 10, 41, 1, },
2035 { FDRIVE_DRV_120
, 10, 42, 1, },
2036 /* 320 kB 5"1/4 floppy disks */
2037 { FDRIVE_DRV_120
, 8, 40, 1, },
2038 { FDRIVE_DRV_120
, 8, 40, 0, },
2039 /* 360 kB must match 5"1/4 better than 3"1/2... */
2040 { FDRIVE_DRV_144
, 9, 80, 0, },
2042 { FDRIVE_DRV_NONE
, -1, -1, 0, },
2045 void bdrv_get_floppy_geometry_hint(BlockDriverState
*bs
, int *nb_heads
,
2046 int *max_track
, int *last_sect
,
2047 FDriveType drive_in
, FDriveType
*drive
)
2049 const FDFormat
*parse
;
2050 uint64_t nb_sectors
, size
;
2051 int i
, first_match
, match
;
2053 bdrv_get_geometry_hint(bs
, nb_heads
, max_track
, last_sect
);
2054 if (*nb_heads
!= 0 && *max_track
!= 0 && *last_sect
!= 0) {
2055 /* User defined disk */
2057 bdrv_get_geometry(bs
, &nb_sectors
);
2060 for (i
= 0; ; i
++) {
2061 parse
= &fd_formats
[i
];
2062 if (parse
->drive
== FDRIVE_DRV_NONE
) {
2065 if (drive_in
== parse
->drive
||
2066 drive_in
== FDRIVE_DRV_NONE
) {
2067 size
= (parse
->max_head
+ 1) * parse
->max_track
*
2069 if (nb_sectors
== size
) {
2073 if (first_match
== -1) {
2079 if (first_match
== -1) {
2082 match
= first_match
;
2084 parse
= &fd_formats
[match
];
2086 *nb_heads
= parse
->max_head
+ 1;
2087 *max_track
= parse
->max_track
;
2088 *last_sect
= parse
->last_sect
;
2089 *drive
= parse
->drive
;
2093 int bdrv_get_translation_hint(BlockDriverState
*bs
)
2095 return bs
->translation
;
2098 void bdrv_set_on_error(BlockDriverState
*bs
, BlockErrorAction on_read_error
,
2099 BlockErrorAction on_write_error
)
2101 bs
->on_read_error
= on_read_error
;
2102 bs
->on_write_error
= on_write_error
;
2105 BlockErrorAction
bdrv_get_on_error(BlockDriverState
*bs
, int is_read
)
2107 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2110 int bdrv_is_read_only(BlockDriverState
*bs
)
2112 return bs
->read_only
;
2115 int bdrv_is_sg(BlockDriverState
*bs
)
2120 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2122 return bs
->enable_write_cache
;
2125 int bdrv_is_encrypted(BlockDriverState
*bs
)
2127 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2129 return bs
->encrypted
;
2132 int bdrv_key_required(BlockDriverState
*bs
)
2134 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2136 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2138 return (bs
->encrypted
&& !bs
->valid_key
);
2141 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2144 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2145 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2151 if (!bs
->encrypted
) {
2153 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2156 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2159 } else if (!bs
->valid_key
) {
2161 /* call the change callback now, we skipped it on open */
2162 bdrv_dev_change_media_cb(bs
, true);
2167 void bdrv_get_format(BlockDriverState
*bs
, char *buf
, int buf_size
)
2172 pstrcpy(buf
, buf_size
, bs
->drv
->format_name
);
2176 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2181 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2182 it(opaque
, drv
->format_name
);
2186 BlockDriverState
*bdrv_find(const char *name
)
2188 BlockDriverState
*bs
;
2190 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2191 if (!strcmp(name
, bs
->device_name
)) {
2198 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2201 return QTAILQ_FIRST(&bdrv_states
);
2203 return QTAILQ_NEXT(bs
, list
);
2206 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2208 BlockDriverState
*bs
;
2210 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2215 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2217 return bs
->device_name
;
2220 void bdrv_flush_all(void)
2222 BlockDriverState
*bs
;
2224 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2225 if (!bdrv_is_read_only(bs
) && bdrv_is_inserted(bs
)) {
2231 int bdrv_has_zero_init(BlockDriverState
*bs
)
2235 if (bs
->drv
->bdrv_has_zero_init
) {
2236 return bs
->drv
->bdrv_has_zero_init(bs
);
2242 typedef struct BdrvCoIsAllocatedData
{
2243 BlockDriverState
*bs
;
2249 } BdrvCoIsAllocatedData
;
2252 * Returns true iff the specified sector is present in the disk image. Drivers
2253 * not implementing the functionality are assumed to not support backing files,
2254 * hence all their sectors are reported as allocated.
2256 * If 'sector_num' is beyond the end of the disk image the return value is 0
2257 * and 'pnum' is set to 0.
2259 * 'pnum' is set to the number of sectors (including and immediately following
2260 * the specified sector) that are known to be in the same
2261 * allocated/unallocated state.
2263 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2264 * beyond the end of the disk image it will be clamped.
2266 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2267 int nb_sectors
, int *pnum
)
2271 if (sector_num
>= bs
->total_sectors
) {
2276 n
= bs
->total_sectors
- sector_num
;
2277 if (n
< nb_sectors
) {
2281 if (!bs
->drv
->bdrv_co_is_allocated
) {
2286 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2289 /* Coroutine wrapper for bdrv_is_allocated() */
2290 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2292 BdrvCoIsAllocatedData
*data
= opaque
;
2293 BlockDriverState
*bs
= data
->bs
;
2295 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2301 * Synchronous wrapper around bdrv_co_is_allocated().
2303 * See bdrv_co_is_allocated() for details.
2305 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2309 BdrvCoIsAllocatedData data
= {
2311 .sector_num
= sector_num
,
2312 .nb_sectors
= nb_sectors
,
2317 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2318 qemu_coroutine_enter(co
, &data
);
2319 while (!data
.done
) {
2325 BlockInfoList
*qmp_query_block(Error
**errp
)
2327 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2328 BlockDriverState
*bs
;
2330 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2331 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2333 info
->value
= g_malloc0(sizeof(*info
->value
));
2334 info
->value
->device
= g_strdup(bs
->device_name
);
2335 info
->value
->type
= g_strdup("unknown");
2336 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2337 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2339 if (bdrv_dev_has_removable_media(bs
)) {
2340 info
->value
->has_tray_open
= true;
2341 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2344 if (bdrv_iostatus_is_enabled(bs
)) {
2345 info
->value
->has_io_status
= true;
2346 info
->value
->io_status
= bs
->iostatus
;
2350 info
->value
->has_inserted
= true;
2351 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2352 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2353 info
->value
->inserted
->ro
= bs
->read_only
;
2354 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2355 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2356 if (bs
->backing_file
[0]) {
2357 info
->value
->inserted
->has_backing_file
= true;
2358 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2361 if (bs
->io_limits_enabled
) {
2362 info
->value
->inserted
->bps
=
2363 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2364 info
->value
->inserted
->bps_rd
=
2365 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2366 info
->value
->inserted
->bps_wr
=
2367 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2368 info
->value
->inserted
->iops
=
2369 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2370 info
->value
->inserted
->iops_rd
=
2371 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2372 info
->value
->inserted
->iops_wr
=
2373 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2377 /* XXX: waiting for the qapi to support GSList */
2379 head
= cur_item
= info
;
2381 cur_item
->next
= info
;
2389 /* Consider exposing this as a full fledged QMP command */
2390 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2394 s
= g_malloc0(sizeof(*s
));
2396 if (bs
->device_name
[0]) {
2397 s
->has_device
= true;
2398 s
->device
= g_strdup(bs
->device_name
);
2401 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2402 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2403 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2404 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2405 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2406 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2407 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2408 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2409 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2410 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2413 s
->has_parent
= true;
2414 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2420 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2422 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2423 BlockDriverState
*bs
;
2425 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2426 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2427 info
->value
= qmp_query_blockstat(bs
, NULL
);
2429 /* XXX: waiting for the qapi to support GSList */
2431 head
= cur_item
= info
;
2433 cur_item
->next
= info
;
2441 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2443 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2444 return bs
->backing_file
;
2445 else if (bs
->encrypted
)
2446 return bs
->filename
;
2451 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2452 char *filename
, int filename_size
)
2454 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2457 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2458 const uint8_t *buf
, int nb_sectors
)
2460 BlockDriver
*drv
= bs
->drv
;
2463 if (!drv
->bdrv_write_compressed
)
2465 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2468 if (bs
->dirty_bitmap
) {
2469 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2472 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2475 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2477 BlockDriver
*drv
= bs
->drv
;
2480 if (!drv
->bdrv_get_info
)
2482 memset(bdi
, 0, sizeof(*bdi
));
2483 return drv
->bdrv_get_info(bs
, bdi
);
2486 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2487 int64_t pos
, int size
)
2489 BlockDriver
*drv
= bs
->drv
;
2492 if (drv
->bdrv_save_vmstate
)
2493 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2495 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2499 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2500 int64_t pos
, int size
)
2502 BlockDriver
*drv
= bs
->drv
;
2505 if (drv
->bdrv_load_vmstate
)
2506 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2508 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2512 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2514 BlockDriver
*drv
= bs
->drv
;
2516 if (!drv
|| !drv
->bdrv_debug_event
) {
2520 return drv
->bdrv_debug_event(bs
, event
);
2524 /**************************************************************/
2525 /* handling of snapshots */
2527 int bdrv_can_snapshot(BlockDriverState
*bs
)
2529 BlockDriver
*drv
= bs
->drv
;
2530 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
2534 if (!drv
->bdrv_snapshot_create
) {
2535 if (bs
->file
!= NULL
) {
2536 return bdrv_can_snapshot(bs
->file
);
2544 int bdrv_is_snapshot(BlockDriverState
*bs
)
2546 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2549 BlockDriverState
*bdrv_snapshots(void)
2551 BlockDriverState
*bs
;
2554 return bs_snapshots
;
2558 while ((bs
= bdrv_next(bs
))) {
2559 if (bdrv_can_snapshot(bs
)) {
2567 int bdrv_snapshot_create(BlockDriverState
*bs
,
2568 QEMUSnapshotInfo
*sn_info
)
2570 BlockDriver
*drv
= bs
->drv
;
2573 if (drv
->bdrv_snapshot_create
)
2574 return drv
->bdrv_snapshot_create(bs
, sn_info
);
2576 return bdrv_snapshot_create(bs
->file
, sn_info
);
2580 int bdrv_snapshot_goto(BlockDriverState
*bs
,
2581 const char *snapshot_id
)
2583 BlockDriver
*drv
= bs
->drv
;
2588 if (drv
->bdrv_snapshot_goto
)
2589 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
2592 drv
->bdrv_close(bs
);
2593 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
2594 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
2596 bdrv_delete(bs
->file
);
2606 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2608 BlockDriver
*drv
= bs
->drv
;
2611 if (drv
->bdrv_snapshot_delete
)
2612 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
2614 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
2618 int bdrv_snapshot_list(BlockDriverState
*bs
,
2619 QEMUSnapshotInfo
**psn_info
)
2621 BlockDriver
*drv
= bs
->drv
;
2624 if (drv
->bdrv_snapshot_list
)
2625 return drv
->bdrv_snapshot_list(bs
, psn_info
);
2627 return bdrv_snapshot_list(bs
->file
, psn_info
);
2631 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
2632 const char *snapshot_name
)
2634 BlockDriver
*drv
= bs
->drv
;
2638 if (!bs
->read_only
) {
2641 if (drv
->bdrv_snapshot_load_tmp
) {
2642 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
2647 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2648 const char *backing_file
)
2654 if (bs
->backing_hd
) {
2655 if (strcmp(bs
->backing_file
, backing_file
) == 0) {
2656 return bs
->backing_hd
;
2658 return bdrv_find_backing_image(bs
->backing_hd
, backing_file
);
2665 #define NB_SUFFIXES 4
2667 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
2669 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
2674 snprintf(buf
, buf_size
, "%" PRId64
, size
);
2677 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
2678 if (size
< (10 * base
)) {
2679 snprintf(buf
, buf_size
, "%0.1f%c",
2680 (double)size
/ base
,
2683 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
2684 snprintf(buf
, buf_size
, "%" PRId64
"%c",
2685 ((size
+ (base
>> 1)) / base
),
2695 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
2697 char buf1
[128], date_buf
[128], clock_buf
[128];
2707 snprintf(buf
, buf_size
,
2708 "%-10s%-20s%7s%20s%15s",
2709 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2713 ptm
= localtime(&ti
);
2714 strftime(date_buf
, sizeof(date_buf
),
2715 "%Y-%m-%d %H:%M:%S", ptm
);
2717 localtime_r(&ti
, &tm
);
2718 strftime(date_buf
, sizeof(date_buf
),
2719 "%Y-%m-%d %H:%M:%S", &tm
);
2721 secs
= sn
->vm_clock_nsec
/ 1000000000;
2722 snprintf(clock_buf
, sizeof(clock_buf
),
2723 "%02d:%02d:%02d.%03d",
2725 (int)((secs
/ 60) % 60),
2727 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
2728 snprintf(buf
, buf_size
,
2729 "%-10s%-20s%7s%20s%15s",
2730 sn
->id_str
, sn
->name
,
2731 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
2738 /**************************************************************/
2741 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
2742 QEMUIOVector
*qiov
, int nb_sectors
,
2743 BlockDriverCompletionFunc
*cb
, void *opaque
)
2745 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
2747 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2751 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
2752 QEMUIOVector
*qiov
, int nb_sectors
,
2753 BlockDriverCompletionFunc
*cb
, void *opaque
)
2755 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
2757 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2762 typedef struct MultiwriteCB
{
2767 BlockDriverCompletionFunc
*cb
;
2769 QEMUIOVector
*free_qiov
;
2774 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
2778 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
2779 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
2780 if (mcb
->callbacks
[i
].free_qiov
) {
2781 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
2783 g_free(mcb
->callbacks
[i
].free_qiov
);
2784 qemu_vfree(mcb
->callbacks
[i
].free_buf
);
2788 static void multiwrite_cb(void *opaque
, int ret
)
2790 MultiwriteCB
*mcb
= opaque
;
2792 trace_multiwrite_cb(mcb
, ret
);
2794 if (ret
< 0 && !mcb
->error
) {
2798 mcb
->num_requests
--;
2799 if (mcb
->num_requests
== 0) {
2800 multiwrite_user_cb(mcb
);
2805 static int multiwrite_req_compare(const void *a
, const void *b
)
2807 const BlockRequest
*req1
= a
, *req2
= b
;
2810 * Note that we can't simply subtract req2->sector from req1->sector
2811 * here as that could overflow the return value.
2813 if (req1
->sector
> req2
->sector
) {
2815 } else if (req1
->sector
< req2
->sector
) {
2823 * Takes a bunch of requests and tries to merge them. Returns the number of
2824 * requests that remain after merging.
2826 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
2827 int num_reqs
, MultiwriteCB
*mcb
)
2831 // Sort requests by start sector
2832 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
2834 // Check if adjacent requests touch the same clusters. If so, combine them,
2835 // filling up gaps with zero sectors.
2837 for (i
= 1; i
< num_reqs
; i
++) {
2839 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
2841 // This handles the cases that are valid for all block drivers, namely
2842 // exactly sequential writes and overlapping writes.
2843 if (reqs
[i
].sector
<= oldreq_last
) {
2847 // The block driver may decide that it makes sense to combine requests
2848 // even if there is a gap of some sectors between them. In this case,
2849 // the gap is filled with zeros (therefore only applicable for yet
2850 // unused space in format like qcow2).
2851 if (!merge
&& bs
->drv
->bdrv_merge_requests
) {
2852 merge
= bs
->drv
->bdrv_merge_requests(bs
, &reqs
[outidx
], &reqs
[i
]);
2855 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
2861 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
2862 qemu_iovec_init(qiov
,
2863 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
2865 // Add the first request to the merged one. If the requests are
2866 // overlapping, drop the last sectors of the first request.
2867 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
2868 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, size
);
2870 // We might need to add some zeros between the two requests
2871 if (reqs
[i
].sector
> oldreq_last
) {
2872 size_t zero_bytes
= (reqs
[i
].sector
- oldreq_last
) << 9;
2873 uint8_t *buf
= qemu_blockalign(bs
, zero_bytes
);
2874 memset(buf
, 0, zero_bytes
);
2875 qemu_iovec_add(qiov
, buf
, zero_bytes
);
2876 mcb
->callbacks
[i
].free_buf
= buf
;
2879 // Add the second request
2880 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, reqs
[i
].qiov
->size
);
2882 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
2883 reqs
[outidx
].qiov
= qiov
;
2885 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
2888 reqs
[outidx
].sector
= reqs
[i
].sector
;
2889 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
2890 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
2898 * Submit multiple AIO write requests at once.
2900 * On success, the function returns 0 and all requests in the reqs array have
2901 * been submitted. In error case this function returns -1, and any of the
2902 * requests may or may not be submitted yet. In particular, this means that the
2903 * callback will be called for some of the requests, for others it won't. The
2904 * caller must check the error field of the BlockRequest to wait for the right
2905 * callbacks (if error != 0, no callback will be called).
2907 * The implementation may modify the contents of the reqs array, e.g. to merge
2908 * requests. However, the fields opaque and error are left unmodified as they
2909 * are used to signal failure for a single request to the caller.
2911 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
2916 /* don't submit writes if we don't have a medium */
2917 if (bs
->drv
== NULL
) {
2918 for (i
= 0; i
< num_reqs
; i
++) {
2919 reqs
[i
].error
= -ENOMEDIUM
;
2924 if (num_reqs
== 0) {
2928 // Create MultiwriteCB structure
2929 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
2930 mcb
->num_requests
= 0;
2931 mcb
->num_callbacks
= num_reqs
;
2933 for (i
= 0; i
< num_reqs
; i
++) {
2934 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
2935 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
2938 // Check for mergable requests
2939 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
2941 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
2943 /* Run the aio requests. */
2944 mcb
->num_requests
= num_reqs
;
2945 for (i
= 0; i
< num_reqs
; i
++) {
2946 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
2947 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
2953 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
2955 acb
->pool
->cancel(acb
);
2958 /* block I/O throttling */
2959 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
2960 bool is_write
, double elapsed_time
, uint64_t *wait
)
2962 uint64_t bps_limit
= 0;
2963 double bytes_limit
, bytes_base
, bytes_res
;
2964 double slice_time
, wait_time
;
2966 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
2967 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2968 } else if (bs
->io_limits
.bps
[is_write
]) {
2969 bps_limit
= bs
->io_limits
.bps
[is_write
];
2978 slice_time
= bs
->slice_end
- bs
->slice_start
;
2979 slice_time
/= (NANOSECONDS_PER_SECOND
);
2980 bytes_limit
= bps_limit
* slice_time
;
2981 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
2982 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
2983 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
2986 /* bytes_base: the bytes of data which have been read/written; and
2987 * it is obtained from the history statistic info.
2988 * bytes_res: the remaining bytes of data which need to be read/written.
2989 * (bytes_base + bytes_res) / bps_limit: used to calcuate
2990 * the total time for completing reading/writting all data.
2992 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
2994 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3002 /* Calc approx time to dispatch */
3003 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3005 /* When the I/O rate at runtime exceeds the limits,
3006 * bs->slice_end need to be extended in order that the current statistic
3007 * info can be kept until the timer fire, so it is increased and tuned
3008 * based on the result of experiment.
3010 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3011 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3013 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3019 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3020 double elapsed_time
, uint64_t *wait
)
3022 uint64_t iops_limit
= 0;
3023 double ios_limit
, ios_base
;
3024 double slice_time
, wait_time
;
3026 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3027 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3028 } else if (bs
->io_limits
.iops
[is_write
]) {
3029 iops_limit
= bs
->io_limits
.iops
[is_write
];
3038 slice_time
= bs
->slice_end
- bs
->slice_start
;
3039 slice_time
/= (NANOSECONDS_PER_SECOND
);
3040 ios_limit
= iops_limit
* slice_time
;
3041 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3042 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3043 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3046 if (ios_base
+ 1 <= ios_limit
) {
3054 /* Calc approx time to dispatch */
3055 wait_time
= (ios_base
+ 1) / iops_limit
;
3056 if (wait_time
> elapsed_time
) {
3057 wait_time
= wait_time
- elapsed_time
;
3062 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3063 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3065 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3071 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3072 bool is_write
, int64_t *wait
)
3074 int64_t now
, max_wait
;
3075 uint64_t bps_wait
= 0, iops_wait
= 0;
3076 double elapsed_time
;
3077 int bps_ret
, iops_ret
;
3079 now
= qemu_get_clock_ns(vm_clock
);
3080 if ((bs
->slice_start
< now
)
3081 && (bs
->slice_end
> now
)) {
3082 bs
->slice_end
= now
+ bs
->slice_time
;
3084 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3085 bs
->slice_start
= now
;
3086 bs
->slice_end
= now
+ bs
->slice_time
;
3088 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3089 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3091 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3092 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3095 elapsed_time
= now
- bs
->slice_start
;
3096 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3098 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3099 is_write
, elapsed_time
, &bps_wait
);
3100 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3101 elapsed_time
, &iops_wait
);
3102 if (bps_ret
|| iops_ret
) {
3103 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3108 now
= qemu_get_clock_ns(vm_clock
);
3109 if (bs
->slice_end
< now
+ max_wait
) {
3110 bs
->slice_end
= now
+ max_wait
;
3123 /**************************************************************/
3124 /* async block device emulation */
3126 typedef struct BlockDriverAIOCBSync
{
3127 BlockDriverAIOCB common
;
3130 /* vector translation state */
3134 } BlockDriverAIOCBSync
;
3136 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3138 BlockDriverAIOCBSync
*acb
=
3139 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3140 qemu_bh_delete(acb
->bh
);
3142 qemu_aio_release(acb
);
3145 static AIOPool bdrv_em_aio_pool
= {
3146 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3147 .cancel
= bdrv_aio_cancel_em
,
3150 static void bdrv_aio_bh_cb(void *opaque
)
3152 BlockDriverAIOCBSync
*acb
= opaque
;
3155 qemu_iovec_from_buffer(acb
->qiov
, acb
->bounce
, acb
->qiov
->size
);
3156 qemu_vfree(acb
->bounce
);
3157 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3158 qemu_bh_delete(acb
->bh
);
3160 qemu_aio_release(acb
);
3163 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3167 BlockDriverCompletionFunc
*cb
,
3172 BlockDriverAIOCBSync
*acb
;
3174 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3175 acb
->is_write
= is_write
;
3177 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3178 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3181 qemu_iovec_to_buffer(acb
->qiov
, acb
->bounce
);
3182 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3184 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3187 qemu_bh_schedule(acb
->bh
);
3189 return &acb
->common
;
3192 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3193 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3194 BlockDriverCompletionFunc
*cb
, void *opaque
)
3196 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3199 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3200 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3201 BlockDriverCompletionFunc
*cb
, void *opaque
)
3203 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3207 typedef struct BlockDriverAIOCBCoroutine
{
3208 BlockDriverAIOCB common
;
3212 } BlockDriverAIOCBCoroutine
;
3214 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3219 static AIOPool bdrv_em_co_aio_pool
= {
3220 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3221 .cancel
= bdrv_aio_co_cancel_em
,
3224 static void bdrv_co_em_bh(void *opaque
)
3226 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3228 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3229 qemu_bh_delete(acb
->bh
);
3230 qemu_aio_release(acb
);
3233 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3234 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3236 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3237 BlockDriverState
*bs
= acb
->common
.bs
;
3239 if (!acb
->is_write
) {
3240 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3241 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3243 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3244 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3247 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3248 qemu_bh_schedule(acb
->bh
);
3251 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3255 BlockDriverCompletionFunc
*cb
,
3260 BlockDriverAIOCBCoroutine
*acb
;
3262 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3263 acb
->req
.sector
= sector_num
;
3264 acb
->req
.nb_sectors
= nb_sectors
;
3265 acb
->req
.qiov
= qiov
;
3266 acb
->is_write
= is_write
;
3268 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3269 qemu_coroutine_enter(co
, acb
);
3271 return &acb
->common
;
3274 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3276 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3277 BlockDriverState
*bs
= acb
->common
.bs
;
3279 acb
->req
.error
= bdrv_co_flush(bs
);
3280 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3281 qemu_bh_schedule(acb
->bh
);
3284 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3285 BlockDriverCompletionFunc
*cb
, void *opaque
)
3287 trace_bdrv_aio_flush(bs
, opaque
);
3290 BlockDriverAIOCBCoroutine
*acb
;
3292 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3293 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3294 qemu_coroutine_enter(co
, acb
);
3296 return &acb
->common
;
3299 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3301 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3302 BlockDriverState
*bs
= acb
->common
.bs
;
3304 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3305 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3306 qemu_bh_schedule(acb
->bh
);
3309 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3310 int64_t sector_num
, int nb_sectors
,
3311 BlockDriverCompletionFunc
*cb
, void *opaque
)
3314 BlockDriverAIOCBCoroutine
*acb
;
3316 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3318 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3319 acb
->req
.sector
= sector_num
;
3320 acb
->req
.nb_sectors
= nb_sectors
;
3321 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3322 qemu_coroutine_enter(co
, acb
);
3324 return &acb
->common
;
3327 void bdrv_init(void)
3329 module_call_init(MODULE_INIT_BLOCK
);
3332 void bdrv_init_with_whitelist(void)
3334 use_bdrv_whitelist
= 1;
3338 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3339 BlockDriverCompletionFunc
*cb
, void *opaque
)
3341 BlockDriverAIOCB
*acb
;
3343 if (pool
->free_aiocb
) {
3344 acb
= pool
->free_aiocb
;
3345 pool
->free_aiocb
= acb
->next
;
3347 acb
= g_malloc0(pool
->aiocb_size
);
3352 acb
->opaque
= opaque
;
3356 void qemu_aio_release(void *p
)
3358 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3359 AIOPool
*pool
= acb
->pool
;
3360 acb
->next
= pool
->free_aiocb
;
3361 pool
->free_aiocb
= acb
;
3364 /**************************************************************/
3365 /* Coroutine block device emulation */
3367 typedef struct CoroutineIOCompletion
{
3368 Coroutine
*coroutine
;
3370 } CoroutineIOCompletion
;
3372 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3374 CoroutineIOCompletion
*co
= opaque
;
3377 qemu_coroutine_enter(co
->coroutine
, NULL
);
3380 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3381 int nb_sectors
, QEMUIOVector
*iov
,
3384 CoroutineIOCompletion co
= {
3385 .coroutine
= qemu_coroutine_self(),
3387 BlockDriverAIOCB
*acb
;
3390 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3391 bdrv_co_io_em_complete
, &co
);
3393 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3394 bdrv_co_io_em_complete
, &co
);
3397 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3401 qemu_coroutine_yield();
3406 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3407 int64_t sector_num
, int nb_sectors
,
3410 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3413 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3414 int64_t sector_num
, int nb_sectors
,
3417 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3420 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3422 RwCo
*rwco
= opaque
;
3424 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3427 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3435 /* Write back cached data to the OS even with cache=unsafe */
3436 if (bs
->drv
->bdrv_co_flush_to_os
) {
3437 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3443 /* But don't actually force it to the disk with cache=unsafe */
3444 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3448 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3449 return bs
->drv
->bdrv_co_flush_to_disk(bs
);
3450 } else if (bs
->drv
->bdrv_aio_flush
) {
3451 BlockDriverAIOCB
*acb
;
3452 CoroutineIOCompletion co
= {
3453 .coroutine
= qemu_coroutine_self(),
3456 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
3460 qemu_coroutine_yield();
3465 * Some block drivers always operate in either writethrough or unsafe
3466 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3467 * know how the server works (because the behaviour is hardcoded or
3468 * depends on server-side configuration), so we can't ensure that
3469 * everything is safe on disk. Returning an error doesn't work because
3470 * that would break guests even if the server operates in writethrough
3473 * Let's hope the user knows what he's doing.
3479 void bdrv_invalidate_cache(BlockDriverState
*bs
)
3481 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
3482 bs
->drv
->bdrv_invalidate_cache(bs
);
3486 void bdrv_invalidate_cache_all(void)
3488 BlockDriverState
*bs
;
3490 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3491 bdrv_invalidate_cache(bs
);
3495 int bdrv_flush(BlockDriverState
*bs
)
3503 if (qemu_in_coroutine()) {
3504 /* Fast-path if already in coroutine context */
3505 bdrv_flush_co_entry(&rwco
);
3507 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
3508 qemu_coroutine_enter(co
, &rwco
);
3509 while (rwco
.ret
== NOT_DONE
) {
3517 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
3519 RwCo
*rwco
= opaque
;
3521 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
3524 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
3529 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
3531 } else if (bs
->read_only
) {
3533 } else if (bs
->drv
->bdrv_co_discard
) {
3534 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
3535 } else if (bs
->drv
->bdrv_aio_discard
) {
3536 BlockDriverAIOCB
*acb
;
3537 CoroutineIOCompletion co
= {
3538 .coroutine
= qemu_coroutine_self(),
3541 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
3542 bdrv_co_io_em_complete
, &co
);
3546 qemu_coroutine_yield();
3554 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
3559 .sector_num
= sector_num
,
3560 .nb_sectors
= nb_sectors
,
3564 if (qemu_in_coroutine()) {
3565 /* Fast-path if already in coroutine context */
3566 bdrv_discard_co_entry(&rwco
);
3568 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
3569 qemu_coroutine_enter(co
, &rwco
);
3570 while (rwco
.ret
== NOT_DONE
) {
3578 /**************************************************************/
3579 /* removable device support */
3582 * Return TRUE if the media is present
3584 int bdrv_is_inserted(BlockDriverState
*bs
)
3586 BlockDriver
*drv
= bs
->drv
;
3590 if (!drv
->bdrv_is_inserted
)
3592 return drv
->bdrv_is_inserted(bs
);
3596 * Return whether the media changed since the last call to this
3597 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3599 int bdrv_media_changed(BlockDriverState
*bs
)
3601 BlockDriver
*drv
= bs
->drv
;
3603 if (drv
&& drv
->bdrv_media_changed
) {
3604 return drv
->bdrv_media_changed(bs
);
3610 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3612 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3614 BlockDriver
*drv
= bs
->drv
;
3616 if (drv
&& drv
->bdrv_eject
) {
3617 drv
->bdrv_eject(bs
, eject_flag
);
3622 * Lock or unlock the media (if it is locked, the user won't be able
3623 * to eject it manually).
3625 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3627 BlockDriver
*drv
= bs
->drv
;
3629 trace_bdrv_lock_medium(bs
, locked
);
3631 if (drv
&& drv
->bdrv_lock_medium
) {
3632 drv
->bdrv_lock_medium(bs
, locked
);
3636 /* needed for generic scsi interface */
3638 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
3640 BlockDriver
*drv
= bs
->drv
;
3642 if (drv
&& drv
->bdrv_ioctl
)
3643 return drv
->bdrv_ioctl(bs
, req
, buf
);
3647 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
3648 unsigned long int req
, void *buf
,
3649 BlockDriverCompletionFunc
*cb
, void *opaque
)
3651 BlockDriver
*drv
= bs
->drv
;
3653 if (drv
&& drv
->bdrv_aio_ioctl
)
3654 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
3658 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
3660 bs
->buffer_alignment
= align
;
3663 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
3665 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
3668 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
3670 int64_t bitmap_size
;
3672 bs
->dirty_count
= 0;
3674 if (!bs
->dirty_bitmap
) {
3675 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
3676 BDRV_SECTORS_PER_DIRTY_CHUNK
* 8 - 1;
3677 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* 8;
3679 bs
->dirty_bitmap
= g_malloc0(bitmap_size
);
3682 if (bs
->dirty_bitmap
) {
3683 g_free(bs
->dirty_bitmap
);
3684 bs
->dirty_bitmap
= NULL
;
3689 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
3691 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
3693 if (bs
->dirty_bitmap
&&
3694 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
3695 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
3696 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
3702 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3705 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
3708 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
3710 return bs
->dirty_count
;
3713 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
3715 assert(bs
->in_use
!= in_use
);
3716 bs
->in_use
= in_use
;
3719 int bdrv_in_use(BlockDriverState
*bs
)
3724 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3726 bs
->iostatus_enabled
= true;
3727 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3730 /* The I/O status is only enabled if the drive explicitly
3731 * enables it _and_ the VM is configured to stop on errors */
3732 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3734 return (bs
->iostatus_enabled
&&
3735 (bs
->on_write_error
== BLOCK_ERR_STOP_ENOSPC
||
3736 bs
->on_write_error
== BLOCK_ERR_STOP_ANY
||
3737 bs
->on_read_error
== BLOCK_ERR_STOP_ANY
));
3740 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3742 bs
->iostatus_enabled
= false;
3745 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3747 if (bdrv_iostatus_is_enabled(bs
)) {
3748 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3752 /* XXX: Today this is set by device models because it makes the implementation
3753 quite simple. However, the block layer knows about the error, so it's
3754 possible to implement this without device models being involved */
3755 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3757 if (bdrv_iostatus_is_enabled(bs
) &&
3758 bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3760 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3761 BLOCK_DEVICE_IO_STATUS_FAILED
;
3766 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
3767 enum BlockAcctType type
)
3769 assert(type
< BDRV_MAX_IOTYPE
);
3771 cookie
->bytes
= bytes
;
3772 cookie
->start_time_ns
= get_clock();
3773 cookie
->type
= type
;
3777 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
3779 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
3781 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
3782 bs
->nr_ops
[cookie
->type
]++;
3783 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
3786 int bdrv_img_create(const char *filename
, const char *fmt
,
3787 const char *base_filename
, const char *base_fmt
,
3788 char *options
, uint64_t img_size
, int flags
)
3790 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
3791 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
3792 BlockDriverState
*bs
= NULL
;
3793 BlockDriver
*drv
, *proto_drv
;
3794 BlockDriver
*backing_drv
= NULL
;
3797 /* Find driver and parse its options */
3798 drv
= bdrv_find_format(fmt
);
3800 error_report("Unknown file format '%s'", fmt
);
3805 proto_drv
= bdrv_find_protocol(filename
);
3807 error_report("Unknown protocol '%s'", filename
);
3812 create_options
= append_option_parameters(create_options
,
3813 drv
->create_options
);
3814 create_options
= append_option_parameters(create_options
,
3815 proto_drv
->create_options
);
3817 /* Create parameter list with default values */
3818 param
= parse_option_parameters("", create_options
, param
);
3820 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
3822 /* Parse -o options */
3824 param
= parse_option_parameters(options
, create_options
, param
);
3825 if (param
== NULL
) {
3826 error_report("Invalid options for file format '%s'.", fmt
);
3832 if (base_filename
) {
3833 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
3835 error_report("Backing file not supported for file format '%s'",
3843 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
3844 error_report("Backing file format not supported for file "
3845 "format '%s'", fmt
);
3851 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
3852 if (backing_file
&& backing_file
->value
.s
) {
3853 if (!strcmp(filename
, backing_file
->value
.s
)) {
3854 error_report("Error: Trying to create an image with the "
3855 "same filename as the backing file");
3861 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
3862 if (backing_fmt
&& backing_fmt
->value
.s
) {
3863 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
3865 error_report("Unknown backing file format '%s'",
3866 backing_fmt
->value
.s
);
3872 // The size for the image must always be specified, with one exception:
3873 // If we are using a backing file, we can obtain the size from there
3874 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
3875 if (size
&& size
->value
.n
== -1) {
3876 if (backing_file
&& backing_file
->value
.s
) {
3882 ret
= bdrv_open(bs
, backing_file
->value
.s
, flags
, backing_drv
);
3884 error_report("Could not open '%s'", backing_file
->value
.s
);
3887 bdrv_get_geometry(bs
, &size
);
3890 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
3891 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
3893 error_report("Image creation needs a size parameter");
3899 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
3900 print_option_parameters(param
);
3903 ret
= bdrv_create(drv
, filename
, param
);
3906 if (ret
== -ENOTSUP
) {
3907 error_report("Formatting or formatting option not supported for "
3908 "file format '%s'", fmt
);
3909 } else if (ret
== -EFBIG
) {
3910 error_report("The image size is too large for file format '%s'",
3913 error_report("%s: error while creating %s: %s", filename
, fmt
,
3919 free_option_parameters(create_options
);
3920 free_option_parameters(param
);
3929 void *block_job_create(const BlockJobType
*job_type
, BlockDriverState
*bs
,
3930 BlockDriverCompletionFunc
*cb
, void *opaque
)
3934 if (bs
->job
|| bdrv_in_use(bs
)) {
3937 bdrv_set_in_use(bs
, 1);
3939 job
= g_malloc0(job_type
->instance_size
);
3940 job
->job_type
= job_type
;
3943 job
->opaque
= opaque
;
3948 void block_job_complete(BlockJob
*job
, int ret
)
3950 BlockDriverState
*bs
= job
->bs
;
3952 assert(bs
->job
== job
);
3953 job
->cb(job
->opaque
, ret
);
3956 bdrv_set_in_use(bs
, 0);
3959 int block_job_set_speed(BlockJob
*job
, int64_t value
)
3961 if (!job
->job_type
->set_speed
) {
3964 return job
->job_type
->set_speed(job
, value
);
3967 void block_job_cancel(BlockJob
*job
)
3969 job
->cancelled
= true;
3972 bool block_job_is_cancelled(BlockJob
*job
)
3974 return job
->cancelled
;