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';
886 * Add new bs contents at the top of an image chain while the chain is
887 * live, while keeping required fields on the top layer.
889 * This will modify the BlockDriverState fields, and swap contents
890 * between bs_new and bs_top. Both bs_new and bs_top are modified.
892 * This function does not create any image files.
894 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
896 BlockDriverState tmp
;
898 /* the new bs must not be in bdrv_states */
899 bdrv_make_anon(bs_new
);
903 /* there are some fields that need to stay on the top layer: */
906 tmp
.dev_ops
= bs_top
->dev_ops
;
907 tmp
.dev_opaque
= bs_top
->dev_opaque
;
908 tmp
.dev
= bs_top
->dev
;
909 tmp
.buffer_alignment
= bs_top
->buffer_alignment
;
910 tmp
.copy_on_read
= bs_top
->copy_on_read
;
912 /* i/o timing parameters */
913 tmp
.slice_time
= bs_top
->slice_time
;
914 tmp
.slice_start
= bs_top
->slice_start
;
915 tmp
.slice_end
= bs_top
->slice_end
;
916 tmp
.io_limits
= bs_top
->io_limits
;
917 tmp
.io_base
= bs_top
->io_base
;
918 tmp
.throttled_reqs
= bs_top
->throttled_reqs
;
919 tmp
.block_timer
= bs_top
->block_timer
;
920 tmp
.io_limits_enabled
= bs_top
->io_limits_enabled
;
923 tmp
.cyls
= bs_top
->cyls
;
924 tmp
.heads
= bs_top
->heads
;
925 tmp
.secs
= bs_top
->secs
;
926 tmp
.translation
= bs_top
->translation
;
929 tmp
.on_read_error
= bs_top
->on_read_error
;
930 tmp
.on_write_error
= bs_top
->on_write_error
;
933 tmp
.iostatus_enabled
= bs_top
->iostatus_enabled
;
934 tmp
.iostatus
= bs_top
->iostatus
;
936 /* keep the same entry in bdrv_states */
937 pstrcpy(tmp
.device_name
, sizeof(tmp
.device_name
), bs_top
->device_name
);
938 tmp
.list
= bs_top
->list
;
940 /* The contents of 'tmp' will become bs_top, as we are
941 * swapping bs_new and bs_top contents. */
942 tmp
.backing_hd
= bs_new
;
943 pstrcpy(tmp
.backing_file
, sizeof(tmp
.backing_file
), bs_top
->filename
);
945 /* swap contents of the fixed new bs and the current top */
949 /* clear the copied fields in the new backing file */
950 bdrv_detach_dev(bs_new
, bs_new
->dev
);
952 qemu_co_queue_init(&bs_new
->throttled_reqs
);
953 memset(&bs_new
->io_base
, 0, sizeof(bs_new
->io_base
));
954 memset(&bs_new
->io_limits
, 0, sizeof(bs_new
->io_limits
));
955 bdrv_iostatus_disable(bs_new
);
957 /* we don't use bdrv_io_limits_disable() for this, because we don't want
958 * to affect or delete the block_timer, as it has been moved to bs_top */
959 bs_new
->io_limits_enabled
= false;
960 bs_new
->block_timer
= NULL
;
961 bs_new
->slice_time
= 0;
962 bs_new
->slice_start
= 0;
963 bs_new
->slice_end
= 0;
966 void bdrv_delete(BlockDriverState
*bs
)
970 /* remove from list, if necessary */
974 if (bs
->file
!= NULL
) {
975 bdrv_delete(bs
->file
);
978 assert(bs
!= bs_snapshots
);
982 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
983 /* TODO change to DeviceState *dev when all users are qdevified */
989 bdrv_iostatus_reset(bs
);
993 /* TODO qdevified devices don't use this, remove when devices are qdevified */
994 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
996 if (bdrv_attach_dev(bs
, dev
) < 0) {
1001 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1002 /* TODO change to DeviceState *dev when all users are qdevified */
1004 assert(bs
->dev
== dev
);
1007 bs
->dev_opaque
= NULL
;
1008 bs
->buffer_alignment
= 512;
1011 /* TODO change to return DeviceState * when all users are qdevified */
1012 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1017 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1021 bs
->dev_opaque
= opaque
;
1022 if (bdrv_dev_has_removable_media(bs
) && bs
== bs_snapshots
) {
1023 bs_snapshots
= NULL
;
1027 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1028 BlockQMPEventAction action
, int is_read
)
1031 const char *action_str
;
1034 case BDRV_ACTION_REPORT
:
1035 action_str
= "report";
1037 case BDRV_ACTION_IGNORE
:
1038 action_str
= "ignore";
1040 case BDRV_ACTION_STOP
:
1041 action_str
= "stop";
1047 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1050 is_read
? "read" : "write");
1051 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR
, data
);
1053 qobject_decref(data
);
1056 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1060 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1061 bdrv_get_device_name(bs
), ejected
);
1062 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1064 qobject_decref(data
);
1067 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1069 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1070 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1071 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1072 if (tray_was_closed
) {
1074 bdrv_emit_qmp_eject_event(bs
, true);
1078 bdrv_emit_qmp_eject_event(bs
, false);
1083 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1085 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1088 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1090 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1091 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1095 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1097 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1098 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1103 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1105 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1106 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1110 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1112 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1113 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1119 * Run consistency checks on an image
1121 * Returns 0 if the check could be completed (it doesn't mean that the image is
1122 * free of errors) or -errno when an internal error occurred. The results of the
1123 * check are stored in res.
1125 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
)
1127 if (bs
->drv
->bdrv_check
== NULL
) {
1131 memset(res
, 0, sizeof(*res
));
1132 return bs
->drv
->bdrv_check(bs
, res
);
1135 #define COMMIT_BUF_SECTORS 2048
1137 /* commit COW file into the raw image */
1138 int bdrv_commit(BlockDriverState
*bs
)
1140 BlockDriver
*drv
= bs
->drv
;
1141 BlockDriver
*backing_drv
;
1142 int64_t sector
, total_sectors
;
1143 int n
, ro
, open_flags
;
1144 int ret
= 0, rw_ret
= 0;
1146 char filename
[1024];
1147 BlockDriverState
*bs_rw
, *bs_ro
;
1152 if (!bs
->backing_hd
) {
1156 if (bs
->backing_hd
->keep_read_only
) {
1160 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1164 backing_drv
= bs
->backing_hd
->drv
;
1165 ro
= bs
->backing_hd
->read_only
;
1166 strncpy(filename
, bs
->backing_hd
->filename
, sizeof(filename
));
1167 open_flags
= bs
->backing_hd
->open_flags
;
1171 bdrv_delete(bs
->backing_hd
);
1172 bs
->backing_hd
= NULL
;
1173 bs_rw
= bdrv_new("");
1174 rw_ret
= bdrv_open(bs_rw
, filename
, open_flags
| BDRV_O_RDWR
,
1178 /* try to re-open read-only */
1179 bs_ro
= bdrv_new("");
1180 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1184 /* drive not functional anymore */
1188 bs
->backing_hd
= bs_ro
;
1191 bs
->backing_hd
= bs_rw
;
1194 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1195 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1197 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1198 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1200 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1205 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1212 if (drv
->bdrv_make_empty
) {
1213 ret
= drv
->bdrv_make_empty(bs
);
1218 * Make sure all data we wrote to the backing device is actually
1222 bdrv_flush(bs
->backing_hd
);
1229 bdrv_delete(bs
->backing_hd
);
1230 bs
->backing_hd
= NULL
;
1231 bs_ro
= bdrv_new("");
1232 ret
= bdrv_open(bs_ro
, filename
, open_flags
& ~BDRV_O_RDWR
,
1236 /* drive not functional anymore */
1240 bs
->backing_hd
= bs_ro
;
1241 bs
->backing_hd
->keep_read_only
= 0;
1247 int bdrv_commit_all(void)
1249 BlockDriverState
*bs
;
1251 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1252 int ret
= bdrv_commit(bs
);
1260 struct BdrvTrackedRequest
{
1261 BlockDriverState
*bs
;
1265 QLIST_ENTRY(BdrvTrackedRequest
) list
;
1266 Coroutine
*co
; /* owner, used for deadlock detection */
1267 CoQueue wait_queue
; /* coroutines blocked on this request */
1271 * Remove an active request from the tracked requests list
1273 * This function should be called when a tracked request is completing.
1275 static void tracked_request_end(BdrvTrackedRequest
*req
)
1277 QLIST_REMOVE(req
, list
);
1278 qemu_co_queue_restart_all(&req
->wait_queue
);
1282 * Add an active request to the tracked requests list
1284 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1285 BlockDriverState
*bs
,
1287 int nb_sectors
, bool is_write
)
1289 *req
= (BdrvTrackedRequest
){
1291 .sector_num
= sector_num
,
1292 .nb_sectors
= nb_sectors
,
1293 .is_write
= is_write
,
1294 .co
= qemu_coroutine_self(),
1297 qemu_co_queue_init(&req
->wait_queue
);
1299 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1303 * Round a region to cluster boundaries
1305 static void round_to_clusters(BlockDriverState
*bs
,
1306 int64_t sector_num
, int nb_sectors
,
1307 int64_t *cluster_sector_num
,
1308 int *cluster_nb_sectors
)
1310 BlockDriverInfo bdi
;
1312 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1313 *cluster_sector_num
= sector_num
;
1314 *cluster_nb_sectors
= nb_sectors
;
1316 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1317 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1318 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1323 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1324 int64_t sector_num
, int nb_sectors
) {
1326 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1330 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1336 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1337 int64_t sector_num
, int nb_sectors
)
1339 BdrvTrackedRequest
*req
;
1340 int64_t cluster_sector_num
;
1341 int cluster_nb_sectors
;
1344 /* If we touch the same cluster it counts as an overlap. This guarantees
1345 * that allocating writes will be serialized and not race with each other
1346 * for the same cluster. For example, in copy-on-read it ensures that the
1347 * CoR read and write operations are atomic and guest writes cannot
1348 * interleave between them.
1350 round_to_clusters(bs
, sector_num
, nb_sectors
,
1351 &cluster_sector_num
, &cluster_nb_sectors
);
1355 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1356 if (tracked_request_overlaps(req
, cluster_sector_num
,
1357 cluster_nb_sectors
)) {
1358 /* Hitting this means there was a reentrant request, for
1359 * example, a block driver issuing nested requests. This must
1360 * never happen since it means deadlock.
1362 assert(qemu_coroutine_self() != req
->co
);
1364 qemu_co_queue_wait(&req
->wait_queue
);
1375 * -EINVAL - backing format specified, but no file
1376 * -ENOSPC - can't update the backing file because no space is left in the
1378 * -ENOTSUP - format driver doesn't support changing the backing file
1380 int bdrv_change_backing_file(BlockDriverState
*bs
,
1381 const char *backing_file
, const char *backing_fmt
)
1383 BlockDriver
*drv
= bs
->drv
;
1385 if (drv
->bdrv_change_backing_file
!= NULL
) {
1386 return drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
1392 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
1397 if (!bdrv_is_inserted(bs
))
1403 len
= bdrv_getlength(bs
);
1408 if ((offset
> len
) || (len
- offset
< size
))
1414 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
1417 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
1418 nb_sectors
* BDRV_SECTOR_SIZE
);
1421 typedef struct RwCo
{
1422 BlockDriverState
*bs
;
1430 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
1432 RwCo
*rwco
= opaque
;
1434 if (!rwco
->is_write
) {
1435 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
1436 rwco
->nb_sectors
, rwco
->qiov
, 0);
1438 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
1439 rwco
->nb_sectors
, rwco
->qiov
, 0);
1444 * Process a synchronous request using coroutines
1446 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
1447 int nb_sectors
, bool is_write
)
1450 struct iovec iov
= {
1451 .iov_base
= (void *)buf
,
1452 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
1457 .sector_num
= sector_num
,
1458 .nb_sectors
= nb_sectors
,
1460 .is_write
= is_write
,
1464 qemu_iovec_init_external(&qiov
, &iov
, 1);
1467 * In sync call context, when the vcpu is blocked, this throttling timer
1468 * will not fire; so the I/O throttling function has to be disabled here
1469 * if it has been enabled.
1471 if (bs
->io_limits_enabled
) {
1472 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
1473 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
1474 bdrv_io_limits_disable(bs
);
1477 if (qemu_in_coroutine()) {
1478 /* Fast-path if already in coroutine context */
1479 bdrv_rw_co_entry(&rwco
);
1481 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
1482 qemu_coroutine_enter(co
, &rwco
);
1483 while (rwco
.ret
== NOT_DONE
) {
1490 /* return < 0 if error. See bdrv_write() for the return codes */
1491 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
1492 uint8_t *buf
, int nb_sectors
)
1494 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false);
1497 static void set_dirty_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
1498 int nb_sectors
, int dirty
)
1501 unsigned long val
, idx
, bit
;
1503 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
1504 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
1506 for (; start
<= end
; start
++) {
1507 idx
= start
/ (sizeof(unsigned long) * 8);
1508 bit
= start
% (sizeof(unsigned long) * 8);
1509 val
= bs
->dirty_bitmap
[idx
];
1511 if (!(val
& (1UL << bit
))) {
1516 if (val
& (1UL << bit
)) {
1518 val
&= ~(1UL << bit
);
1521 bs
->dirty_bitmap
[idx
] = val
;
1525 /* Return < 0 if error. Important errors are:
1526 -EIO generic I/O error (may happen for all errors)
1527 -ENOMEDIUM No media inserted.
1528 -EINVAL Invalid sector number or nb_sectors
1529 -EACCES Trying to write a read-only device
1531 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
1532 const uint8_t *buf
, int nb_sectors
)
1534 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true);
1537 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
1538 void *buf
, int count1
)
1540 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1541 int len
, nb_sectors
, count
;
1546 /* first read to align to sector start */
1547 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1550 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1552 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1554 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
1562 /* read the sectors "in place" */
1563 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1564 if (nb_sectors
> 0) {
1565 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1567 sector_num
+= nb_sectors
;
1568 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1573 /* add data from the last sector */
1575 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1577 memcpy(buf
, tmp_buf
, count
);
1582 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
1583 const void *buf
, int count1
)
1585 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
1586 int len
, nb_sectors
, count
;
1591 /* first write to align to sector start */
1592 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
1595 sector_num
= offset
>> BDRV_SECTOR_BITS
;
1597 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1599 memcpy(tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), buf
, len
);
1600 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1609 /* write the sectors "in place" */
1610 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
1611 if (nb_sectors
> 0) {
1612 if ((ret
= bdrv_write(bs
, sector_num
, buf
, nb_sectors
)) < 0)
1614 sector_num
+= nb_sectors
;
1615 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
1620 /* add data from the last sector */
1622 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
1624 memcpy(tmp_buf
, buf
, count
);
1625 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
1632 * Writes to the file and ensures that no writes are reordered across this
1633 * request (acts as a barrier)
1635 * Returns 0 on success, -errno in error cases.
1637 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
1638 const void *buf
, int count
)
1642 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
1647 /* No flush needed for cache modes that use O_DSYNC */
1648 if ((bs
->open_flags
& BDRV_O_CACHE_WB
) != 0) {
1655 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
1656 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1658 /* Perform I/O through a temporary buffer so that users who scribble over
1659 * their read buffer while the operation is in progress do not end up
1660 * modifying the image file. This is critical for zero-copy guest I/O
1661 * where anything might happen inside guest memory.
1663 void *bounce_buffer
;
1665 BlockDriver
*drv
= bs
->drv
;
1667 QEMUIOVector bounce_qiov
;
1668 int64_t cluster_sector_num
;
1669 int cluster_nb_sectors
;
1673 /* Cover entire cluster so no additional backing file I/O is required when
1674 * allocating cluster in the image file.
1676 round_to_clusters(bs
, sector_num
, nb_sectors
,
1677 &cluster_sector_num
, &cluster_nb_sectors
);
1679 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
1680 cluster_sector_num
, cluster_nb_sectors
);
1682 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
1683 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
1684 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
1686 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
1692 if (drv
->bdrv_co_write_zeroes
&&
1693 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
1694 ret
= drv
->bdrv_co_write_zeroes(bs
, cluster_sector_num
,
1695 cluster_nb_sectors
);
1697 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
1702 /* It might be okay to ignore write errors for guest requests. If this
1703 * is a deliberate copy-on-read then we don't want to ignore the error.
1704 * Simply report it in all cases.
1709 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
1710 qemu_iovec_from_buffer(qiov
, bounce_buffer
+ skip_bytes
,
1711 nb_sectors
* BDRV_SECTOR_SIZE
);
1714 qemu_vfree(bounce_buffer
);
1719 * Handle a read request in coroutine context
1721 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
1722 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1723 BdrvRequestFlags flags
)
1725 BlockDriver
*drv
= bs
->drv
;
1726 BdrvTrackedRequest req
;
1732 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1736 /* throttling disk read I/O */
1737 if (bs
->io_limits_enabled
) {
1738 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
1741 if (bs
->copy_on_read
) {
1742 flags
|= BDRV_REQ_COPY_ON_READ
;
1744 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1745 bs
->copy_on_read_in_flight
++;
1748 if (bs
->copy_on_read_in_flight
) {
1749 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1752 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
1754 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1757 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
1762 if (!ret
|| pnum
!= nb_sectors
) {
1763 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
1768 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
1771 tracked_request_end(&req
);
1773 if (flags
& BDRV_REQ_COPY_ON_READ
) {
1774 bs
->copy_on_read_in_flight
--;
1780 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
1781 int nb_sectors
, QEMUIOVector
*qiov
)
1783 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
1785 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
1788 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
1789 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
1791 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
1793 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
1794 BDRV_REQ_COPY_ON_READ
);
1797 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
1798 int64_t sector_num
, int nb_sectors
)
1800 BlockDriver
*drv
= bs
->drv
;
1805 /* First try the efficient write zeroes operation */
1806 if (drv
->bdrv_co_write_zeroes
) {
1807 return drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1810 /* Fall back to bounce buffer if write zeroes is unsupported */
1811 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
1812 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
1813 memset(iov
.iov_base
, 0, iov
.iov_len
);
1814 qemu_iovec_init_external(&qiov
, &iov
, 1);
1816 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
1818 qemu_vfree(iov
.iov_base
);
1823 * Handle a write request in coroutine context
1825 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
1826 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
1827 BdrvRequestFlags flags
)
1829 BlockDriver
*drv
= bs
->drv
;
1830 BdrvTrackedRequest req
;
1836 if (bs
->read_only
) {
1839 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
1843 /* throttling disk write I/O */
1844 if (bs
->io_limits_enabled
) {
1845 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
1848 if (bs
->copy_on_read_in_flight
) {
1849 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
1852 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
1854 if (flags
& BDRV_REQ_ZERO_WRITE
) {
1855 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
1857 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
1860 if (bs
->dirty_bitmap
) {
1861 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
1864 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
1865 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
1868 tracked_request_end(&req
);
1873 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
1874 int nb_sectors
, QEMUIOVector
*qiov
)
1876 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
1878 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
1881 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
1882 int64_t sector_num
, int nb_sectors
)
1884 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
1886 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
1887 BDRV_REQ_ZERO_WRITE
);
1891 * Truncate file to 'offset' bytes (needed only for file protocols)
1893 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
1895 BlockDriver
*drv
= bs
->drv
;
1899 if (!drv
->bdrv_truncate
)
1903 if (bdrv_in_use(bs
))
1905 ret
= drv
->bdrv_truncate(bs
, offset
);
1907 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
1908 bdrv_dev_resize_cb(bs
);
1914 * Length of a allocated file in bytes. Sparse files are counted by actual
1915 * allocated space. Return < 0 if error or unknown.
1917 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
1919 BlockDriver
*drv
= bs
->drv
;
1923 if (drv
->bdrv_get_allocated_file_size
) {
1924 return drv
->bdrv_get_allocated_file_size(bs
);
1927 return bdrv_get_allocated_file_size(bs
->file
);
1933 * Length of a file in bytes. Return < 0 if error or unknown.
1935 int64_t bdrv_getlength(BlockDriverState
*bs
)
1937 BlockDriver
*drv
= bs
->drv
;
1941 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
1942 if (drv
->bdrv_getlength
) {
1943 return drv
->bdrv_getlength(bs
);
1946 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
1949 /* return 0 as number of sectors if no device present or error */
1950 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
1953 length
= bdrv_getlength(bs
);
1957 length
= length
>> BDRV_SECTOR_BITS
;
1958 *nb_sectors_ptr
= length
;
1962 uint8_t boot_ind
; /* 0x80 - active */
1963 uint8_t head
; /* starting head */
1964 uint8_t sector
; /* starting sector */
1965 uint8_t cyl
; /* starting cylinder */
1966 uint8_t sys_ind
; /* What partition type */
1967 uint8_t end_head
; /* end head */
1968 uint8_t end_sector
; /* end sector */
1969 uint8_t end_cyl
; /* end cylinder */
1970 uint32_t start_sect
; /* starting sector counting from 0 */
1971 uint32_t nr_sects
; /* nr of sectors in partition */
1974 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
1975 static int guess_disk_lchs(BlockDriverState
*bs
,
1976 int *pcylinders
, int *pheads
, int *psectors
)
1978 uint8_t buf
[BDRV_SECTOR_SIZE
];
1979 int ret
, i
, heads
, sectors
, cylinders
;
1980 struct partition
*p
;
1982 uint64_t nb_sectors
;
1985 bdrv_get_geometry(bs
, &nb_sectors
);
1988 * The function will be invoked during startup not only in sync I/O mode,
1989 * but also in async I/O mode. So the I/O throttling function has to
1990 * be disabled temporarily here, not permanently.
1992 enabled
= bs
->io_limits_enabled
;
1993 bs
->io_limits_enabled
= false;
1994 ret
= bdrv_read(bs
, 0, buf
, 1);
1995 bs
->io_limits_enabled
= enabled
;
1998 /* test msdos magic */
1999 if (buf
[510] != 0x55 || buf
[511] != 0xaa)
2001 for(i
= 0; i
< 4; i
++) {
2002 p
= ((struct partition
*)(buf
+ 0x1be)) + i
;
2003 nr_sects
= le32_to_cpu(p
->nr_sects
);
2004 if (nr_sects
&& p
->end_head
) {
2005 /* We make the assumption that the partition terminates on
2006 a cylinder boundary */
2007 heads
= p
->end_head
+ 1;
2008 sectors
= p
->end_sector
& 63;
2011 cylinders
= nb_sectors
/ (heads
* sectors
);
2012 if (cylinders
< 1 || cylinders
> 16383)
2015 *psectors
= sectors
;
2016 *pcylinders
= cylinders
;
2018 printf("guessed geometry: LCHS=%d %d %d\n",
2019 cylinders
, heads
, sectors
);
2027 void bdrv_guess_geometry(BlockDriverState
*bs
, int *pcyls
, int *pheads
, int *psecs
)
2029 int translation
, lba_detected
= 0;
2030 int cylinders
, heads
, secs
;
2031 uint64_t nb_sectors
;
2033 /* if a geometry hint is available, use it */
2034 bdrv_get_geometry(bs
, &nb_sectors
);
2035 bdrv_get_geometry_hint(bs
, &cylinders
, &heads
, &secs
);
2036 translation
= bdrv_get_translation_hint(bs
);
2037 if (cylinders
!= 0) {
2042 if (guess_disk_lchs(bs
, &cylinders
, &heads
, &secs
) == 0) {
2044 /* if heads > 16, it means that a BIOS LBA
2045 translation was active, so the default
2046 hardware geometry is OK */
2048 goto default_geometry
;
2053 /* disable any translation to be in sync with
2054 the logical geometry */
2055 if (translation
== BIOS_ATA_TRANSLATION_AUTO
) {
2056 bdrv_set_translation_hint(bs
,
2057 BIOS_ATA_TRANSLATION_NONE
);
2062 /* if no geometry, use a standard physical disk geometry */
2063 cylinders
= nb_sectors
/ (16 * 63);
2065 if (cylinders
> 16383)
2067 else if (cylinders
< 2)
2072 if ((lba_detected
== 1) && (translation
== BIOS_ATA_TRANSLATION_AUTO
)) {
2073 if ((*pcyls
* *pheads
) <= 131072) {
2074 bdrv_set_translation_hint(bs
,
2075 BIOS_ATA_TRANSLATION_LARGE
);
2077 bdrv_set_translation_hint(bs
,
2078 BIOS_ATA_TRANSLATION_LBA
);
2082 bdrv_set_geometry_hint(bs
, *pcyls
, *pheads
, *psecs
);
2086 void bdrv_set_geometry_hint(BlockDriverState
*bs
,
2087 int cyls
, int heads
, int secs
)
2094 void bdrv_set_translation_hint(BlockDriverState
*bs
, int translation
)
2096 bs
->translation
= translation
;
2099 void bdrv_get_geometry_hint(BlockDriverState
*bs
,
2100 int *pcyls
, int *pheads
, int *psecs
)
2103 *pheads
= bs
->heads
;
2107 /* throttling disk io limits */
2108 void bdrv_set_io_limits(BlockDriverState
*bs
,
2109 BlockIOLimit
*io_limits
)
2111 bs
->io_limits
= *io_limits
;
2112 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2115 /* Recognize floppy formats */
2116 typedef struct FDFormat
{
2124 static const FDFormat fd_formats
[] = {
2125 /* First entry is default format */
2126 /* 1.44 MB 3"1/2 floppy disks */
2127 { FDRIVE_DRV_144
, 18, 80, 1, FDRIVE_RATE_500K
, },
2128 { FDRIVE_DRV_144
, 20, 80, 1, FDRIVE_RATE_500K
, },
2129 { FDRIVE_DRV_144
, 21, 80, 1, FDRIVE_RATE_500K
, },
2130 { FDRIVE_DRV_144
, 21, 82, 1, FDRIVE_RATE_500K
, },
2131 { FDRIVE_DRV_144
, 21, 83, 1, FDRIVE_RATE_500K
, },
2132 { FDRIVE_DRV_144
, 22, 80, 1, FDRIVE_RATE_500K
, },
2133 { FDRIVE_DRV_144
, 23, 80, 1, FDRIVE_RATE_500K
, },
2134 { FDRIVE_DRV_144
, 24, 80, 1, FDRIVE_RATE_500K
, },
2135 /* 2.88 MB 3"1/2 floppy disks */
2136 { FDRIVE_DRV_288
, 36, 80, 1, FDRIVE_RATE_1M
, },
2137 { FDRIVE_DRV_288
, 39, 80, 1, FDRIVE_RATE_1M
, },
2138 { FDRIVE_DRV_288
, 40, 80, 1, FDRIVE_RATE_1M
, },
2139 { FDRIVE_DRV_288
, 44, 80, 1, FDRIVE_RATE_1M
, },
2140 { FDRIVE_DRV_288
, 48, 80, 1, FDRIVE_RATE_1M
, },
2141 /* 720 kB 3"1/2 floppy disks */
2142 { FDRIVE_DRV_144
, 9, 80, 1, FDRIVE_RATE_250K
, },
2143 { FDRIVE_DRV_144
, 10, 80, 1, FDRIVE_RATE_250K
, },
2144 { FDRIVE_DRV_144
, 10, 82, 1, FDRIVE_RATE_250K
, },
2145 { FDRIVE_DRV_144
, 10, 83, 1, FDRIVE_RATE_250K
, },
2146 { FDRIVE_DRV_144
, 13, 80, 1, FDRIVE_RATE_250K
, },
2147 { FDRIVE_DRV_144
, 14, 80, 1, FDRIVE_RATE_250K
, },
2148 /* 1.2 MB 5"1/4 floppy disks */
2149 { FDRIVE_DRV_120
, 15, 80, 1, FDRIVE_RATE_500K
, },
2150 { FDRIVE_DRV_120
, 18, 80, 1, FDRIVE_RATE_500K
, },
2151 { FDRIVE_DRV_120
, 18, 82, 1, FDRIVE_RATE_500K
, },
2152 { FDRIVE_DRV_120
, 18, 83, 1, FDRIVE_RATE_500K
, },
2153 { FDRIVE_DRV_120
, 20, 80, 1, FDRIVE_RATE_500K
, },
2154 /* 720 kB 5"1/4 floppy disks */
2155 { FDRIVE_DRV_120
, 9, 80, 1, FDRIVE_RATE_250K
, },
2156 { FDRIVE_DRV_120
, 11, 80, 1, FDRIVE_RATE_250K
, },
2157 /* 360 kB 5"1/4 floppy disks */
2158 { FDRIVE_DRV_120
, 9, 40, 1, FDRIVE_RATE_300K
, },
2159 { FDRIVE_DRV_120
, 9, 40, 0, FDRIVE_RATE_300K
, },
2160 { FDRIVE_DRV_120
, 10, 41, 1, FDRIVE_RATE_300K
, },
2161 { FDRIVE_DRV_120
, 10, 42, 1, FDRIVE_RATE_300K
, },
2162 /* 320 kB 5"1/4 floppy disks */
2163 { FDRIVE_DRV_120
, 8, 40, 1, FDRIVE_RATE_250K
, },
2164 { FDRIVE_DRV_120
, 8, 40, 0, FDRIVE_RATE_250K
, },
2165 /* 360 kB must match 5"1/4 better than 3"1/2... */
2166 { FDRIVE_DRV_144
, 9, 80, 0, FDRIVE_RATE_250K
, },
2168 { FDRIVE_DRV_NONE
, -1, -1, 0, 0, },
2171 void bdrv_get_floppy_geometry_hint(BlockDriverState
*bs
, int *nb_heads
,
2172 int *max_track
, int *last_sect
,
2173 FDriveType drive_in
, FDriveType
*drive
,
2176 const FDFormat
*parse
;
2177 uint64_t nb_sectors
, size
;
2178 int i
, first_match
, match
;
2180 bdrv_get_geometry_hint(bs
, nb_heads
, max_track
, last_sect
);
2181 if (*nb_heads
!= 0 && *max_track
!= 0 && *last_sect
!= 0) {
2182 /* User defined disk */
2183 *rate
= FDRIVE_RATE_500K
;
2185 bdrv_get_geometry(bs
, &nb_sectors
);
2188 for (i
= 0; ; i
++) {
2189 parse
= &fd_formats
[i
];
2190 if (parse
->drive
== FDRIVE_DRV_NONE
) {
2193 if (drive_in
== parse
->drive
||
2194 drive_in
== FDRIVE_DRV_NONE
) {
2195 size
= (parse
->max_head
+ 1) * parse
->max_track
*
2197 if (nb_sectors
== size
) {
2201 if (first_match
== -1) {
2207 if (first_match
== -1) {
2210 match
= first_match
;
2212 parse
= &fd_formats
[match
];
2214 *nb_heads
= parse
->max_head
+ 1;
2215 *max_track
= parse
->max_track
;
2216 *last_sect
= parse
->last_sect
;
2217 *drive
= parse
->drive
;
2218 *rate
= parse
->rate
;
2222 int bdrv_get_translation_hint(BlockDriverState
*bs
)
2224 return bs
->translation
;
2227 void bdrv_set_on_error(BlockDriverState
*bs
, BlockErrorAction on_read_error
,
2228 BlockErrorAction on_write_error
)
2230 bs
->on_read_error
= on_read_error
;
2231 bs
->on_write_error
= on_write_error
;
2234 BlockErrorAction
bdrv_get_on_error(BlockDriverState
*bs
, int is_read
)
2236 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2239 int bdrv_is_read_only(BlockDriverState
*bs
)
2241 return bs
->read_only
;
2244 int bdrv_is_sg(BlockDriverState
*bs
)
2249 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2251 return bs
->enable_write_cache
;
2254 int bdrv_is_encrypted(BlockDriverState
*bs
)
2256 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2258 return bs
->encrypted
;
2261 int bdrv_key_required(BlockDriverState
*bs
)
2263 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2265 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2267 return (bs
->encrypted
&& !bs
->valid_key
);
2270 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2273 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2274 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2280 if (!bs
->encrypted
) {
2282 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2285 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2288 } else if (!bs
->valid_key
) {
2290 /* call the change callback now, we skipped it on open */
2291 bdrv_dev_change_media_cb(bs
, true);
2296 void bdrv_get_format(BlockDriverState
*bs
, char *buf
, int buf_size
)
2301 pstrcpy(buf
, buf_size
, bs
->drv
->format_name
);
2305 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2310 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2311 it(opaque
, drv
->format_name
);
2315 BlockDriverState
*bdrv_find(const char *name
)
2317 BlockDriverState
*bs
;
2319 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2320 if (!strcmp(name
, bs
->device_name
)) {
2327 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2330 return QTAILQ_FIRST(&bdrv_states
);
2332 return QTAILQ_NEXT(bs
, list
);
2335 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2337 BlockDriverState
*bs
;
2339 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2344 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2346 return bs
->device_name
;
2349 void bdrv_flush_all(void)
2351 BlockDriverState
*bs
;
2353 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2358 int bdrv_has_zero_init(BlockDriverState
*bs
)
2362 if (bs
->drv
->bdrv_has_zero_init
) {
2363 return bs
->drv
->bdrv_has_zero_init(bs
);
2369 typedef struct BdrvCoIsAllocatedData
{
2370 BlockDriverState
*bs
;
2376 } BdrvCoIsAllocatedData
;
2379 * Returns true iff the specified sector is present in the disk image. Drivers
2380 * not implementing the functionality are assumed to not support backing files,
2381 * hence all their sectors are reported as allocated.
2383 * If 'sector_num' is beyond the end of the disk image the return value is 0
2384 * and 'pnum' is set to 0.
2386 * 'pnum' is set to the number of sectors (including and immediately following
2387 * the specified sector) that are known to be in the same
2388 * allocated/unallocated state.
2390 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2391 * beyond the end of the disk image it will be clamped.
2393 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
2394 int nb_sectors
, int *pnum
)
2398 if (sector_num
>= bs
->total_sectors
) {
2403 n
= bs
->total_sectors
- sector_num
;
2404 if (n
< nb_sectors
) {
2408 if (!bs
->drv
->bdrv_co_is_allocated
) {
2413 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
2416 /* Coroutine wrapper for bdrv_is_allocated() */
2417 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
2419 BdrvCoIsAllocatedData
*data
= opaque
;
2420 BlockDriverState
*bs
= data
->bs
;
2422 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
2428 * Synchronous wrapper around bdrv_co_is_allocated().
2430 * See bdrv_co_is_allocated() for details.
2432 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
2436 BdrvCoIsAllocatedData data
= {
2438 .sector_num
= sector_num
,
2439 .nb_sectors
= nb_sectors
,
2444 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
2445 qemu_coroutine_enter(co
, &data
);
2446 while (!data
.done
) {
2452 BlockInfoList
*qmp_query_block(Error
**errp
)
2454 BlockInfoList
*head
= NULL
, *cur_item
= NULL
;
2455 BlockDriverState
*bs
;
2457 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2458 BlockInfoList
*info
= g_malloc0(sizeof(*info
));
2460 info
->value
= g_malloc0(sizeof(*info
->value
));
2461 info
->value
->device
= g_strdup(bs
->device_name
);
2462 info
->value
->type
= g_strdup("unknown");
2463 info
->value
->locked
= bdrv_dev_is_medium_locked(bs
);
2464 info
->value
->removable
= bdrv_dev_has_removable_media(bs
);
2466 if (bdrv_dev_has_removable_media(bs
)) {
2467 info
->value
->has_tray_open
= true;
2468 info
->value
->tray_open
= bdrv_dev_is_tray_open(bs
);
2471 if (bdrv_iostatus_is_enabled(bs
)) {
2472 info
->value
->has_io_status
= true;
2473 info
->value
->io_status
= bs
->iostatus
;
2477 info
->value
->has_inserted
= true;
2478 info
->value
->inserted
= g_malloc0(sizeof(*info
->value
->inserted
));
2479 info
->value
->inserted
->file
= g_strdup(bs
->filename
);
2480 info
->value
->inserted
->ro
= bs
->read_only
;
2481 info
->value
->inserted
->drv
= g_strdup(bs
->drv
->format_name
);
2482 info
->value
->inserted
->encrypted
= bs
->encrypted
;
2483 if (bs
->backing_file
[0]) {
2484 info
->value
->inserted
->has_backing_file
= true;
2485 info
->value
->inserted
->backing_file
= g_strdup(bs
->backing_file
);
2488 if (bs
->io_limits_enabled
) {
2489 info
->value
->inserted
->bps
=
2490 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
2491 info
->value
->inserted
->bps_rd
=
2492 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_READ
];
2493 info
->value
->inserted
->bps_wr
=
2494 bs
->io_limits
.bps
[BLOCK_IO_LIMIT_WRITE
];
2495 info
->value
->inserted
->iops
=
2496 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
2497 info
->value
->inserted
->iops_rd
=
2498 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_READ
];
2499 info
->value
->inserted
->iops_wr
=
2500 bs
->io_limits
.iops
[BLOCK_IO_LIMIT_WRITE
];
2504 /* XXX: waiting for the qapi to support GSList */
2506 head
= cur_item
= info
;
2508 cur_item
->next
= info
;
2516 /* Consider exposing this as a full fledged QMP command */
2517 static BlockStats
*qmp_query_blockstat(const BlockDriverState
*bs
, Error
**errp
)
2521 s
= g_malloc0(sizeof(*s
));
2523 if (bs
->device_name
[0]) {
2524 s
->has_device
= true;
2525 s
->device
= g_strdup(bs
->device_name
);
2528 s
->stats
= g_malloc0(sizeof(*s
->stats
));
2529 s
->stats
->rd_bytes
= bs
->nr_bytes
[BDRV_ACCT_READ
];
2530 s
->stats
->wr_bytes
= bs
->nr_bytes
[BDRV_ACCT_WRITE
];
2531 s
->stats
->rd_operations
= bs
->nr_ops
[BDRV_ACCT_READ
];
2532 s
->stats
->wr_operations
= bs
->nr_ops
[BDRV_ACCT_WRITE
];
2533 s
->stats
->wr_highest_offset
= bs
->wr_highest_sector
* BDRV_SECTOR_SIZE
;
2534 s
->stats
->flush_operations
= bs
->nr_ops
[BDRV_ACCT_FLUSH
];
2535 s
->stats
->wr_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_WRITE
];
2536 s
->stats
->rd_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_READ
];
2537 s
->stats
->flush_total_time_ns
= bs
->total_time_ns
[BDRV_ACCT_FLUSH
];
2540 s
->has_parent
= true;
2541 s
->parent
= qmp_query_blockstat(bs
->file
, NULL
);
2547 BlockStatsList
*qmp_query_blockstats(Error
**errp
)
2549 BlockStatsList
*head
= NULL
, *cur_item
= NULL
;
2550 BlockDriverState
*bs
;
2552 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2553 BlockStatsList
*info
= g_malloc0(sizeof(*info
));
2554 info
->value
= qmp_query_blockstat(bs
, NULL
);
2556 /* XXX: waiting for the qapi to support GSList */
2558 head
= cur_item
= info
;
2560 cur_item
->next
= info
;
2568 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
2570 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2571 return bs
->backing_file
;
2572 else if (bs
->encrypted
)
2573 return bs
->filename
;
2578 void bdrv_get_backing_filename(BlockDriverState
*bs
,
2579 char *filename
, int filename_size
)
2581 pstrcpy(filename
, filename_size
, bs
->backing_file
);
2584 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
2585 const uint8_t *buf
, int nb_sectors
)
2587 BlockDriver
*drv
= bs
->drv
;
2590 if (!drv
->bdrv_write_compressed
)
2592 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
2595 if (bs
->dirty_bitmap
) {
2596 set_dirty_bitmap(bs
, sector_num
, nb_sectors
, 1);
2599 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
2602 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
2604 BlockDriver
*drv
= bs
->drv
;
2607 if (!drv
->bdrv_get_info
)
2609 memset(bdi
, 0, sizeof(*bdi
));
2610 return drv
->bdrv_get_info(bs
, bdi
);
2613 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
2614 int64_t pos
, int size
)
2616 BlockDriver
*drv
= bs
->drv
;
2619 if (drv
->bdrv_save_vmstate
)
2620 return drv
->bdrv_save_vmstate(bs
, buf
, pos
, size
);
2622 return bdrv_save_vmstate(bs
->file
, buf
, pos
, size
);
2626 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
2627 int64_t pos
, int size
)
2629 BlockDriver
*drv
= bs
->drv
;
2632 if (drv
->bdrv_load_vmstate
)
2633 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
2635 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
2639 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
2641 BlockDriver
*drv
= bs
->drv
;
2643 if (!drv
|| !drv
->bdrv_debug_event
) {
2647 return drv
->bdrv_debug_event(bs
, event
);
2651 /**************************************************************/
2652 /* handling of snapshots */
2654 int bdrv_can_snapshot(BlockDriverState
*bs
)
2656 BlockDriver
*drv
= bs
->drv
;
2657 if (!drv
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
2661 if (!drv
->bdrv_snapshot_create
) {
2662 if (bs
->file
!= NULL
) {
2663 return bdrv_can_snapshot(bs
->file
);
2671 int bdrv_is_snapshot(BlockDriverState
*bs
)
2673 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
2676 BlockDriverState
*bdrv_snapshots(void)
2678 BlockDriverState
*bs
;
2681 return bs_snapshots
;
2685 while ((bs
= bdrv_next(bs
))) {
2686 if (bdrv_can_snapshot(bs
)) {
2694 int bdrv_snapshot_create(BlockDriverState
*bs
,
2695 QEMUSnapshotInfo
*sn_info
)
2697 BlockDriver
*drv
= bs
->drv
;
2700 if (drv
->bdrv_snapshot_create
)
2701 return drv
->bdrv_snapshot_create(bs
, sn_info
);
2703 return bdrv_snapshot_create(bs
->file
, sn_info
);
2707 int bdrv_snapshot_goto(BlockDriverState
*bs
,
2708 const char *snapshot_id
)
2710 BlockDriver
*drv
= bs
->drv
;
2715 if (drv
->bdrv_snapshot_goto
)
2716 return drv
->bdrv_snapshot_goto(bs
, snapshot_id
);
2719 drv
->bdrv_close(bs
);
2720 ret
= bdrv_snapshot_goto(bs
->file
, snapshot_id
);
2721 open_ret
= drv
->bdrv_open(bs
, bs
->open_flags
);
2723 bdrv_delete(bs
->file
);
2733 int bdrv_snapshot_delete(BlockDriverState
*bs
, const char *snapshot_id
)
2735 BlockDriver
*drv
= bs
->drv
;
2738 if (drv
->bdrv_snapshot_delete
)
2739 return drv
->bdrv_snapshot_delete(bs
, snapshot_id
);
2741 return bdrv_snapshot_delete(bs
->file
, snapshot_id
);
2745 int bdrv_snapshot_list(BlockDriverState
*bs
,
2746 QEMUSnapshotInfo
**psn_info
)
2748 BlockDriver
*drv
= bs
->drv
;
2751 if (drv
->bdrv_snapshot_list
)
2752 return drv
->bdrv_snapshot_list(bs
, psn_info
);
2754 return bdrv_snapshot_list(bs
->file
, psn_info
);
2758 int bdrv_snapshot_load_tmp(BlockDriverState
*bs
,
2759 const char *snapshot_name
)
2761 BlockDriver
*drv
= bs
->drv
;
2765 if (!bs
->read_only
) {
2768 if (drv
->bdrv_snapshot_load_tmp
) {
2769 return drv
->bdrv_snapshot_load_tmp(bs
, snapshot_name
);
2774 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
2775 const char *backing_file
)
2781 if (bs
->backing_hd
) {
2782 if (strcmp(bs
->backing_file
, backing_file
) == 0) {
2783 return bs
->backing_hd
;
2785 return bdrv_find_backing_image(bs
->backing_hd
, backing_file
);
2792 #define NB_SUFFIXES 4
2794 char *get_human_readable_size(char *buf
, int buf_size
, int64_t size
)
2796 static const char suffixes
[NB_SUFFIXES
] = "KMGT";
2801 snprintf(buf
, buf_size
, "%" PRId64
, size
);
2804 for(i
= 0; i
< NB_SUFFIXES
; i
++) {
2805 if (size
< (10 * base
)) {
2806 snprintf(buf
, buf_size
, "%0.1f%c",
2807 (double)size
/ base
,
2810 } else if (size
< (1000 * base
) || i
== (NB_SUFFIXES
- 1)) {
2811 snprintf(buf
, buf_size
, "%" PRId64
"%c",
2812 ((size
+ (base
>> 1)) / base
),
2822 char *bdrv_snapshot_dump(char *buf
, int buf_size
, QEMUSnapshotInfo
*sn
)
2824 char buf1
[128], date_buf
[128], clock_buf
[128];
2834 snprintf(buf
, buf_size
,
2835 "%-10s%-20s%7s%20s%15s",
2836 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
2840 ptm
= localtime(&ti
);
2841 strftime(date_buf
, sizeof(date_buf
),
2842 "%Y-%m-%d %H:%M:%S", ptm
);
2844 localtime_r(&ti
, &tm
);
2845 strftime(date_buf
, sizeof(date_buf
),
2846 "%Y-%m-%d %H:%M:%S", &tm
);
2848 secs
= sn
->vm_clock_nsec
/ 1000000000;
2849 snprintf(clock_buf
, sizeof(clock_buf
),
2850 "%02d:%02d:%02d.%03d",
2852 (int)((secs
/ 60) % 60),
2854 (int)((sn
->vm_clock_nsec
/ 1000000) % 1000));
2855 snprintf(buf
, buf_size
,
2856 "%-10s%-20s%7s%20s%15s",
2857 sn
->id_str
, sn
->name
,
2858 get_human_readable_size(buf1
, sizeof(buf1
), sn
->vm_state_size
),
2865 /**************************************************************/
2868 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
2869 QEMUIOVector
*qiov
, int nb_sectors
,
2870 BlockDriverCompletionFunc
*cb
, void *opaque
)
2872 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
2874 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2878 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
2879 QEMUIOVector
*qiov
, int nb_sectors
,
2880 BlockDriverCompletionFunc
*cb
, void *opaque
)
2882 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
2884 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
2889 typedef struct MultiwriteCB
{
2894 BlockDriverCompletionFunc
*cb
;
2896 QEMUIOVector
*free_qiov
;
2900 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
2904 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
2905 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
2906 if (mcb
->callbacks
[i
].free_qiov
) {
2907 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
2909 g_free(mcb
->callbacks
[i
].free_qiov
);
2913 static void multiwrite_cb(void *opaque
, int ret
)
2915 MultiwriteCB
*mcb
= opaque
;
2917 trace_multiwrite_cb(mcb
, ret
);
2919 if (ret
< 0 && !mcb
->error
) {
2923 mcb
->num_requests
--;
2924 if (mcb
->num_requests
== 0) {
2925 multiwrite_user_cb(mcb
);
2930 static int multiwrite_req_compare(const void *a
, const void *b
)
2932 const BlockRequest
*req1
= a
, *req2
= b
;
2935 * Note that we can't simply subtract req2->sector from req1->sector
2936 * here as that could overflow the return value.
2938 if (req1
->sector
> req2
->sector
) {
2940 } else if (req1
->sector
< req2
->sector
) {
2948 * Takes a bunch of requests and tries to merge them. Returns the number of
2949 * requests that remain after merging.
2951 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
2952 int num_reqs
, MultiwriteCB
*mcb
)
2956 // Sort requests by start sector
2957 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
2959 // Check if adjacent requests touch the same clusters. If so, combine them,
2960 // filling up gaps with zero sectors.
2962 for (i
= 1; i
< num_reqs
; i
++) {
2964 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
2966 // Handle exactly sequential writes and overlapping writes.
2967 if (reqs
[i
].sector
<= oldreq_last
) {
2971 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
2977 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
2978 qemu_iovec_init(qiov
,
2979 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
2981 // Add the first request to the merged one. If the requests are
2982 // overlapping, drop the last sectors of the first request.
2983 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
2984 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, size
);
2986 // We should need to add any zeros between the two requests
2987 assert (reqs
[i
].sector
<= oldreq_last
);
2989 // Add the second request
2990 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, reqs
[i
].qiov
->size
);
2992 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
2993 reqs
[outidx
].qiov
= qiov
;
2995 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
2998 reqs
[outidx
].sector
= reqs
[i
].sector
;
2999 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3000 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3008 * Submit multiple AIO write requests at once.
3010 * On success, the function returns 0 and all requests in the reqs array have
3011 * been submitted. In error case this function returns -1, and any of the
3012 * requests may or may not be submitted yet. In particular, this means that the
3013 * callback will be called for some of the requests, for others it won't. The
3014 * caller must check the error field of the BlockRequest to wait for the right
3015 * callbacks (if error != 0, no callback will be called).
3017 * The implementation may modify the contents of the reqs array, e.g. to merge
3018 * requests. However, the fields opaque and error are left unmodified as they
3019 * are used to signal failure for a single request to the caller.
3021 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3026 /* don't submit writes if we don't have a medium */
3027 if (bs
->drv
== NULL
) {
3028 for (i
= 0; i
< num_reqs
; i
++) {
3029 reqs
[i
].error
= -ENOMEDIUM
;
3034 if (num_reqs
== 0) {
3038 // Create MultiwriteCB structure
3039 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3040 mcb
->num_requests
= 0;
3041 mcb
->num_callbacks
= num_reqs
;
3043 for (i
= 0; i
< num_reqs
; i
++) {
3044 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3045 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3048 // Check for mergable requests
3049 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3051 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3053 /* Run the aio requests. */
3054 mcb
->num_requests
= num_reqs
;
3055 for (i
= 0; i
< num_reqs
; i
++) {
3056 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3057 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3063 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3065 acb
->pool
->cancel(acb
);
3068 /* block I/O throttling */
3069 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3070 bool is_write
, double elapsed_time
, uint64_t *wait
)
3072 uint64_t bps_limit
= 0;
3073 double bytes_limit
, bytes_base
, bytes_res
;
3074 double slice_time
, wait_time
;
3076 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3077 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3078 } else if (bs
->io_limits
.bps
[is_write
]) {
3079 bps_limit
= bs
->io_limits
.bps
[is_write
];
3088 slice_time
= bs
->slice_end
- bs
->slice_start
;
3089 slice_time
/= (NANOSECONDS_PER_SECOND
);
3090 bytes_limit
= bps_limit
* slice_time
;
3091 bytes_base
= bs
->nr_bytes
[is_write
] - bs
->io_base
.bytes
[is_write
];
3092 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3093 bytes_base
+= bs
->nr_bytes
[!is_write
] - bs
->io_base
.bytes
[!is_write
];
3096 /* bytes_base: the bytes of data which have been read/written; and
3097 * it is obtained from the history statistic info.
3098 * bytes_res: the remaining bytes of data which need to be read/written.
3099 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3100 * the total time for completing reading/writting all data.
3102 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3104 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3112 /* Calc approx time to dispatch */
3113 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3115 /* When the I/O rate at runtime exceeds the limits,
3116 * bs->slice_end need to be extended in order that the current statistic
3117 * info can be kept until the timer fire, so it is increased and tuned
3118 * based on the result of experiment.
3120 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3121 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3123 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3129 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3130 double elapsed_time
, uint64_t *wait
)
3132 uint64_t iops_limit
= 0;
3133 double ios_limit
, ios_base
;
3134 double slice_time
, wait_time
;
3136 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3137 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3138 } else if (bs
->io_limits
.iops
[is_write
]) {
3139 iops_limit
= bs
->io_limits
.iops
[is_write
];
3148 slice_time
= bs
->slice_end
- bs
->slice_start
;
3149 slice_time
/= (NANOSECONDS_PER_SECOND
);
3150 ios_limit
= iops_limit
* slice_time
;
3151 ios_base
= bs
->nr_ops
[is_write
] - bs
->io_base
.ios
[is_write
];
3152 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3153 ios_base
+= bs
->nr_ops
[!is_write
] - bs
->io_base
.ios
[!is_write
];
3156 if (ios_base
+ 1 <= ios_limit
) {
3164 /* Calc approx time to dispatch */
3165 wait_time
= (ios_base
+ 1) / iops_limit
;
3166 if (wait_time
> elapsed_time
) {
3167 wait_time
= wait_time
- elapsed_time
;
3172 bs
->slice_time
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3173 bs
->slice_end
+= bs
->slice_time
- 3 * BLOCK_IO_SLICE_TIME
;
3175 *wait
= wait_time
* BLOCK_IO_SLICE_TIME
* 10;
3181 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3182 bool is_write
, int64_t *wait
)
3184 int64_t now
, max_wait
;
3185 uint64_t bps_wait
= 0, iops_wait
= 0;
3186 double elapsed_time
;
3187 int bps_ret
, iops_ret
;
3189 now
= qemu_get_clock_ns(vm_clock
);
3190 if ((bs
->slice_start
< now
)
3191 && (bs
->slice_end
> now
)) {
3192 bs
->slice_end
= now
+ bs
->slice_time
;
3194 bs
->slice_time
= 5 * BLOCK_IO_SLICE_TIME
;
3195 bs
->slice_start
= now
;
3196 bs
->slice_end
= now
+ bs
->slice_time
;
3198 bs
->io_base
.bytes
[is_write
] = bs
->nr_bytes
[is_write
];
3199 bs
->io_base
.bytes
[!is_write
] = bs
->nr_bytes
[!is_write
];
3201 bs
->io_base
.ios
[is_write
] = bs
->nr_ops
[is_write
];
3202 bs
->io_base
.ios
[!is_write
] = bs
->nr_ops
[!is_write
];
3205 elapsed_time
= now
- bs
->slice_start
;
3206 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3208 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3209 is_write
, elapsed_time
, &bps_wait
);
3210 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3211 elapsed_time
, &iops_wait
);
3212 if (bps_ret
|| iops_ret
) {
3213 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3218 now
= qemu_get_clock_ns(vm_clock
);
3219 if (bs
->slice_end
< now
+ max_wait
) {
3220 bs
->slice_end
= now
+ max_wait
;
3233 /**************************************************************/
3234 /* async block device emulation */
3236 typedef struct BlockDriverAIOCBSync
{
3237 BlockDriverAIOCB common
;
3240 /* vector translation state */
3244 } BlockDriverAIOCBSync
;
3246 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3248 BlockDriverAIOCBSync
*acb
=
3249 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3250 qemu_bh_delete(acb
->bh
);
3252 qemu_aio_release(acb
);
3255 static AIOPool bdrv_em_aio_pool
= {
3256 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3257 .cancel
= bdrv_aio_cancel_em
,
3260 static void bdrv_aio_bh_cb(void *opaque
)
3262 BlockDriverAIOCBSync
*acb
= opaque
;
3265 qemu_iovec_from_buffer(acb
->qiov
, acb
->bounce
, acb
->qiov
->size
);
3266 qemu_vfree(acb
->bounce
);
3267 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3268 qemu_bh_delete(acb
->bh
);
3270 qemu_aio_release(acb
);
3273 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3277 BlockDriverCompletionFunc
*cb
,
3282 BlockDriverAIOCBSync
*acb
;
3284 acb
= qemu_aio_get(&bdrv_em_aio_pool
, bs
, cb
, opaque
);
3285 acb
->is_write
= is_write
;
3287 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3288 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3291 qemu_iovec_to_buffer(acb
->qiov
, acb
->bounce
);
3292 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3294 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3297 qemu_bh_schedule(acb
->bh
);
3299 return &acb
->common
;
3302 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3303 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3304 BlockDriverCompletionFunc
*cb
, void *opaque
)
3306 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3309 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3310 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3311 BlockDriverCompletionFunc
*cb
, void *opaque
)
3313 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3317 typedef struct BlockDriverAIOCBCoroutine
{
3318 BlockDriverAIOCB common
;
3322 } BlockDriverAIOCBCoroutine
;
3324 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3329 static AIOPool bdrv_em_co_aio_pool
= {
3330 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3331 .cancel
= bdrv_aio_co_cancel_em
,
3334 static void bdrv_co_em_bh(void *opaque
)
3336 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3338 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3339 qemu_bh_delete(acb
->bh
);
3340 qemu_aio_release(acb
);
3343 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3344 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3346 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3347 BlockDriverState
*bs
= acb
->common
.bs
;
3349 if (!acb
->is_write
) {
3350 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3351 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3353 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3354 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3357 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3358 qemu_bh_schedule(acb
->bh
);
3361 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3365 BlockDriverCompletionFunc
*cb
,
3370 BlockDriverAIOCBCoroutine
*acb
;
3372 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3373 acb
->req
.sector
= sector_num
;
3374 acb
->req
.nb_sectors
= nb_sectors
;
3375 acb
->req
.qiov
= qiov
;
3376 acb
->is_write
= is_write
;
3378 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3379 qemu_coroutine_enter(co
, acb
);
3381 return &acb
->common
;
3384 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3386 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3387 BlockDriverState
*bs
= acb
->common
.bs
;
3389 acb
->req
.error
= bdrv_co_flush(bs
);
3390 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3391 qemu_bh_schedule(acb
->bh
);
3394 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3395 BlockDriverCompletionFunc
*cb
, void *opaque
)
3397 trace_bdrv_aio_flush(bs
, opaque
);
3400 BlockDriverAIOCBCoroutine
*acb
;
3402 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3403 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3404 qemu_coroutine_enter(co
, acb
);
3406 return &acb
->common
;
3409 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3411 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3412 BlockDriverState
*bs
= acb
->common
.bs
;
3414 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3415 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3416 qemu_bh_schedule(acb
->bh
);
3419 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3420 int64_t sector_num
, int nb_sectors
,
3421 BlockDriverCompletionFunc
*cb
, void *opaque
)
3424 BlockDriverAIOCBCoroutine
*acb
;
3426 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3428 acb
= qemu_aio_get(&bdrv_em_co_aio_pool
, bs
, cb
, opaque
);
3429 acb
->req
.sector
= sector_num
;
3430 acb
->req
.nb_sectors
= nb_sectors
;
3431 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3432 qemu_coroutine_enter(co
, acb
);
3434 return &acb
->common
;
3437 void bdrv_init(void)
3439 module_call_init(MODULE_INIT_BLOCK
);
3442 void bdrv_init_with_whitelist(void)
3444 use_bdrv_whitelist
= 1;
3448 void *qemu_aio_get(AIOPool
*pool
, BlockDriverState
*bs
,
3449 BlockDriverCompletionFunc
*cb
, void *opaque
)
3451 BlockDriverAIOCB
*acb
;
3453 if (pool
->free_aiocb
) {
3454 acb
= pool
->free_aiocb
;
3455 pool
->free_aiocb
= acb
->next
;
3457 acb
= g_malloc0(pool
->aiocb_size
);
3462 acb
->opaque
= opaque
;
3466 void qemu_aio_release(void *p
)
3468 BlockDriverAIOCB
*acb
= (BlockDriverAIOCB
*)p
;
3469 AIOPool
*pool
= acb
->pool
;
3470 acb
->next
= pool
->free_aiocb
;
3471 pool
->free_aiocb
= acb
;
3474 /**************************************************************/
3475 /* Coroutine block device emulation */
3477 typedef struct CoroutineIOCompletion
{
3478 Coroutine
*coroutine
;
3480 } CoroutineIOCompletion
;
3482 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
3484 CoroutineIOCompletion
*co
= opaque
;
3487 qemu_coroutine_enter(co
->coroutine
, NULL
);
3490 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
3491 int nb_sectors
, QEMUIOVector
*iov
,
3494 CoroutineIOCompletion co
= {
3495 .coroutine
= qemu_coroutine_self(),
3497 BlockDriverAIOCB
*acb
;
3500 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
3501 bdrv_co_io_em_complete
, &co
);
3503 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
3504 bdrv_co_io_em_complete
, &co
);
3507 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
3511 qemu_coroutine_yield();
3516 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
3517 int64_t sector_num
, int nb_sectors
,
3520 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
3523 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
3524 int64_t sector_num
, int nb_sectors
,
3527 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
3530 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
3532 RwCo
*rwco
= opaque
;
3534 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
3537 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
3541 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
3545 /* Write back cached data to the OS even with cache=unsafe */
3546 if (bs
->drv
->bdrv_co_flush_to_os
) {
3547 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
3553 /* But don't actually force it to the disk with cache=unsafe */
3554 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
3558 if (bs
->drv
->bdrv_co_flush_to_disk
) {
3559 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
3560 } else if (bs
->drv
->bdrv_aio_flush
) {
3561 BlockDriverAIOCB
*acb
;
3562 CoroutineIOCompletion co
= {
3563 .coroutine
= qemu_coroutine_self(),
3566 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
3570 qemu_coroutine_yield();
3575 * Some block drivers always operate in either writethrough or unsafe
3576 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
3577 * know how the server works (because the behaviour is hardcoded or
3578 * depends on server-side configuration), so we can't ensure that
3579 * everything is safe on disk. Returning an error doesn't work because
3580 * that would break guests even if the server operates in writethrough
3583 * Let's hope the user knows what he's doing.
3591 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
3592 * in the case of cache=unsafe, so there are no useless flushes.
3594 return bdrv_co_flush(bs
->file
);
3597 void bdrv_invalidate_cache(BlockDriverState
*bs
)
3599 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
3600 bs
->drv
->bdrv_invalidate_cache(bs
);
3604 void bdrv_invalidate_cache_all(void)
3606 BlockDriverState
*bs
;
3608 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
3609 bdrv_invalidate_cache(bs
);
3613 int bdrv_flush(BlockDriverState
*bs
)
3621 if (qemu_in_coroutine()) {
3622 /* Fast-path if already in coroutine context */
3623 bdrv_flush_co_entry(&rwco
);
3625 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
3626 qemu_coroutine_enter(co
, &rwco
);
3627 while (rwco
.ret
== NOT_DONE
) {
3635 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
3637 RwCo
*rwco
= opaque
;
3639 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
3642 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
3647 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
3649 } else if (bs
->read_only
) {
3651 } else if (bs
->drv
->bdrv_co_discard
) {
3652 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
3653 } else if (bs
->drv
->bdrv_aio_discard
) {
3654 BlockDriverAIOCB
*acb
;
3655 CoroutineIOCompletion co
= {
3656 .coroutine
= qemu_coroutine_self(),
3659 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
3660 bdrv_co_io_em_complete
, &co
);
3664 qemu_coroutine_yield();
3672 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
3677 .sector_num
= sector_num
,
3678 .nb_sectors
= nb_sectors
,
3682 if (qemu_in_coroutine()) {
3683 /* Fast-path if already in coroutine context */
3684 bdrv_discard_co_entry(&rwco
);
3686 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
3687 qemu_coroutine_enter(co
, &rwco
);
3688 while (rwco
.ret
== NOT_DONE
) {
3696 /**************************************************************/
3697 /* removable device support */
3700 * Return TRUE if the media is present
3702 int bdrv_is_inserted(BlockDriverState
*bs
)
3704 BlockDriver
*drv
= bs
->drv
;
3708 if (!drv
->bdrv_is_inserted
)
3710 return drv
->bdrv_is_inserted(bs
);
3714 * Return whether the media changed since the last call to this
3715 * function, or -ENOTSUP if we don't know. Most drivers don't know.
3717 int bdrv_media_changed(BlockDriverState
*bs
)
3719 BlockDriver
*drv
= bs
->drv
;
3721 if (drv
&& drv
->bdrv_media_changed
) {
3722 return drv
->bdrv_media_changed(bs
);
3728 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
3730 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
3732 BlockDriver
*drv
= bs
->drv
;
3734 if (drv
&& drv
->bdrv_eject
) {
3735 drv
->bdrv_eject(bs
, eject_flag
);
3738 if (bs
->device_name
[0] != '\0') {
3739 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
3744 * Lock or unlock the media (if it is locked, the user won't be able
3745 * to eject it manually).
3747 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
3749 BlockDriver
*drv
= bs
->drv
;
3751 trace_bdrv_lock_medium(bs
, locked
);
3753 if (drv
&& drv
->bdrv_lock_medium
) {
3754 drv
->bdrv_lock_medium(bs
, locked
);
3758 /* needed for generic scsi interface */
3760 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
3762 BlockDriver
*drv
= bs
->drv
;
3764 if (drv
&& drv
->bdrv_ioctl
)
3765 return drv
->bdrv_ioctl(bs
, req
, buf
);
3769 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
3770 unsigned long int req
, void *buf
,
3771 BlockDriverCompletionFunc
*cb
, void *opaque
)
3773 BlockDriver
*drv
= bs
->drv
;
3775 if (drv
&& drv
->bdrv_aio_ioctl
)
3776 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
3780 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
3782 bs
->buffer_alignment
= align
;
3785 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
3787 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
3790 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int enable
)
3792 int64_t bitmap_size
;
3794 bs
->dirty_count
= 0;
3796 if (!bs
->dirty_bitmap
) {
3797 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
3798 BDRV_SECTORS_PER_DIRTY_CHUNK
* 8 - 1;
3799 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* 8;
3801 bs
->dirty_bitmap
= g_malloc0(bitmap_size
);
3804 if (bs
->dirty_bitmap
) {
3805 g_free(bs
->dirty_bitmap
);
3806 bs
->dirty_bitmap
= NULL
;
3811 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
3813 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
3815 if (bs
->dirty_bitmap
&&
3816 (sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bs
)) {
3817 return !!(bs
->dirty_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
3818 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
3824 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
3827 set_dirty_bitmap(bs
, cur_sector
, nr_sectors
, 0);
3830 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
3832 return bs
->dirty_count
;
3835 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
3837 assert(bs
->in_use
!= in_use
);
3838 bs
->in_use
= in_use
;
3841 int bdrv_in_use(BlockDriverState
*bs
)
3846 void bdrv_iostatus_enable(BlockDriverState
*bs
)
3848 bs
->iostatus_enabled
= true;
3849 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3852 /* The I/O status is only enabled if the drive explicitly
3853 * enables it _and_ the VM is configured to stop on errors */
3854 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
3856 return (bs
->iostatus_enabled
&&
3857 (bs
->on_write_error
== BLOCK_ERR_STOP_ENOSPC
||
3858 bs
->on_write_error
== BLOCK_ERR_STOP_ANY
||
3859 bs
->on_read_error
== BLOCK_ERR_STOP_ANY
));
3862 void bdrv_iostatus_disable(BlockDriverState
*bs
)
3864 bs
->iostatus_enabled
= false;
3867 void bdrv_iostatus_reset(BlockDriverState
*bs
)
3869 if (bdrv_iostatus_is_enabled(bs
)) {
3870 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
3874 /* XXX: Today this is set by device models because it makes the implementation
3875 quite simple. However, the block layer knows about the error, so it's
3876 possible to implement this without device models being involved */
3877 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
3879 if (bdrv_iostatus_is_enabled(bs
) &&
3880 bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
3882 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
3883 BLOCK_DEVICE_IO_STATUS_FAILED
;
3888 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
3889 enum BlockAcctType type
)
3891 assert(type
< BDRV_MAX_IOTYPE
);
3893 cookie
->bytes
= bytes
;
3894 cookie
->start_time_ns
= get_clock();
3895 cookie
->type
= type
;
3899 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
3901 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
3903 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
3904 bs
->nr_ops
[cookie
->type
]++;
3905 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
3908 int bdrv_img_create(const char *filename
, const char *fmt
,
3909 const char *base_filename
, const char *base_fmt
,
3910 char *options
, uint64_t img_size
, int flags
)
3912 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
3913 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
3914 BlockDriverState
*bs
= NULL
;
3915 BlockDriver
*drv
, *proto_drv
;
3916 BlockDriver
*backing_drv
= NULL
;
3919 /* Find driver and parse its options */
3920 drv
= bdrv_find_format(fmt
);
3922 error_report("Unknown file format '%s'", fmt
);
3927 proto_drv
= bdrv_find_protocol(filename
);
3929 error_report("Unknown protocol '%s'", filename
);
3934 create_options
= append_option_parameters(create_options
,
3935 drv
->create_options
);
3936 create_options
= append_option_parameters(create_options
,
3937 proto_drv
->create_options
);
3939 /* Create parameter list with default values */
3940 param
= parse_option_parameters("", create_options
, param
);
3942 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
3944 /* Parse -o options */
3946 param
= parse_option_parameters(options
, create_options
, param
);
3947 if (param
== NULL
) {
3948 error_report("Invalid options for file format '%s'.", fmt
);
3954 if (base_filename
) {
3955 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
3957 error_report("Backing file not supported for file format '%s'",
3965 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
3966 error_report("Backing file format not supported for file "
3967 "format '%s'", fmt
);
3973 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
3974 if (backing_file
&& backing_file
->value
.s
) {
3975 if (!strcmp(filename
, backing_file
->value
.s
)) {
3976 error_report("Error: Trying to create an image with the "
3977 "same filename as the backing file");
3983 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
3984 if (backing_fmt
&& backing_fmt
->value
.s
) {
3985 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
3987 error_report("Unknown backing file format '%s'",
3988 backing_fmt
->value
.s
);
3994 // The size for the image must always be specified, with one exception:
3995 // If we are using a backing file, we can obtain the size from there
3996 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
3997 if (size
&& size
->value
.n
== -1) {
3998 if (backing_file
&& backing_file
->value
.s
) {
4004 ret
= bdrv_open(bs
, backing_file
->value
.s
, flags
, backing_drv
);
4006 error_report("Could not open '%s'", backing_file
->value
.s
);
4009 bdrv_get_geometry(bs
, &size
);
4012 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4013 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4015 error_report("Image creation needs a size parameter");
4021 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4022 print_option_parameters(param
);
4025 ret
= bdrv_create(drv
, filename
, param
);
4028 if (ret
== -ENOTSUP
) {
4029 error_report("Formatting or formatting option not supported for "
4030 "file format '%s'", fmt
);
4031 } else if (ret
== -EFBIG
) {
4032 error_report("The image size is too large for file format '%s'",
4035 error_report("%s: error while creating %s: %s", filename
, fmt
,
4041 free_option_parameters(create_options
);
4042 free_option_parameters(param
);
4051 void *block_job_create(const BlockJobType
*job_type
, BlockDriverState
*bs
,
4052 BlockDriverCompletionFunc
*cb
, void *opaque
)
4056 if (bs
->job
|| bdrv_in_use(bs
)) {
4059 bdrv_set_in_use(bs
, 1);
4061 job
= g_malloc0(job_type
->instance_size
);
4062 job
->job_type
= job_type
;
4065 job
->opaque
= opaque
;
4070 void block_job_complete(BlockJob
*job
, int ret
)
4072 BlockDriverState
*bs
= job
->bs
;
4074 assert(bs
->job
== job
);
4075 job
->cb(job
->opaque
, ret
);
4078 bdrv_set_in_use(bs
, 0);
4081 int block_job_set_speed(BlockJob
*job
, int64_t value
)
4083 if (!job
->job_type
->set_speed
) {
4086 return job
->job_type
->set_speed(job
, value
);
4089 void block_job_cancel(BlockJob
*job
)
4091 job
->cancelled
= true;
4094 bool block_job_is_cancelled(BlockJob
*job
)
4096 return job
->cancelled
;