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"
27 #include "monitor/monitor.h"
28 #include "block/block_int.h"
29 #include "block/blockjob.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qjson.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
39 #include <sys/types.h>
41 #include <sys/ioctl.h>
42 #include <sys/queue.h>
52 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
55 BDRV_REQ_COPY_ON_READ
= 0x1,
56 BDRV_REQ_ZERO_WRITE
= 0x2,
59 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
60 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
61 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
62 BlockDriverCompletionFunc
*cb
, void *opaque
);
63 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
64 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
65 BlockDriverCompletionFunc
*cb
, void *opaque
);
66 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
67 int64_t sector_num
, int nb_sectors
,
69 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
70 int64_t sector_num
, int nb_sectors
,
72 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
73 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
74 BdrvRequestFlags flags
);
75 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
76 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
77 BdrvRequestFlags flags
);
78 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
82 BlockDriverCompletionFunc
*cb
,
85 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
86 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
87 int64_t sector_num
, int nb_sectors
);
89 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
90 bool is_write
, double elapsed_time
, uint64_t *wait
);
91 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
92 double elapsed_time
, uint64_t *wait
);
93 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
94 bool is_write
, int64_t *wait
);
96 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
97 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
99 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
100 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
102 /* If non-zero, use only whitelisted block drivers */
103 static int use_bdrv_whitelist
;
106 static int is_windows_drive_prefix(const char *filename
)
108 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
109 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
113 int is_windows_drive(const char *filename
)
115 if (is_windows_drive_prefix(filename
) &&
118 if (strstart(filename
, "\\\\.\\", NULL
) ||
119 strstart(filename
, "//./", NULL
))
125 /* throttling disk I/O limits */
126 void bdrv_io_limits_disable(BlockDriverState
*bs
)
128 bs
->io_limits_enabled
= false;
130 do {} while (qemu_co_enter_next(&bs
->throttled_reqs
));
132 if (bs
->block_timer
) {
133 qemu_del_timer(bs
->block_timer
);
134 qemu_free_timer(bs
->block_timer
);
135 bs
->block_timer
= NULL
;
142 static void bdrv_block_timer(void *opaque
)
144 BlockDriverState
*bs
= opaque
;
146 qemu_co_enter_next(&bs
->throttled_reqs
);
149 void bdrv_io_limits_enable(BlockDriverState
*bs
)
151 bs
->block_timer
= qemu_new_timer_ns(vm_clock
, bdrv_block_timer
, bs
);
152 bs
->io_limits_enabled
= true;
155 bool bdrv_io_limits_enabled(BlockDriverState
*bs
)
157 BlockIOLimit
*io_limits
= &bs
->io_limits
;
158 return io_limits
->bps
[BLOCK_IO_LIMIT_READ
]
159 || io_limits
->bps
[BLOCK_IO_LIMIT_WRITE
]
160 || io_limits
->bps
[BLOCK_IO_LIMIT_TOTAL
]
161 || io_limits
->iops
[BLOCK_IO_LIMIT_READ
]
162 || io_limits
->iops
[BLOCK_IO_LIMIT_WRITE
]
163 || io_limits
->iops
[BLOCK_IO_LIMIT_TOTAL
];
166 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
167 bool is_write
, int nb_sectors
)
169 int64_t wait_time
= -1;
171 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
172 qemu_co_queue_wait(&bs
->throttled_reqs
);
175 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
176 * throttled requests will not be dequeued until the current request is
177 * allowed to be serviced. So if the current request still exceeds the
178 * limits, it will be inserted to the head. All requests followed it will
179 * be still in throttled_reqs queue.
182 while (bdrv_exceed_io_limits(bs
, nb_sectors
, is_write
, &wait_time
)) {
183 qemu_mod_timer(bs
->block_timer
,
184 wait_time
+ qemu_get_clock_ns(vm_clock
));
185 qemu_co_queue_wait_insert_head(&bs
->throttled_reqs
);
188 qemu_co_queue_next(&bs
->throttled_reqs
);
191 /* check if the path starts with "<protocol>:" */
192 static int path_has_protocol(const char *path
)
197 if (is_windows_drive(path
) ||
198 is_windows_drive_prefix(path
)) {
201 p
= path
+ strcspn(path
, ":/\\");
203 p
= path
+ strcspn(path
, ":/");
209 int path_is_absolute(const char *path
)
212 /* specific case for names like: "\\.\d:" */
213 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
216 return (*path
== '/' || *path
== '\\');
218 return (*path
== '/');
222 /* if filename is absolute, just copy it to dest. Otherwise, build a
223 path to it by considering it is relative to base_path. URL are
225 void path_combine(char *dest
, int dest_size
,
226 const char *base_path
,
227 const char *filename
)
234 if (path_is_absolute(filename
)) {
235 pstrcpy(dest
, dest_size
, filename
);
237 p
= strchr(base_path
, ':');
242 p1
= strrchr(base_path
, '/');
246 p2
= strrchr(base_path
, '\\');
258 if (len
> dest_size
- 1)
260 memcpy(dest
, base_path
, len
);
262 pstrcat(dest
, dest_size
, filename
);
266 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
268 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
269 pstrcpy(dest
, sz
, bs
->backing_file
);
271 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
275 void bdrv_register(BlockDriver
*bdrv
)
277 /* Block drivers without coroutine functions need emulation */
278 if (!bdrv
->bdrv_co_readv
) {
279 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
280 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
282 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
283 * the block driver lacks aio we need to emulate that too.
285 if (!bdrv
->bdrv_aio_readv
) {
286 /* add AIO emulation layer */
287 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
288 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
292 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
295 /* create a new block device (by default it is empty) */
296 BlockDriverState
*bdrv_new(const char *device_name
)
298 BlockDriverState
*bs
;
300 bs
= g_malloc0(sizeof(BlockDriverState
));
301 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
302 if (device_name
[0] != '\0') {
303 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, list
);
305 bdrv_iostatus_disable(bs
);
306 notifier_list_init(&bs
->close_notifiers
);
307 notifier_with_return_list_init(&bs
->before_write_notifiers
);
308 qemu_co_queue_init(&bs
->throttled_reqs
);
313 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
315 notifier_list_add(&bs
->close_notifiers
, notify
);
318 BlockDriver
*bdrv_find_format(const char *format_name
)
321 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
322 if (!strcmp(drv1
->format_name
, format_name
)) {
329 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
331 static const char *whitelist_rw
[] = {
332 CONFIG_BDRV_RW_WHITELIST
334 static const char *whitelist_ro
[] = {
335 CONFIG_BDRV_RO_WHITELIST
339 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
340 return 1; /* no whitelist, anything goes */
343 for (p
= whitelist_rw
; *p
; p
++) {
344 if (!strcmp(drv
->format_name
, *p
)) {
349 for (p
= whitelist_ro
; *p
; p
++) {
350 if (!strcmp(drv
->format_name
, *p
)) {
358 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
361 BlockDriver
*drv
= bdrv_find_format(format_name
);
362 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
365 typedef struct CreateCo
{
368 QEMUOptionParameter
*options
;
372 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
374 CreateCo
*cco
= opaque
;
377 cco
->ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
);
380 int bdrv_create(BlockDriver
*drv
, const char* filename
,
381 QEMUOptionParameter
*options
)
388 .filename
= g_strdup(filename
),
393 if (!drv
->bdrv_create
) {
398 if (qemu_in_coroutine()) {
399 /* Fast-path if already in coroutine context */
400 bdrv_create_co_entry(&cco
);
402 co
= qemu_coroutine_create(bdrv_create_co_entry
);
403 qemu_coroutine_enter(co
, &cco
);
404 while (cco
.ret
== NOT_DONE
) {
412 g_free(cco
.filename
);
416 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
)
420 drv
= bdrv_find_protocol(filename
, true);
425 return bdrv_create(drv
, filename
, options
);
429 * Create a uniquely-named empty temporary file.
430 * Return 0 upon success, otherwise a negative errno value.
432 int get_tmp_filename(char *filename
, int size
)
435 char temp_dir
[MAX_PATH
];
436 /* GetTempFileName requires that its output buffer (4th param)
437 have length MAX_PATH or greater. */
438 assert(size
>= MAX_PATH
);
439 return (GetTempPath(MAX_PATH
, temp_dir
)
440 && GetTempFileName(temp_dir
, "qem", 0, filename
)
441 ? 0 : -GetLastError());
445 tmpdir
= getenv("TMPDIR");
448 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
451 fd
= mkstemp(filename
);
455 if (close(fd
) != 0) {
464 * Detect host devices. By convention, /dev/cdrom[N] is always
465 * recognized as a host CDROM.
467 static BlockDriver
*find_hdev_driver(const char *filename
)
469 int score_max
= 0, score
;
470 BlockDriver
*drv
= NULL
, *d
;
472 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
473 if (d
->bdrv_probe_device
) {
474 score
= d
->bdrv_probe_device(filename
);
475 if (score
> score_max
) {
485 BlockDriver
*bdrv_find_protocol(const char *filename
,
486 bool allow_protocol_prefix
)
493 /* TODO Drivers without bdrv_file_open must be specified explicitly */
496 * XXX(hch): we really should not let host device detection
497 * override an explicit protocol specification, but moving this
498 * later breaks access to device names with colons in them.
499 * Thanks to the brain-dead persistent naming schemes on udev-
500 * based Linux systems those actually are quite common.
502 drv1
= find_hdev_driver(filename
);
507 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
508 return bdrv_find_format("file");
511 p
= strchr(filename
, ':');
514 if (len
> sizeof(protocol
) - 1)
515 len
= sizeof(protocol
) - 1;
516 memcpy(protocol
, filename
, len
);
517 protocol
[len
] = '\0';
518 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
519 if (drv1
->protocol_name
&&
520 !strcmp(drv1
->protocol_name
, protocol
)) {
527 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
530 int score
, score_max
;
531 BlockDriver
*drv1
, *drv
;
535 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
536 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
537 drv
= bdrv_find_format("raw");
545 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
553 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
554 if (drv1
->bdrv_probe
) {
555 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
556 if (score
> score_max
) {
570 * Set the current 'total_sectors' value
572 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
574 BlockDriver
*drv
= bs
->drv
;
576 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
580 /* query actual device if possible, otherwise just trust the hint */
581 if (drv
->bdrv_getlength
) {
582 int64_t length
= drv
->bdrv_getlength(bs
);
586 hint
= length
>> BDRV_SECTOR_BITS
;
589 bs
->total_sectors
= hint
;
594 * Set open flags for a given discard mode
596 * Return 0 on success, -1 if the discard mode was invalid.
598 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
600 *flags
&= ~BDRV_O_UNMAP
;
602 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
604 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
605 *flags
|= BDRV_O_UNMAP
;
614 * Set open flags for a given cache mode
616 * Return 0 on success, -1 if the cache mode was invalid.
618 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
620 *flags
&= ~BDRV_O_CACHE_MASK
;
622 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
623 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
624 } else if (!strcmp(mode
, "directsync")) {
625 *flags
|= BDRV_O_NOCACHE
;
626 } else if (!strcmp(mode
, "writeback")) {
627 *flags
|= BDRV_O_CACHE_WB
;
628 } else if (!strcmp(mode
, "unsafe")) {
629 *flags
|= BDRV_O_CACHE_WB
;
630 *flags
|= BDRV_O_NO_FLUSH
;
631 } else if (!strcmp(mode
, "writethrough")) {
632 /* this is the default */
641 * The copy-on-read flag is actually a reference count so multiple users may
642 * use the feature without worrying about clobbering its previous state.
643 * Copy-on-read stays enabled until all users have called to disable it.
645 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
650 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
652 assert(bs
->copy_on_read
> 0);
656 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
658 int open_flags
= flags
| BDRV_O_CACHE_WB
;
661 * Clear flags that are internal to the block layer before opening the
664 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
667 * Snapshots should be writable.
669 if (bs
->is_temporary
) {
670 open_flags
|= BDRV_O_RDWR
;
677 * Common part for opening disk images and files
679 * Removes all processed options from *options.
681 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
682 QDict
*options
, int flags
, BlockDriver
*drv
)
685 const char *filename
;
688 assert(bs
->file
== NULL
);
689 assert(options
!= NULL
&& bs
->options
!= options
);
692 filename
= file
->filename
;
694 filename
= qdict_get_try_str(options
, "filename");
697 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
699 /* bdrv_open() with directly using a protocol as drv. This layer is already
700 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
701 * and return immediately. */
702 if (file
!= NULL
&& drv
->bdrv_file_open
) {
707 bs
->open_flags
= flags
;
708 bs
->buffer_alignment
= 512;
709 bs
->zero_beyond_eof
= true;
710 open_flags
= bdrv_open_flags(bs
, flags
);
711 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
713 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
717 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
718 if (!bs
->read_only
&& (flags
& BDRV_O_COPY_ON_READ
)) {
719 bdrv_enable_copy_on_read(bs
);
722 if (filename
!= NULL
) {
723 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
725 bs
->filename
[0] = '\0';
729 bs
->opaque
= g_malloc0(drv
->instance_size
);
731 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
733 /* Open the image, either directly or using a protocol */
734 if (drv
->bdrv_file_open
) {
735 assert(file
== NULL
);
736 assert(drv
->bdrv_parse_filename
|| filename
!= NULL
);
737 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
);
740 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Can't use '%s' as a "
741 "block driver for the protocol level",
746 assert(file
!= NULL
);
748 ret
= drv
->bdrv_open(bs
, options
, open_flags
);
755 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
761 if (bs
->is_temporary
) {
762 assert(filename
!= NULL
);
777 * Opens a file using a protocol (file, host_device, nbd, ...)
779 * options is a QDict of options to pass to the block drivers, or NULL for an
780 * empty set of options. The reference to the QDict belongs to the block layer
781 * after the call (even on failure), so if the caller intends to reuse the
782 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
784 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
,
785 QDict
*options
, int flags
)
787 BlockDriverState
*bs
;
790 bool allow_protocol_prefix
= false;
793 /* NULL means an empty set of options */
794 if (options
== NULL
) {
795 options
= qdict_new();
799 bs
->options
= options
;
800 options
= qdict_clone_shallow(options
);
802 /* Fetch the file name from the options QDict if necessary */
804 filename
= qdict_get_try_str(options
, "filename");
805 } else if (filename
&& !qdict_haskey(options
, "filename")) {
806 qdict_put(options
, "filename", qstring_from_str(filename
));
807 allow_protocol_prefix
= true;
809 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Can't specify 'file' and "
810 "'filename' options at the same time");
815 /* Find the right block driver */
816 drvname
= qdict_get_try_str(options
, "driver");
818 drv
= bdrv_find_whitelisted_format(drvname
, !(flags
& BDRV_O_RDWR
));
819 qdict_del(options
, "driver");
820 } else if (filename
) {
821 drv
= bdrv_find_protocol(filename
, allow_protocol_prefix
);
823 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Unknown protocol");
826 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
827 "Must specify either driver or file");
836 /* Parse the filename and open it */
837 if (drv
->bdrv_parse_filename
&& filename
) {
838 Error
*local_err
= NULL
;
839 drv
->bdrv_parse_filename(filename
, options
, &local_err
);
840 if (error_is_set(&local_err
)) {
841 qerror_report_err(local_err
);
842 error_free(local_err
);
846 qdict_del(options
, "filename");
847 } else if (!drv
->bdrv_parse_filename
&& !filename
) {
848 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
849 "The '%s' block driver requires a file name",
855 ret
= bdrv_open_common(bs
, NULL
, options
, flags
, drv
);
860 /* Check if any unknown options were used */
861 if (qdict_size(options
) != 0) {
862 const QDictEntry
*entry
= qdict_first(options
);
863 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Block protocol '%s' doesn't "
864 "support the option '%s'",
865 drv
->format_name
, entry
->key
);
878 QDECREF(bs
->options
);
885 * Opens the backing file for a BlockDriverState if not yet open
887 * options is a QDict of options to pass to the block drivers, or NULL for an
888 * empty set of options. The reference to the QDict is transferred to this
889 * function (even on failure), so if the caller intends to reuse the dictionary,
890 * it needs to use QINCREF() before calling bdrv_file_open.
892 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
)
894 char backing_filename
[PATH_MAX
];
896 BlockDriver
*back_drv
= NULL
;
898 if (bs
->backing_hd
!= NULL
) {
903 /* NULL means an empty set of options */
904 if (options
== NULL
) {
905 options
= qdict_new();
908 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
909 if (qdict_haskey(options
, "file.filename")) {
910 backing_filename
[0] = '\0';
911 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
916 bs
->backing_hd
= bdrv_new("");
917 bdrv_get_full_backing_filename(bs
, backing_filename
,
918 sizeof(backing_filename
));
920 if (bs
->backing_format
[0] != '\0') {
921 back_drv
= bdrv_find_format(bs
->backing_format
);
924 /* backing files always opened read-only */
925 back_flags
= bs
->open_flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
);
927 ret
= bdrv_open(bs
->backing_hd
,
928 *backing_filename
? backing_filename
: NULL
, options
,
929 back_flags
, back_drv
);
931 bdrv_delete(bs
->backing_hd
);
932 bs
->backing_hd
= NULL
;
933 bs
->open_flags
|= BDRV_O_NO_BACKING
;
939 static void extract_subqdict(QDict
*src
, QDict
**dst
, const char *start
)
941 const QDictEntry
*entry
, *next
;
945 entry
= qdict_first(src
);
947 while (entry
!= NULL
) {
948 next
= qdict_next(src
, entry
);
949 if (strstart(entry
->key
, start
, &p
)) {
950 qobject_incref(entry
->value
);
951 qdict_put_obj(*dst
, p
, entry
->value
);
952 qdict_del(src
, entry
->key
);
959 * Opens a disk image (raw, qcow2, vmdk, ...)
961 * options is a QDict of options to pass to the block drivers, or NULL for an
962 * empty set of options. The reference to the QDict belongs to the block layer
963 * after the call (even on failure), so if the caller intends to reuse the
964 * dictionary, it needs to use QINCREF() before calling bdrv_open.
966 int bdrv_open(BlockDriverState
*bs
, const char *filename
, QDict
*options
,
967 int flags
, BlockDriver
*drv
)
970 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
971 char tmp_filename
[PATH_MAX
+ 1];
972 BlockDriverState
*file
= NULL
;
973 QDict
*file_options
= NULL
;
976 /* NULL means an empty set of options */
977 if (options
== NULL
) {
978 options
= qdict_new();
981 bs
->options
= options
;
982 options
= qdict_clone_shallow(options
);
984 /* For snapshot=on, create a temporary qcow2 overlay */
985 if (flags
& BDRV_O_SNAPSHOT
) {
986 BlockDriverState
*bs1
;
988 BlockDriver
*bdrv_qcow2
;
989 QEMUOptionParameter
*create_options
;
990 char backing_filename
[PATH_MAX
];
992 if (qdict_size(options
) != 0) {
993 error_report("Can't use snapshot=on with driver-specific options");
997 assert(filename
!= NULL
);
999 /* if snapshot, we create a temporary backing file and open it
1000 instead of opening 'filename' directly */
1002 /* if there is a backing file, use it */
1004 ret
= bdrv_open(bs1
, filename
, NULL
, 0, drv
);
1009 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
1013 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
1018 /* Real path is meaningless for protocols */
1019 if (path_has_protocol(filename
)) {
1020 snprintf(backing_filename
, sizeof(backing_filename
),
1022 } else if (!realpath(filename
, backing_filename
)) {
1027 bdrv_qcow2
= bdrv_find_format("qcow2");
1028 create_options
= parse_option_parameters("", bdrv_qcow2
->create_options
,
1031 set_option_parameter_int(create_options
, BLOCK_OPT_SIZE
, total_size
);
1032 set_option_parameter(create_options
, BLOCK_OPT_BACKING_FILE
,
1035 set_option_parameter(create_options
, BLOCK_OPT_BACKING_FMT
,
1039 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, create_options
);
1040 free_option_parameters(create_options
);
1045 filename
= tmp_filename
;
1047 bs
->is_temporary
= 1;
1050 /* Open image file without format layer */
1051 if (flags
& BDRV_O_RDWR
) {
1052 flags
|= BDRV_O_ALLOW_RDWR
;
1055 extract_subqdict(options
, &file_options
, "file.");
1057 ret
= bdrv_file_open(&file
, filename
, file_options
,
1058 bdrv_open_flags(bs
, flags
| BDRV_O_UNMAP
));
1063 /* Find the right image format driver */
1064 drvname
= qdict_get_try_str(options
, "driver");
1066 drv
= bdrv_find_whitelisted_format(drvname
, !(flags
& BDRV_O_RDWR
));
1067 qdict_del(options
, "driver");
1071 ret
= find_image_format(file
, filename
, &drv
);
1075 goto unlink_and_fail
;
1078 /* Open the image */
1079 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
);
1081 goto unlink_and_fail
;
1084 if (bs
->file
!= file
) {
1089 /* If there is a backing file, use it */
1090 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1091 QDict
*backing_options
;
1093 extract_subqdict(options
, &backing_options
, "backing.");
1094 ret
= bdrv_open_backing_file(bs
, backing_options
);
1096 goto close_and_fail
;
1100 /* Check if any unknown options were used */
1101 if (qdict_size(options
) != 0) {
1102 const QDictEntry
*entry
= qdict_first(options
);
1103 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Block format '%s' used by "
1104 "device '%s' doesn't support the option '%s'",
1105 drv
->format_name
, bs
->device_name
, entry
->key
);
1108 goto close_and_fail
;
1112 if (!bdrv_key_required(bs
)) {
1113 bdrv_dev_change_media_cb(bs
, true);
1116 /* throttling disk I/O limits */
1117 if (bs
->io_limits_enabled
) {
1118 bdrv_io_limits_enable(bs
);
1127 if (bs
->is_temporary
) {
1131 QDECREF(bs
->options
);
1142 typedef struct BlockReopenQueueEntry
{
1144 BDRVReopenState state
;
1145 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1146 } BlockReopenQueueEntry
;
1149 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1150 * reopen of multiple devices.
1152 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1153 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1154 * be created and initialized. This newly created BlockReopenQueue should be
1155 * passed back in for subsequent calls that are intended to be of the same
1158 * bs is the BlockDriverState to add to the reopen queue.
1160 * flags contains the open flags for the associated bs
1162 * returns a pointer to bs_queue, which is either the newly allocated
1163 * bs_queue, or the existing bs_queue being used.
1166 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1167 BlockDriverState
*bs
, int flags
)
1171 BlockReopenQueueEntry
*bs_entry
;
1172 if (bs_queue
== NULL
) {
1173 bs_queue
= g_new0(BlockReopenQueue
, 1);
1174 QSIMPLEQ_INIT(bs_queue
);
1178 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
1181 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1182 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1184 bs_entry
->state
.bs
= bs
;
1185 bs_entry
->state
.flags
= flags
;
1191 * Reopen multiple BlockDriverStates atomically & transactionally.
1193 * The queue passed in (bs_queue) must have been built up previous
1194 * via bdrv_reopen_queue().
1196 * Reopens all BDS specified in the queue, with the appropriate
1197 * flags. All devices are prepared for reopen, and failure of any
1198 * device will cause all device changes to be abandonded, and intermediate
1201 * If all devices prepare successfully, then the changes are committed
1205 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1208 BlockReopenQueueEntry
*bs_entry
, *next
;
1209 Error
*local_err
= NULL
;
1211 assert(bs_queue
!= NULL
);
1215 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1216 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1217 error_propagate(errp
, local_err
);
1220 bs_entry
->prepared
= true;
1223 /* If we reach this point, we have success and just need to apply the
1226 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1227 bdrv_reopen_commit(&bs_entry
->state
);
1233 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1234 if (ret
&& bs_entry
->prepared
) {
1235 bdrv_reopen_abort(&bs_entry
->state
);
1244 /* Reopen a single BlockDriverState with the specified flags. */
1245 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1248 Error
*local_err
= NULL
;
1249 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1251 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1252 if (local_err
!= NULL
) {
1253 error_propagate(errp
, local_err
);
1260 * Prepares a BlockDriverState for reopen. All changes are staged in the
1261 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1262 * the block driver layer .bdrv_reopen_prepare()
1264 * bs is the BlockDriverState to reopen
1265 * flags are the new open flags
1266 * queue is the reopen queue
1268 * Returns 0 on success, non-zero on error. On error errp will be set
1271 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1272 * It is the responsibility of the caller to then call the abort() or
1273 * commit() for any other BDS that have been left in a prepare() state
1276 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1280 Error
*local_err
= NULL
;
1283 assert(reopen_state
!= NULL
);
1284 assert(reopen_state
->bs
->drv
!= NULL
);
1285 drv
= reopen_state
->bs
->drv
;
1287 /* if we are to stay read-only, do not allow permission change
1289 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1290 reopen_state
->flags
& BDRV_O_RDWR
) {
1291 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1292 reopen_state
->bs
->device_name
);
1297 ret
= bdrv_flush(reopen_state
->bs
);
1299 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1304 if (drv
->bdrv_reopen_prepare
) {
1305 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1307 if (local_err
!= NULL
) {
1308 error_propagate(errp
, local_err
);
1310 error_setg(errp
, "failed while preparing to reopen image '%s'",
1311 reopen_state
->bs
->filename
);
1316 /* It is currently mandatory to have a bdrv_reopen_prepare()
1317 * handler for each supported drv. */
1318 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1319 drv
->format_name
, reopen_state
->bs
->device_name
,
1320 "reopening of file");
1332 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1333 * makes them final by swapping the staging BlockDriverState contents into
1334 * the active BlockDriverState contents.
1336 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1340 assert(reopen_state
!= NULL
);
1341 drv
= reopen_state
->bs
->drv
;
1342 assert(drv
!= NULL
);
1344 /* If there are any driver level actions to take */
1345 if (drv
->bdrv_reopen_commit
) {
1346 drv
->bdrv_reopen_commit(reopen_state
);
1349 /* set BDS specific flags now */
1350 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1351 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1353 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1357 * Abort the reopen, and delete and free the staged changes in
1360 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1364 assert(reopen_state
!= NULL
);
1365 drv
= reopen_state
->bs
->drv
;
1366 assert(drv
!= NULL
);
1368 if (drv
->bdrv_reopen_abort
) {
1369 drv
->bdrv_reopen_abort(reopen_state
);
1374 void bdrv_close(BlockDriverState
*bs
)
1377 block_job_cancel_sync(bs
->job
);
1379 bdrv_drain_all(); /* complete I/O */
1381 bdrv_drain_all(); /* in case flush left pending I/O */
1382 notifier_list_notify(&bs
->close_notifiers
, bs
);
1385 if (bs
->backing_hd
) {
1386 bdrv_delete(bs
->backing_hd
);
1387 bs
->backing_hd
= NULL
;
1389 bs
->drv
->bdrv_close(bs
);
1392 if (bs
->is_temporary
) {
1393 unlink(bs
->filename
);
1398 bs
->copy_on_read
= 0;
1399 bs
->backing_file
[0] = '\0';
1400 bs
->backing_format
[0] = '\0';
1401 bs
->total_sectors
= 0;
1406 bs
->zero_beyond_eof
= false;
1407 QDECREF(bs
->options
);
1410 if (bs
->file
!= NULL
) {
1411 bdrv_delete(bs
->file
);
1416 bdrv_dev_change_media_cb(bs
, false);
1418 /*throttling disk I/O limits*/
1419 if (bs
->io_limits_enabled
) {
1420 bdrv_io_limits_disable(bs
);
1424 void bdrv_close_all(void)
1426 BlockDriverState
*bs
;
1428 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1433 /* Check if any requests are in-flight (including throttled requests) */
1434 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1436 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1439 if (!qemu_co_queue_empty(&bs
->throttled_reqs
)) {
1442 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1445 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1451 static bool bdrv_requests_pending_all(void)
1453 BlockDriverState
*bs
;
1454 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1455 if (bdrv_requests_pending(bs
)) {
1463 * Wait for pending requests to complete across all BlockDriverStates
1465 * This function does not flush data to disk, use bdrv_flush_all() for that
1466 * after calling this function.
1468 * Note that completion of an asynchronous I/O operation can trigger any
1469 * number of other I/O operations on other devices---for example a coroutine
1470 * can be arbitrarily complex and a constant flow of I/O can come until the
1471 * coroutine is complete. Because of this, it is not possible to have a
1472 * function to drain a single device's I/O queue.
1474 void bdrv_drain_all(void)
1476 /* Always run first iteration so any pending completion BHs run */
1478 BlockDriverState
*bs
;
1481 /* FIXME: We do not have timer support here, so this is effectively
1484 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1485 while (qemu_co_enter_next(&bs
->throttled_reqs
)) {
1490 busy
= bdrv_requests_pending_all();
1491 busy
|= aio_poll(qemu_get_aio_context(), busy
);
1495 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1496 Also, NULL terminate the device_name to prevent double remove */
1497 void bdrv_make_anon(BlockDriverState
*bs
)
1499 if (bs
->device_name
[0] != '\0') {
1500 QTAILQ_REMOVE(&bdrv_states
, bs
, list
);
1502 bs
->device_name
[0] = '\0';
1505 static void bdrv_rebind(BlockDriverState
*bs
)
1507 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1508 bs
->drv
->bdrv_rebind(bs
);
1512 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1513 BlockDriverState
*bs_src
)
1515 /* move some fields that need to stay attached to the device */
1516 bs_dest
->open_flags
= bs_src
->open_flags
;
1519 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1520 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1521 bs_dest
->dev
= bs_src
->dev
;
1522 bs_dest
->buffer_alignment
= bs_src
->buffer_alignment
;
1523 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1525 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1527 /* i/o timing parameters */
1528 bs_dest
->slice_start
= bs_src
->slice_start
;
1529 bs_dest
->slice_end
= bs_src
->slice_end
;
1530 bs_dest
->slice_submitted
= bs_src
->slice_submitted
;
1531 bs_dest
->io_limits
= bs_src
->io_limits
;
1532 bs_dest
->throttled_reqs
= bs_src
->throttled_reqs
;
1533 bs_dest
->block_timer
= bs_src
->block_timer
;
1534 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1537 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1538 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1541 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1542 bs_dest
->iostatus
= bs_src
->iostatus
;
1545 bs_dest
->dirty_bitmap
= bs_src
->dirty_bitmap
;
1548 bs_dest
->in_use
= bs_src
->in_use
;
1549 bs_dest
->job
= bs_src
->job
;
1551 /* keep the same entry in bdrv_states */
1552 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1553 bs_src
->device_name
);
1554 bs_dest
->list
= bs_src
->list
;
1558 * Swap bs contents for two image chains while they are live,
1559 * while keeping required fields on the BlockDriverState that is
1560 * actually attached to a device.
1562 * This will modify the BlockDriverState fields, and swap contents
1563 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1565 * bs_new is required to be anonymous.
1567 * This function does not create any image files.
1569 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1571 BlockDriverState tmp
;
1573 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1574 assert(bs_new
->device_name
[0] == '\0');
1575 assert(bs_new
->dirty_bitmap
== NULL
);
1576 assert(bs_new
->job
== NULL
);
1577 assert(bs_new
->dev
== NULL
);
1578 assert(bs_new
->in_use
== 0);
1579 assert(bs_new
->io_limits_enabled
== false);
1580 assert(bs_new
->block_timer
== NULL
);
1586 /* there are some fields that should not be swapped, move them back */
1587 bdrv_move_feature_fields(&tmp
, bs_old
);
1588 bdrv_move_feature_fields(bs_old
, bs_new
);
1589 bdrv_move_feature_fields(bs_new
, &tmp
);
1591 /* bs_new shouldn't be in bdrv_states even after the swap! */
1592 assert(bs_new
->device_name
[0] == '\0');
1594 /* Check a few fields that should remain attached to the device */
1595 assert(bs_new
->dev
== NULL
);
1596 assert(bs_new
->job
== NULL
);
1597 assert(bs_new
->in_use
== 0);
1598 assert(bs_new
->io_limits_enabled
== false);
1599 assert(bs_new
->block_timer
== NULL
);
1601 bdrv_rebind(bs_new
);
1602 bdrv_rebind(bs_old
);
1606 * Add new bs contents at the top of an image chain while the chain is
1607 * live, while keeping required fields on the top layer.
1609 * This will modify the BlockDriverState fields, and swap contents
1610 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1612 * bs_new is required to be anonymous.
1614 * This function does not create any image files.
1616 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1618 bdrv_swap(bs_new
, bs_top
);
1620 /* The contents of 'tmp' will become bs_top, as we are
1621 * swapping bs_new and bs_top contents. */
1622 bs_top
->backing_hd
= bs_new
;
1623 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1624 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1626 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1627 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1630 void bdrv_delete(BlockDriverState
*bs
)
1634 assert(!bs
->in_use
);
1638 /* remove from list, if necessary */
1644 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1645 /* TODO change to DeviceState *dev when all users are qdevified */
1651 bdrv_iostatus_reset(bs
);
1655 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1656 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1658 if (bdrv_attach_dev(bs
, dev
) < 0) {
1663 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1664 /* TODO change to DeviceState *dev when all users are qdevified */
1666 assert(bs
->dev
== dev
);
1669 bs
->dev_opaque
= NULL
;
1670 bs
->buffer_alignment
= 512;
1673 /* TODO change to return DeviceState * when all users are qdevified */
1674 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1679 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1683 bs
->dev_opaque
= opaque
;
1686 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1687 enum MonitorEvent ev
,
1688 BlockErrorAction action
, bool is_read
)
1691 const char *action_str
;
1694 case BDRV_ACTION_REPORT
:
1695 action_str
= "report";
1697 case BDRV_ACTION_IGNORE
:
1698 action_str
= "ignore";
1700 case BDRV_ACTION_STOP
:
1701 action_str
= "stop";
1707 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1710 is_read
? "read" : "write");
1711 monitor_protocol_event(ev
, data
);
1713 qobject_decref(data
);
1716 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
1720 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1721 bdrv_get_device_name(bs
), ejected
);
1722 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
1724 qobject_decref(data
);
1727 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
1729 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
1730 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
1731 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
1732 if (tray_was_closed
) {
1734 bdrv_emit_qmp_eject_event(bs
, true);
1738 bdrv_emit_qmp_eject_event(bs
, false);
1743 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
1745 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
1748 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
1750 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
1751 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
1755 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
1757 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
1758 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
1763 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
1765 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
1766 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
1770 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
1772 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
1773 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
1779 * Run consistency checks on an image
1781 * Returns 0 if the check could be completed (it doesn't mean that the image is
1782 * free of errors) or -errno when an internal error occurred. The results of the
1783 * check are stored in res.
1785 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
1787 if (bs
->drv
->bdrv_check
== NULL
) {
1791 memset(res
, 0, sizeof(*res
));
1792 return bs
->drv
->bdrv_check(bs
, res
, fix
);
1795 #define COMMIT_BUF_SECTORS 2048
1797 /* commit COW file into the raw image */
1798 int bdrv_commit(BlockDriverState
*bs
)
1800 BlockDriver
*drv
= bs
->drv
;
1801 int64_t sector
, total_sectors
;
1802 int n
, ro
, open_flags
;
1805 char filename
[PATH_MAX
];
1810 if (!bs
->backing_hd
) {
1814 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
1818 ro
= bs
->backing_hd
->read_only
;
1819 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1820 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
1821 open_flags
= bs
->backing_hd
->open_flags
;
1824 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
1829 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
1830 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
1832 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
1833 if (bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
)) {
1835 if (bdrv_read(bs
, sector
, buf
, n
) != 0) {
1840 if (bdrv_write(bs
->backing_hd
, sector
, buf
, n
) != 0) {
1847 if (drv
->bdrv_make_empty
) {
1848 ret
= drv
->bdrv_make_empty(bs
);
1853 * Make sure all data we wrote to the backing device is actually
1857 bdrv_flush(bs
->backing_hd
);
1863 /* ignoring error return here */
1864 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
1870 int bdrv_commit_all(void)
1872 BlockDriverState
*bs
;
1874 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
1875 if (bs
->drv
&& bs
->backing_hd
) {
1876 int ret
= bdrv_commit(bs
);
1886 * Remove an active request from the tracked requests list
1888 * This function should be called when a tracked request is completing.
1890 static void tracked_request_end(BdrvTrackedRequest
*req
)
1892 QLIST_REMOVE(req
, list
);
1893 qemu_co_queue_restart_all(&req
->wait_queue
);
1897 * Add an active request to the tracked requests list
1899 static void tracked_request_begin(BdrvTrackedRequest
*req
,
1900 BlockDriverState
*bs
,
1902 int nb_sectors
, bool is_write
)
1904 *req
= (BdrvTrackedRequest
){
1906 .sector_num
= sector_num
,
1907 .nb_sectors
= nb_sectors
,
1908 .is_write
= is_write
,
1909 .co
= qemu_coroutine_self(),
1912 qemu_co_queue_init(&req
->wait_queue
);
1914 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
1918 * Round a region to cluster boundaries
1920 void bdrv_round_to_clusters(BlockDriverState
*bs
,
1921 int64_t sector_num
, int nb_sectors
,
1922 int64_t *cluster_sector_num
,
1923 int *cluster_nb_sectors
)
1925 BlockDriverInfo bdi
;
1927 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
1928 *cluster_sector_num
= sector_num
;
1929 *cluster_nb_sectors
= nb_sectors
;
1931 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
1932 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
1933 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
1938 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
1939 int64_t sector_num
, int nb_sectors
) {
1941 if (sector_num
>= req
->sector_num
+ req
->nb_sectors
) {
1945 if (req
->sector_num
>= sector_num
+ nb_sectors
) {
1951 static void coroutine_fn
wait_for_overlapping_requests(BlockDriverState
*bs
,
1952 int64_t sector_num
, int nb_sectors
)
1954 BdrvTrackedRequest
*req
;
1955 int64_t cluster_sector_num
;
1956 int cluster_nb_sectors
;
1959 /* If we touch the same cluster it counts as an overlap. This guarantees
1960 * that allocating writes will be serialized and not race with each other
1961 * for the same cluster. For example, in copy-on-read it ensures that the
1962 * CoR read and write operations are atomic and guest writes cannot
1963 * interleave between them.
1965 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
1966 &cluster_sector_num
, &cluster_nb_sectors
);
1970 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
1971 if (tracked_request_overlaps(req
, cluster_sector_num
,
1972 cluster_nb_sectors
)) {
1973 /* Hitting this means there was a reentrant request, for
1974 * example, a block driver issuing nested requests. This must
1975 * never happen since it means deadlock.
1977 assert(qemu_coroutine_self() != req
->co
);
1979 qemu_co_queue_wait(&req
->wait_queue
);
1990 * -EINVAL - backing format specified, but no file
1991 * -ENOSPC - can't update the backing file because no space is left in the
1993 * -ENOTSUP - format driver doesn't support changing the backing file
1995 int bdrv_change_backing_file(BlockDriverState
*bs
,
1996 const char *backing_file
, const char *backing_fmt
)
1998 BlockDriver
*drv
= bs
->drv
;
2001 /* Backing file format doesn't make sense without a backing file */
2002 if (backing_fmt
&& !backing_file
) {
2006 if (drv
->bdrv_change_backing_file
!= NULL
) {
2007 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2013 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2014 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2020 * Finds the image layer in the chain that has 'bs' as its backing file.
2022 * active is the current topmost image.
2024 * Returns NULL if bs is not found in active's image chain,
2025 * or if active == bs.
2027 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2028 BlockDriverState
*bs
)
2030 BlockDriverState
*overlay
= NULL
;
2031 BlockDriverState
*intermediate
;
2033 assert(active
!= NULL
);
2036 /* if bs is the same as active, then by definition it has no overlay
2042 intermediate
= active
;
2043 while (intermediate
->backing_hd
) {
2044 if (intermediate
->backing_hd
== bs
) {
2045 overlay
= intermediate
;
2048 intermediate
= intermediate
->backing_hd
;
2054 typedef struct BlkIntermediateStates
{
2055 BlockDriverState
*bs
;
2056 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2057 } BlkIntermediateStates
;
2061 * Drops images above 'base' up to and including 'top', and sets the image
2062 * above 'top' to have base as its backing file.
2064 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2065 * information in 'bs' can be properly updated.
2067 * E.g., this will convert the following chain:
2068 * bottom <- base <- intermediate <- top <- active
2072 * bottom <- base <- active
2074 * It is allowed for bottom==base, in which case it converts:
2076 * base <- intermediate <- top <- active
2083 * if active == top, that is considered an error
2086 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2087 BlockDriverState
*base
)
2089 BlockDriverState
*intermediate
;
2090 BlockDriverState
*base_bs
= NULL
;
2091 BlockDriverState
*new_top_bs
= NULL
;
2092 BlkIntermediateStates
*intermediate_state
, *next
;
2095 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2096 QSIMPLEQ_INIT(&states_to_delete
);
2098 if (!top
->drv
|| !base
->drv
) {
2102 new_top_bs
= bdrv_find_overlay(active
, top
);
2104 if (new_top_bs
== NULL
) {
2105 /* we could not find the image above 'top', this is an error */
2109 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2110 * to do, no intermediate images */
2111 if (new_top_bs
->backing_hd
== base
) {
2118 /* now we will go down through the list, and add each BDS we find
2119 * into our deletion queue, until we hit the 'base'
2121 while (intermediate
) {
2122 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
2123 intermediate_state
->bs
= intermediate
;
2124 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2126 if (intermediate
->backing_hd
== base
) {
2127 base_bs
= intermediate
->backing_hd
;
2130 intermediate
= intermediate
->backing_hd
;
2132 if (base_bs
== NULL
) {
2133 /* something went wrong, we did not end at the base. safely
2134 * unravel everything, and exit with error */
2138 /* success - we can delete the intermediate states, and link top->base */
2139 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
2140 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2144 new_top_bs
->backing_hd
= base_bs
;
2147 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2148 /* so that bdrv_close() does not recursively close the chain */
2149 intermediate_state
->bs
->backing_hd
= NULL
;
2150 bdrv_delete(intermediate_state
->bs
);
2155 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2156 g_free(intermediate_state
);
2162 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2167 if (!bdrv_is_inserted(bs
))
2173 len
= bdrv_getlength(bs
);
2178 if ((offset
> len
) || (len
- offset
< size
))
2184 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2187 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2188 nb_sectors
* BDRV_SECTOR_SIZE
);
2191 typedef struct RwCo
{
2192 BlockDriverState
*bs
;
2198 BdrvRequestFlags flags
;
2201 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2203 RwCo
*rwco
= opaque
;
2205 if (!rwco
->is_write
) {
2206 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
2207 rwco
->nb_sectors
, rwco
->qiov
,
2210 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
2211 rwco
->nb_sectors
, rwco
->qiov
,
2217 * Process a vectored synchronous request using coroutines
2219 static int bdrv_rwv_co(BlockDriverState
*bs
, int64_t sector_num
,
2220 QEMUIOVector
*qiov
, bool is_write
,
2221 BdrvRequestFlags flags
)
2226 .sector_num
= sector_num
,
2227 .nb_sectors
= qiov
->size
>> BDRV_SECTOR_BITS
,
2229 .is_write
= is_write
,
2233 assert((qiov
->size
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2236 * In sync call context, when the vcpu is blocked, this throttling timer
2237 * will not fire; so the I/O throttling function has to be disabled here
2238 * if it has been enabled.
2240 if (bs
->io_limits_enabled
) {
2241 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2242 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2243 bdrv_io_limits_disable(bs
);
2246 if (qemu_in_coroutine()) {
2247 /* Fast-path if already in coroutine context */
2248 bdrv_rw_co_entry(&rwco
);
2250 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2251 qemu_coroutine_enter(co
, &rwco
);
2252 while (rwco
.ret
== NOT_DONE
) {
2260 * Process a synchronous request using coroutines
2262 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2263 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2266 struct iovec iov
= {
2267 .iov_base
= (void *)buf
,
2268 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2271 qemu_iovec_init_external(&qiov
, &iov
, 1);
2272 return bdrv_rwv_co(bs
, sector_num
, &qiov
, is_write
, flags
);
2275 /* return < 0 if error. See bdrv_write() for the return codes */
2276 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2277 uint8_t *buf
, int nb_sectors
)
2279 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2282 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2283 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2284 uint8_t *buf
, int nb_sectors
)
2289 enabled
= bs
->io_limits_enabled
;
2290 bs
->io_limits_enabled
= false;
2291 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2292 bs
->io_limits_enabled
= enabled
;
2296 /* Return < 0 if error. Important errors are:
2297 -EIO generic I/O error (may happen for all errors)
2298 -ENOMEDIUM No media inserted.
2299 -EINVAL Invalid sector number or nb_sectors
2300 -EACCES Trying to write a read-only device
2302 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2303 const uint8_t *buf
, int nb_sectors
)
2305 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2308 int bdrv_writev(BlockDriverState
*bs
, int64_t sector_num
, QEMUIOVector
*qiov
)
2310 return bdrv_rwv_co(bs
, sector_num
, qiov
, true, 0);
2313 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
2315 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2316 BDRV_REQ_ZERO_WRITE
);
2319 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2320 void *buf
, int count1
)
2322 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2323 int len
, nb_sectors
, count
;
2328 /* first read to align to sector start */
2329 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2332 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2334 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2336 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2344 /* read the sectors "in place" */
2345 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2346 if (nb_sectors
> 0) {
2347 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2349 sector_num
+= nb_sectors
;
2350 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2355 /* add data from the last sector */
2357 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2359 memcpy(buf
, tmp_buf
, count
);
2364 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2366 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2367 int len
, nb_sectors
, count
;
2373 /* first write to align to sector start */
2374 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2377 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2379 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2381 qemu_iovec_to_buf(qiov
, 0, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)),
2383 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2391 /* write the sectors "in place" */
2392 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2393 if (nb_sectors
> 0) {
2394 QEMUIOVector qiov_inplace
;
2396 qemu_iovec_init(&qiov_inplace
, qiov
->niov
);
2397 qemu_iovec_concat(&qiov_inplace
, qiov
, len
,
2398 nb_sectors
<< BDRV_SECTOR_BITS
);
2399 ret
= bdrv_writev(bs
, sector_num
, &qiov_inplace
);
2400 qemu_iovec_destroy(&qiov_inplace
);
2405 sector_num
+= nb_sectors
;
2406 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2410 /* add data from the last sector */
2412 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2414 qemu_iovec_to_buf(qiov
, qiov
->size
- count
, tmp_buf
, count
);
2415 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2421 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2422 const void *buf
, int count1
)
2425 struct iovec iov
= {
2426 .iov_base
= (void *) buf
,
2430 qemu_iovec_init_external(&qiov
, &iov
, 1);
2431 return bdrv_pwritev(bs
, offset
, &qiov
);
2435 * Writes to the file and ensures that no writes are reordered across this
2436 * request (acts as a barrier)
2438 * Returns 0 on success, -errno in error cases.
2440 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2441 const void *buf
, int count
)
2445 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2450 /* No flush needed for cache modes that already do it */
2451 if (bs
->enable_write_cache
) {
2458 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2459 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2461 /* Perform I/O through a temporary buffer so that users who scribble over
2462 * their read buffer while the operation is in progress do not end up
2463 * modifying the image file. This is critical for zero-copy guest I/O
2464 * where anything might happen inside guest memory.
2466 void *bounce_buffer
;
2468 BlockDriver
*drv
= bs
->drv
;
2470 QEMUIOVector bounce_qiov
;
2471 int64_t cluster_sector_num
;
2472 int cluster_nb_sectors
;
2476 /* Cover entire cluster so no additional backing file I/O is required when
2477 * allocating cluster in the image file.
2479 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2480 &cluster_sector_num
, &cluster_nb_sectors
);
2482 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2483 cluster_sector_num
, cluster_nb_sectors
);
2485 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2486 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2487 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2489 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2495 if (drv
->bdrv_co_write_zeroes
&&
2496 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2497 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2498 cluster_nb_sectors
);
2500 /* This does not change the data on the disk, it is not necessary
2501 * to flush even in cache=writethrough mode.
2503 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2508 /* It might be okay to ignore write errors for guest requests. If this
2509 * is a deliberate copy-on-read then we don't want to ignore the error.
2510 * Simply report it in all cases.
2515 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2516 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2517 nb_sectors
* BDRV_SECTOR_SIZE
);
2520 qemu_vfree(bounce_buffer
);
2525 * Handle a read request in coroutine context
2527 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
2528 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2529 BdrvRequestFlags flags
)
2531 BlockDriver
*drv
= bs
->drv
;
2532 BdrvTrackedRequest req
;
2538 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2542 /* throttling disk read I/O */
2543 if (bs
->io_limits_enabled
) {
2544 bdrv_io_limits_intercept(bs
, false, nb_sectors
);
2547 if (bs
->copy_on_read
) {
2548 flags
|= BDRV_REQ_COPY_ON_READ
;
2550 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2551 bs
->copy_on_read_in_flight
++;
2554 if (bs
->copy_on_read_in_flight
) {
2555 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2558 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, false);
2560 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2563 ret
= bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2568 if (!ret
|| pnum
!= nb_sectors
) {
2569 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2574 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2577 tracked_request_end(&req
);
2579 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2580 bs
->copy_on_read_in_flight
--;
2586 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
2587 int nb_sectors
, QEMUIOVector
*qiov
)
2589 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
2591 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
2594 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
2595 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2597 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
2599 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
2600 BDRV_REQ_COPY_ON_READ
);
2603 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
2604 int64_t sector_num
, int nb_sectors
)
2606 BlockDriver
*drv
= bs
->drv
;
2611 /* TODO Emulate only part of misaligned requests instead of letting block
2612 * drivers return -ENOTSUP and emulate everything */
2614 /* First try the efficient write zeroes operation */
2615 if (drv
->bdrv_co_write_zeroes
) {
2616 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2617 if (ret
!= -ENOTSUP
) {
2622 /* Fall back to bounce buffer if write zeroes is unsupported */
2623 iov
.iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
;
2624 iov
.iov_base
= qemu_blockalign(bs
, iov
.iov_len
);
2625 memset(iov
.iov_base
, 0, iov
.iov_len
);
2626 qemu_iovec_init_external(&qiov
, &iov
, 1);
2628 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, &qiov
);
2630 qemu_vfree(iov
.iov_base
);
2635 * Handle a write request in coroutine context
2637 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
2638 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
2639 BdrvRequestFlags flags
)
2641 BlockDriver
*drv
= bs
->drv
;
2642 BdrvTrackedRequest req
;
2648 if (bs
->read_only
) {
2651 if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
2655 /* throttling disk write I/O */
2656 if (bs
->io_limits_enabled
) {
2657 bdrv_io_limits_intercept(bs
, true, nb_sectors
);
2660 if (bs
->copy_on_read_in_flight
) {
2661 wait_for_overlapping_requests(bs
, sector_num
, nb_sectors
);
2664 tracked_request_begin(&req
, bs
, sector_num
, nb_sectors
, true);
2666 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, &req
);
2669 /* Do nothing, write notifier decided to fail this request */
2670 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
2671 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
);
2673 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
2676 if (ret
== 0 && !bs
->enable_write_cache
) {
2677 ret
= bdrv_co_flush(bs
);
2680 if (bs
->dirty_bitmap
) {
2681 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
2684 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
2685 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
2688 tracked_request_end(&req
);
2693 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
2694 int nb_sectors
, QEMUIOVector
*qiov
)
2696 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
2698 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
2701 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
2702 int64_t sector_num
, int nb_sectors
)
2704 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
);
2706 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
2707 BDRV_REQ_ZERO_WRITE
);
2711 * Truncate file to 'offset' bytes (needed only for file protocols)
2713 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
2715 BlockDriver
*drv
= bs
->drv
;
2719 if (!drv
->bdrv_truncate
)
2723 if (bdrv_in_use(bs
))
2725 ret
= drv
->bdrv_truncate(bs
, offset
);
2727 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
2728 bdrv_dev_resize_cb(bs
);
2734 * Length of a allocated file in bytes. Sparse files are counted by actual
2735 * allocated space. Return < 0 if error or unknown.
2737 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
2739 BlockDriver
*drv
= bs
->drv
;
2743 if (drv
->bdrv_get_allocated_file_size
) {
2744 return drv
->bdrv_get_allocated_file_size(bs
);
2747 return bdrv_get_allocated_file_size(bs
->file
);
2753 * Length of a file in bytes. Return < 0 if error or unknown.
2755 int64_t bdrv_getlength(BlockDriverState
*bs
)
2757 BlockDriver
*drv
= bs
->drv
;
2761 if (bs
->growable
|| bdrv_dev_has_removable_media(bs
)) {
2762 if (drv
->bdrv_getlength
) {
2763 return drv
->bdrv_getlength(bs
);
2766 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
2769 /* return 0 as number of sectors if no device present or error */
2770 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
2773 length
= bdrv_getlength(bs
);
2777 length
= length
>> BDRV_SECTOR_BITS
;
2778 *nb_sectors_ptr
= length
;
2781 /* throttling disk io limits */
2782 void bdrv_set_io_limits(BlockDriverState
*bs
,
2783 BlockIOLimit
*io_limits
)
2785 bs
->io_limits
= *io_limits
;
2786 bs
->io_limits_enabled
= bdrv_io_limits_enabled(bs
);
2789 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
2790 BlockdevOnError on_write_error
)
2792 bs
->on_read_error
= on_read_error
;
2793 bs
->on_write_error
= on_write_error
;
2796 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
2798 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
2801 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
2803 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
2806 case BLOCKDEV_ON_ERROR_ENOSPC
:
2807 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
2808 case BLOCKDEV_ON_ERROR_STOP
:
2809 return BDRV_ACTION_STOP
;
2810 case BLOCKDEV_ON_ERROR_REPORT
:
2811 return BDRV_ACTION_REPORT
;
2812 case BLOCKDEV_ON_ERROR_IGNORE
:
2813 return BDRV_ACTION_IGNORE
;
2819 /* This is done by device models because, while the block layer knows
2820 * about the error, it does not know whether an operation comes from
2821 * the device or the block layer (from a job, for example).
2823 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
2824 bool is_read
, int error
)
2827 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
2828 if (action
== BDRV_ACTION_STOP
) {
2829 vm_stop(RUN_STATE_IO_ERROR
);
2830 bdrv_iostatus_set_err(bs
, error
);
2834 int bdrv_is_read_only(BlockDriverState
*bs
)
2836 return bs
->read_only
;
2839 int bdrv_is_sg(BlockDriverState
*bs
)
2844 int bdrv_enable_write_cache(BlockDriverState
*bs
)
2846 return bs
->enable_write_cache
;
2849 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
2851 bs
->enable_write_cache
= wce
;
2853 /* so a reopen() will preserve wce */
2855 bs
->open_flags
|= BDRV_O_CACHE_WB
;
2857 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
2861 int bdrv_is_encrypted(BlockDriverState
*bs
)
2863 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
2865 return bs
->encrypted
;
2868 int bdrv_key_required(BlockDriverState
*bs
)
2870 BlockDriverState
*backing_hd
= bs
->backing_hd
;
2872 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
2874 return (bs
->encrypted
&& !bs
->valid_key
);
2877 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
2880 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
2881 ret
= bdrv_set_key(bs
->backing_hd
, key
);
2887 if (!bs
->encrypted
) {
2889 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
2892 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
2895 } else if (!bs
->valid_key
) {
2897 /* call the change callback now, we skipped it on open */
2898 bdrv_dev_change_media_cb(bs
, true);
2903 const char *bdrv_get_format_name(BlockDriverState
*bs
)
2905 return bs
->drv
? bs
->drv
->format_name
: NULL
;
2908 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
2913 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
2914 it(opaque
, drv
->format_name
);
2918 BlockDriverState
*bdrv_find(const char *name
)
2920 BlockDriverState
*bs
;
2922 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2923 if (!strcmp(name
, bs
->device_name
)) {
2930 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
2933 return QTAILQ_FIRST(&bdrv_states
);
2935 return QTAILQ_NEXT(bs
, list
);
2938 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
2940 BlockDriverState
*bs
;
2942 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2947 const char *bdrv_get_device_name(BlockDriverState
*bs
)
2949 return bs
->device_name
;
2952 int bdrv_get_flags(BlockDriverState
*bs
)
2954 return bs
->open_flags
;
2957 int bdrv_flush_all(void)
2959 BlockDriverState
*bs
;
2962 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
2963 int ret
= bdrv_flush(bs
);
2964 if (ret
< 0 && !result
) {
2972 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
2977 int bdrv_has_zero_init(BlockDriverState
*bs
)
2981 if (bs
->drv
->bdrv_has_zero_init
) {
2982 return bs
->drv
->bdrv_has_zero_init(bs
);
2989 typedef struct BdrvCoIsAllocatedData
{
2990 BlockDriverState
*bs
;
2991 BlockDriverState
*base
;
2997 } BdrvCoIsAllocatedData
;
3000 * Returns true iff the specified sector is present in the disk image. Drivers
3001 * not implementing the functionality are assumed to not support backing files,
3002 * hence all their sectors are reported as allocated.
3004 * If 'sector_num' is beyond the end of the disk image the return value is 0
3005 * and 'pnum' is set to 0.
3007 * 'pnum' is set to the number of sectors (including and immediately following
3008 * the specified sector) that are known to be in the same
3009 * allocated/unallocated state.
3011 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3012 * beyond the end of the disk image it will be clamped.
3014 int coroutine_fn
bdrv_co_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
3015 int nb_sectors
, int *pnum
)
3019 if (sector_num
>= bs
->total_sectors
) {
3024 n
= bs
->total_sectors
- sector_num
;
3025 if (n
< nb_sectors
) {
3029 if (!bs
->drv
->bdrv_co_is_allocated
) {
3034 return bs
->drv
->bdrv_co_is_allocated(bs
, sector_num
, nb_sectors
, pnum
);
3037 /* Coroutine wrapper for bdrv_is_allocated() */
3038 static void coroutine_fn
bdrv_is_allocated_co_entry(void *opaque
)
3040 BdrvCoIsAllocatedData
*data
= opaque
;
3041 BlockDriverState
*bs
= data
->bs
;
3043 data
->ret
= bdrv_co_is_allocated(bs
, data
->sector_num
, data
->nb_sectors
,
3049 * Synchronous wrapper around bdrv_co_is_allocated().
3051 * See bdrv_co_is_allocated() for details.
3053 int bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
,
3057 BdrvCoIsAllocatedData data
= {
3059 .sector_num
= sector_num
,
3060 .nb_sectors
= nb_sectors
,
3065 co
= qemu_coroutine_create(bdrv_is_allocated_co_entry
);
3066 qemu_coroutine_enter(co
, &data
);
3067 while (!data
.done
) {
3074 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3076 * Return true if the given sector is allocated in any image between
3077 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3078 * sector is allocated in any image of the chain. Return false otherwise.
3080 * 'pnum' is set to the number of sectors (including and immediately following
3081 * the specified sector) that are known to be in the same
3082 * allocated/unallocated state.
3085 int coroutine_fn
bdrv_co_is_allocated_above(BlockDriverState
*top
,
3086 BlockDriverState
*base
,
3088 int nb_sectors
, int *pnum
)
3090 BlockDriverState
*intermediate
;
3091 int ret
, n
= nb_sectors
;
3094 while (intermediate
&& intermediate
!= base
) {
3096 ret
= bdrv_co_is_allocated(intermediate
, sector_num
, nb_sectors
,
3106 * [sector_num, nb_sectors] is unallocated on top but intermediate
3109 * [sector_num+x, nr_sectors] allocated.
3111 if (n
> pnum_inter
&&
3112 (intermediate
== top
||
3113 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
3117 intermediate
= intermediate
->backing_hd
;
3124 /* Coroutine wrapper for bdrv_is_allocated_above() */
3125 static void coroutine_fn
bdrv_is_allocated_above_co_entry(void *opaque
)
3127 BdrvCoIsAllocatedData
*data
= opaque
;
3128 BlockDriverState
*top
= data
->bs
;
3129 BlockDriverState
*base
= data
->base
;
3131 data
->ret
= bdrv_co_is_allocated_above(top
, base
, data
->sector_num
,
3132 data
->nb_sectors
, data
->pnum
);
3137 * Synchronous wrapper around bdrv_co_is_allocated_above().
3139 * See bdrv_co_is_allocated_above() for details.
3141 int bdrv_is_allocated_above(BlockDriverState
*top
, BlockDriverState
*base
,
3142 int64_t sector_num
, int nb_sectors
, int *pnum
)
3145 BdrvCoIsAllocatedData data
= {
3148 .sector_num
= sector_num
,
3149 .nb_sectors
= nb_sectors
,
3154 co
= qemu_coroutine_create(bdrv_is_allocated_above_co_entry
);
3155 qemu_coroutine_enter(co
, &data
);
3156 while (!data
.done
) {
3162 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3164 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3165 return bs
->backing_file
;
3166 else if (bs
->encrypted
)
3167 return bs
->filename
;
3172 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3173 char *filename
, int filename_size
)
3175 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3178 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
3179 const uint8_t *buf
, int nb_sectors
)
3181 BlockDriver
*drv
= bs
->drv
;
3184 if (!drv
->bdrv_write_compressed
)
3186 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
3189 assert(!bs
->dirty_bitmap
);
3191 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
3194 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3196 BlockDriver
*drv
= bs
->drv
;
3199 if (!drv
->bdrv_get_info
)
3201 memset(bdi
, 0, sizeof(*bdi
));
3202 return drv
->bdrv_get_info(bs
, bdi
);
3205 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
3206 int64_t pos
, int size
)
3209 struct iovec iov
= {
3210 .iov_base
= (void *) buf
,
3214 qemu_iovec_init_external(&qiov
, &iov
, 1);
3215 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
3218 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
3220 BlockDriver
*drv
= bs
->drv
;
3224 } else if (drv
->bdrv_save_vmstate
) {
3225 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
3226 } else if (bs
->file
) {
3227 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
3233 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
3234 int64_t pos
, int size
)
3236 BlockDriver
*drv
= bs
->drv
;
3239 if (drv
->bdrv_load_vmstate
)
3240 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
3242 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
3246 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
3248 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
3252 bs
->drv
->bdrv_debug_event(bs
, event
);
3255 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
3258 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
3262 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
3263 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
3269 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
3271 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_resume
) {
3275 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
3276 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
3282 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
3284 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
3288 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
3289 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
3295 int bdrv_is_snapshot(BlockDriverState
*bs
)
3297 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
3300 /* backing_file can either be relative, or absolute, or a protocol. If it is
3301 * relative, it must be relative to the chain. So, passing in bs->filename
3302 * from a BDS as backing_file should not be done, as that may be relative to
3303 * the CWD rather than the chain. */
3304 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
3305 const char *backing_file
)
3307 char *filename_full
= NULL
;
3308 char *backing_file_full
= NULL
;
3309 char *filename_tmp
= NULL
;
3310 int is_protocol
= 0;
3311 BlockDriverState
*curr_bs
= NULL
;
3312 BlockDriverState
*retval
= NULL
;
3314 if (!bs
|| !bs
->drv
|| !backing_file
) {
3318 filename_full
= g_malloc(PATH_MAX
);
3319 backing_file_full
= g_malloc(PATH_MAX
);
3320 filename_tmp
= g_malloc(PATH_MAX
);
3322 is_protocol
= path_has_protocol(backing_file
);
3324 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
3326 /* If either of the filename paths is actually a protocol, then
3327 * compare unmodified paths; otherwise make paths relative */
3328 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
3329 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
3330 retval
= curr_bs
->backing_hd
;
3334 /* If not an absolute filename path, make it relative to the current
3335 * image's filename path */
3336 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3339 /* We are going to compare absolute pathnames */
3340 if (!realpath(filename_tmp
, filename_full
)) {
3344 /* We need to make sure the backing filename we are comparing against
3345 * is relative to the current image filename (or absolute) */
3346 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
3347 curr_bs
->backing_file
);
3349 if (!realpath(filename_tmp
, backing_file_full
)) {
3353 if (strcmp(backing_file_full
, filename_full
) == 0) {
3354 retval
= curr_bs
->backing_hd
;
3360 g_free(filename_full
);
3361 g_free(backing_file_full
);
3362 g_free(filename_tmp
);
3366 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
3372 if (!bs
->backing_hd
) {
3376 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
3379 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
3381 BlockDriverState
*curr_bs
= NULL
;
3389 while (curr_bs
->backing_hd
) {
3390 curr_bs
= curr_bs
->backing_hd
;
3395 /**************************************************************/
3398 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
3399 QEMUIOVector
*qiov
, int nb_sectors
,
3400 BlockDriverCompletionFunc
*cb
, void *opaque
)
3402 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
3404 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3408 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
3409 QEMUIOVector
*qiov
, int nb_sectors
,
3410 BlockDriverCompletionFunc
*cb
, void *opaque
)
3412 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
3414 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
,
3419 typedef struct MultiwriteCB
{
3424 BlockDriverCompletionFunc
*cb
;
3426 QEMUIOVector
*free_qiov
;
3430 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
3434 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
3435 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
3436 if (mcb
->callbacks
[i
].free_qiov
) {
3437 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
3439 g_free(mcb
->callbacks
[i
].free_qiov
);
3443 static void multiwrite_cb(void *opaque
, int ret
)
3445 MultiwriteCB
*mcb
= opaque
;
3447 trace_multiwrite_cb(mcb
, ret
);
3449 if (ret
< 0 && !mcb
->error
) {
3453 mcb
->num_requests
--;
3454 if (mcb
->num_requests
== 0) {
3455 multiwrite_user_cb(mcb
);
3460 static int multiwrite_req_compare(const void *a
, const void *b
)
3462 const BlockRequest
*req1
= a
, *req2
= b
;
3465 * Note that we can't simply subtract req2->sector from req1->sector
3466 * here as that could overflow the return value.
3468 if (req1
->sector
> req2
->sector
) {
3470 } else if (req1
->sector
< req2
->sector
) {
3478 * Takes a bunch of requests and tries to merge them. Returns the number of
3479 * requests that remain after merging.
3481 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
3482 int num_reqs
, MultiwriteCB
*mcb
)
3486 // Sort requests by start sector
3487 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
3489 // Check if adjacent requests touch the same clusters. If so, combine them,
3490 // filling up gaps with zero sectors.
3492 for (i
= 1; i
< num_reqs
; i
++) {
3494 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
3496 // Handle exactly sequential writes and overlapping writes.
3497 if (reqs
[i
].sector
<= oldreq_last
) {
3501 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
3507 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
3508 qemu_iovec_init(qiov
,
3509 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
3511 // Add the first request to the merged one. If the requests are
3512 // overlapping, drop the last sectors of the first request.
3513 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
3514 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
3516 // We should need to add any zeros between the two requests
3517 assert (reqs
[i
].sector
<= oldreq_last
);
3519 // Add the second request
3520 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
3522 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
3523 reqs
[outidx
].qiov
= qiov
;
3525 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
3528 reqs
[outidx
].sector
= reqs
[i
].sector
;
3529 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
3530 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
3538 * Submit multiple AIO write requests at once.
3540 * On success, the function returns 0 and all requests in the reqs array have
3541 * been submitted. In error case this function returns -1, and any of the
3542 * requests may or may not be submitted yet. In particular, this means that the
3543 * callback will be called for some of the requests, for others it won't. The
3544 * caller must check the error field of the BlockRequest to wait for the right
3545 * callbacks (if error != 0, no callback will be called).
3547 * The implementation may modify the contents of the reqs array, e.g. to merge
3548 * requests. However, the fields opaque and error are left unmodified as they
3549 * are used to signal failure for a single request to the caller.
3551 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
3556 /* don't submit writes if we don't have a medium */
3557 if (bs
->drv
== NULL
) {
3558 for (i
= 0; i
< num_reqs
; i
++) {
3559 reqs
[i
].error
= -ENOMEDIUM
;
3564 if (num_reqs
== 0) {
3568 // Create MultiwriteCB structure
3569 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
3570 mcb
->num_requests
= 0;
3571 mcb
->num_callbacks
= num_reqs
;
3573 for (i
= 0; i
< num_reqs
; i
++) {
3574 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
3575 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
3578 // Check for mergable requests
3579 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
3581 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
3583 /* Run the aio requests. */
3584 mcb
->num_requests
= num_reqs
;
3585 for (i
= 0; i
< num_reqs
; i
++) {
3586 bdrv_aio_writev(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
3587 reqs
[i
].nb_sectors
, multiwrite_cb
, mcb
);
3593 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
3595 acb
->aiocb_info
->cancel(acb
);
3598 /* block I/O throttling */
3599 static bool bdrv_exceed_bps_limits(BlockDriverState
*bs
, int nb_sectors
,
3600 bool is_write
, double elapsed_time
, uint64_t *wait
)
3602 uint64_t bps_limit
= 0;
3604 double bytes_limit
, bytes_base
, bytes_res
;
3605 double slice_time
, wait_time
;
3607 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3608 bps_limit
= bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
];
3609 } else if (bs
->io_limits
.bps
[is_write
]) {
3610 bps_limit
= bs
->io_limits
.bps
[is_write
];
3619 slice_time
= bs
->slice_end
- bs
->slice_start
;
3620 slice_time
/= (NANOSECONDS_PER_SECOND
);
3621 bytes_limit
= bps_limit
* slice_time
;
3622 bytes_base
= bs
->slice_submitted
.bytes
[is_write
];
3623 if (bs
->io_limits
.bps
[BLOCK_IO_LIMIT_TOTAL
]) {
3624 bytes_base
+= bs
->slice_submitted
.bytes
[!is_write
];
3627 /* bytes_base: the bytes of data which have been read/written; and
3628 * it is obtained from the history statistic info.
3629 * bytes_res: the remaining bytes of data which need to be read/written.
3630 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3631 * the total time for completing reading/writting all data.
3633 bytes_res
= (unsigned) nb_sectors
* BDRV_SECTOR_SIZE
;
3635 if (bytes_base
+ bytes_res
<= bytes_limit
) {
3643 /* Calc approx time to dispatch */
3644 wait_time
= (bytes_base
+ bytes_res
) / bps_limit
- elapsed_time
;
3646 /* When the I/O rate at runtime exceeds the limits,
3647 * bs->slice_end need to be extended in order that the current statistic
3648 * info can be kept until the timer fire, so it is increased and tuned
3649 * based on the result of experiment.
3651 extension
= wait_time
* NANOSECONDS_PER_SECOND
;
3652 extension
= DIV_ROUND_UP(extension
, BLOCK_IO_SLICE_TIME
) *
3653 BLOCK_IO_SLICE_TIME
;
3654 bs
->slice_end
+= extension
;
3656 *wait
= wait_time
* NANOSECONDS_PER_SECOND
;
3662 static bool bdrv_exceed_iops_limits(BlockDriverState
*bs
, bool is_write
,
3663 double elapsed_time
, uint64_t *wait
)
3665 uint64_t iops_limit
= 0;
3666 double ios_limit
, ios_base
;
3667 double slice_time
, wait_time
;
3669 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3670 iops_limit
= bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
];
3671 } else if (bs
->io_limits
.iops
[is_write
]) {
3672 iops_limit
= bs
->io_limits
.iops
[is_write
];
3681 slice_time
= bs
->slice_end
- bs
->slice_start
;
3682 slice_time
/= (NANOSECONDS_PER_SECOND
);
3683 ios_limit
= iops_limit
* slice_time
;
3684 ios_base
= bs
->slice_submitted
.ios
[is_write
];
3685 if (bs
->io_limits
.iops
[BLOCK_IO_LIMIT_TOTAL
]) {
3686 ios_base
+= bs
->slice_submitted
.ios
[!is_write
];
3689 if (ios_base
+ 1 <= ios_limit
) {
3697 /* Calc approx time to dispatch, in seconds */
3698 wait_time
= (ios_base
+ 1) / iops_limit
;
3699 if (wait_time
> elapsed_time
) {
3700 wait_time
= wait_time
- elapsed_time
;
3705 /* Exceeded current slice, extend it by another slice time */
3706 bs
->slice_end
+= BLOCK_IO_SLICE_TIME
;
3708 *wait
= wait_time
* NANOSECONDS_PER_SECOND
;
3714 static bool bdrv_exceed_io_limits(BlockDriverState
*bs
, int nb_sectors
,
3715 bool is_write
, int64_t *wait
)
3717 int64_t now
, max_wait
;
3718 uint64_t bps_wait
= 0, iops_wait
= 0;
3719 double elapsed_time
;
3720 int bps_ret
, iops_ret
;
3722 now
= qemu_get_clock_ns(vm_clock
);
3723 if (now
> bs
->slice_end
) {
3724 bs
->slice_start
= now
;
3725 bs
->slice_end
= now
+ BLOCK_IO_SLICE_TIME
;
3726 memset(&bs
->slice_submitted
, 0, sizeof(bs
->slice_submitted
));
3729 elapsed_time
= now
- bs
->slice_start
;
3730 elapsed_time
/= (NANOSECONDS_PER_SECOND
);
3732 bps_ret
= bdrv_exceed_bps_limits(bs
, nb_sectors
,
3733 is_write
, elapsed_time
, &bps_wait
);
3734 iops_ret
= bdrv_exceed_iops_limits(bs
, is_write
,
3735 elapsed_time
, &iops_wait
);
3736 if (bps_ret
|| iops_ret
) {
3737 max_wait
= bps_wait
> iops_wait
? bps_wait
: iops_wait
;
3742 now
= qemu_get_clock_ns(vm_clock
);
3743 if (bs
->slice_end
< now
+ max_wait
) {
3744 bs
->slice_end
= now
+ max_wait
;
3754 bs
->slice_submitted
.bytes
[is_write
] += (int64_t)nb_sectors
*
3756 bs
->slice_submitted
.ios
[is_write
]++;
3761 /**************************************************************/
3762 /* async block device emulation */
3764 typedef struct BlockDriverAIOCBSync
{
3765 BlockDriverAIOCB common
;
3768 /* vector translation state */
3772 } BlockDriverAIOCBSync
;
3774 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
3776 BlockDriverAIOCBSync
*acb
=
3777 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
3778 qemu_bh_delete(acb
->bh
);
3780 qemu_aio_release(acb
);
3783 static const AIOCBInfo bdrv_em_aiocb_info
= {
3784 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
3785 .cancel
= bdrv_aio_cancel_em
,
3788 static void bdrv_aio_bh_cb(void *opaque
)
3790 BlockDriverAIOCBSync
*acb
= opaque
;
3793 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
3794 qemu_vfree(acb
->bounce
);
3795 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
3796 qemu_bh_delete(acb
->bh
);
3798 qemu_aio_release(acb
);
3801 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
3805 BlockDriverCompletionFunc
*cb
,
3810 BlockDriverAIOCBSync
*acb
;
3812 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
3813 acb
->is_write
= is_write
;
3815 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
3816 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
3819 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
3820 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3822 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
3825 qemu_bh_schedule(acb
->bh
);
3827 return &acb
->common
;
3830 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
3831 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3832 BlockDriverCompletionFunc
*cb
, void *opaque
)
3834 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
3837 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
3838 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
3839 BlockDriverCompletionFunc
*cb
, void *opaque
)
3841 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
3845 typedef struct BlockDriverAIOCBCoroutine
{
3846 BlockDriverAIOCB common
;
3851 } BlockDriverAIOCBCoroutine
;
3853 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
3855 BlockDriverAIOCBCoroutine
*acb
=
3856 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
3865 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
3866 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
3867 .cancel
= bdrv_aio_co_cancel_em
,
3870 static void bdrv_co_em_bh(void *opaque
)
3872 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3874 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
3880 qemu_bh_delete(acb
->bh
);
3881 qemu_aio_release(acb
);
3884 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3885 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
3887 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3888 BlockDriverState
*bs
= acb
->common
.bs
;
3890 if (!acb
->is_write
) {
3891 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
3892 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3894 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
3895 acb
->req
.nb_sectors
, acb
->req
.qiov
, 0);
3898 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3899 qemu_bh_schedule(acb
->bh
);
3902 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
3906 BlockDriverCompletionFunc
*cb
,
3911 BlockDriverAIOCBCoroutine
*acb
;
3913 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3914 acb
->req
.sector
= sector_num
;
3915 acb
->req
.nb_sectors
= nb_sectors
;
3916 acb
->req
.qiov
= qiov
;
3917 acb
->is_write
= is_write
;
3920 co
= qemu_coroutine_create(bdrv_co_do_rw
);
3921 qemu_coroutine_enter(co
, acb
);
3923 return &acb
->common
;
3926 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
3928 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3929 BlockDriverState
*bs
= acb
->common
.bs
;
3931 acb
->req
.error
= bdrv_co_flush(bs
);
3932 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3933 qemu_bh_schedule(acb
->bh
);
3936 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
3937 BlockDriverCompletionFunc
*cb
, void *opaque
)
3939 trace_bdrv_aio_flush(bs
, opaque
);
3942 BlockDriverAIOCBCoroutine
*acb
;
3944 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3947 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
3948 qemu_coroutine_enter(co
, acb
);
3950 return &acb
->common
;
3953 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
3955 BlockDriverAIOCBCoroutine
*acb
= opaque
;
3956 BlockDriverState
*bs
= acb
->common
.bs
;
3958 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
3959 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
3960 qemu_bh_schedule(acb
->bh
);
3963 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
3964 int64_t sector_num
, int nb_sectors
,
3965 BlockDriverCompletionFunc
*cb
, void *opaque
)
3968 BlockDriverAIOCBCoroutine
*acb
;
3970 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
3972 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
3973 acb
->req
.sector
= sector_num
;
3974 acb
->req
.nb_sectors
= nb_sectors
;
3976 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
3977 qemu_coroutine_enter(co
, acb
);
3979 return &acb
->common
;
3982 void bdrv_init(void)
3984 module_call_init(MODULE_INIT_BLOCK
);
3987 void bdrv_init_with_whitelist(void)
3989 use_bdrv_whitelist
= 1;
3993 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
3994 BlockDriverCompletionFunc
*cb
, void *opaque
)
3996 BlockDriverAIOCB
*acb
;
3998 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
3999 acb
->aiocb_info
= aiocb_info
;
4002 acb
->opaque
= opaque
;
4006 void qemu_aio_release(void *p
)
4008 BlockDriverAIOCB
*acb
= p
;
4009 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4012 /**************************************************************/
4013 /* Coroutine block device emulation */
4015 typedef struct CoroutineIOCompletion
{
4016 Coroutine
*coroutine
;
4018 } CoroutineIOCompletion
;
4020 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4022 CoroutineIOCompletion
*co
= opaque
;
4025 qemu_coroutine_enter(co
->coroutine
, NULL
);
4028 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4029 int nb_sectors
, QEMUIOVector
*iov
,
4032 CoroutineIOCompletion co
= {
4033 .coroutine
= qemu_coroutine_self(),
4035 BlockDriverAIOCB
*acb
;
4038 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4039 bdrv_co_io_em_complete
, &co
);
4041 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4042 bdrv_co_io_em_complete
, &co
);
4045 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4049 qemu_coroutine_yield();
4054 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4055 int64_t sector_num
, int nb_sectors
,
4058 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4061 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4062 int64_t sector_num
, int nb_sectors
,
4065 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4068 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4070 RwCo
*rwco
= opaque
;
4072 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4075 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4079 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4083 /* Write back cached data to the OS even with cache=unsafe */
4084 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4085 if (bs
->drv
->bdrv_co_flush_to_os
) {
4086 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4092 /* But don't actually force it to the disk with cache=unsafe */
4093 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4097 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
4098 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4099 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4100 } else if (bs
->drv
->bdrv_aio_flush
) {
4101 BlockDriverAIOCB
*acb
;
4102 CoroutineIOCompletion co
= {
4103 .coroutine
= qemu_coroutine_self(),
4106 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4110 qemu_coroutine_yield();
4115 * Some block drivers always operate in either writethrough or unsafe
4116 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4117 * know how the server works (because the behaviour is hardcoded or
4118 * depends on server-side configuration), so we can't ensure that
4119 * everything is safe on disk. Returning an error doesn't work because
4120 * that would break guests even if the server operates in writethrough
4123 * Let's hope the user knows what he's doing.
4131 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4132 * in the case of cache=unsafe, so there are no useless flushes.
4135 return bdrv_co_flush(bs
->file
);
4138 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4140 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4141 bs
->drv
->bdrv_invalidate_cache(bs
);
4145 void bdrv_invalidate_cache_all(void)
4147 BlockDriverState
*bs
;
4149 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4150 bdrv_invalidate_cache(bs
);
4154 void bdrv_clear_incoming_migration_all(void)
4156 BlockDriverState
*bs
;
4158 QTAILQ_FOREACH(bs
, &bdrv_states
, list
) {
4159 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4163 int bdrv_flush(BlockDriverState
*bs
)
4171 if (qemu_in_coroutine()) {
4172 /* Fast-path if already in coroutine context */
4173 bdrv_flush_co_entry(&rwco
);
4175 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4176 qemu_coroutine_enter(co
, &rwco
);
4177 while (rwco
.ret
== NOT_DONE
) {
4185 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4187 RwCo
*rwco
= opaque
;
4189 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4192 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4197 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4199 } else if (bs
->read_only
) {
4203 if (bs
->dirty_bitmap
) {
4204 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
4207 /* Do nothing if disabled. */
4208 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
4212 if (bs
->drv
->bdrv_co_discard
) {
4213 return bs
->drv
->bdrv_co_discard(bs
, sector_num
, nb_sectors
);
4214 } else if (bs
->drv
->bdrv_aio_discard
) {
4215 BlockDriverAIOCB
*acb
;
4216 CoroutineIOCompletion co
= {
4217 .coroutine
= qemu_coroutine_self(),
4220 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4221 bdrv_co_io_em_complete
, &co
);
4225 qemu_coroutine_yield();
4233 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4238 .sector_num
= sector_num
,
4239 .nb_sectors
= nb_sectors
,
4243 if (qemu_in_coroutine()) {
4244 /* Fast-path if already in coroutine context */
4245 bdrv_discard_co_entry(&rwco
);
4247 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4248 qemu_coroutine_enter(co
, &rwco
);
4249 while (rwco
.ret
== NOT_DONE
) {
4257 /**************************************************************/
4258 /* removable device support */
4261 * Return TRUE if the media is present
4263 int bdrv_is_inserted(BlockDriverState
*bs
)
4265 BlockDriver
*drv
= bs
->drv
;
4269 if (!drv
->bdrv_is_inserted
)
4271 return drv
->bdrv_is_inserted(bs
);
4275 * Return whether the media changed since the last call to this
4276 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4278 int bdrv_media_changed(BlockDriverState
*bs
)
4280 BlockDriver
*drv
= bs
->drv
;
4282 if (drv
&& drv
->bdrv_media_changed
) {
4283 return drv
->bdrv_media_changed(bs
);
4289 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4291 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4293 BlockDriver
*drv
= bs
->drv
;
4295 if (drv
&& drv
->bdrv_eject
) {
4296 drv
->bdrv_eject(bs
, eject_flag
);
4299 if (bs
->device_name
[0] != '\0') {
4300 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4305 * Lock or unlock the media (if it is locked, the user won't be able
4306 * to eject it manually).
4308 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4310 BlockDriver
*drv
= bs
->drv
;
4312 trace_bdrv_lock_medium(bs
, locked
);
4314 if (drv
&& drv
->bdrv_lock_medium
) {
4315 drv
->bdrv_lock_medium(bs
, locked
);
4319 /* needed for generic scsi interface */
4321 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
4323 BlockDriver
*drv
= bs
->drv
;
4325 if (drv
&& drv
->bdrv_ioctl
)
4326 return drv
->bdrv_ioctl(bs
, req
, buf
);
4330 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
4331 unsigned long int req
, void *buf
,
4332 BlockDriverCompletionFunc
*cb
, void *opaque
)
4334 BlockDriver
*drv
= bs
->drv
;
4336 if (drv
&& drv
->bdrv_aio_ioctl
)
4337 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
4341 void bdrv_set_buffer_alignment(BlockDriverState
*bs
, int align
)
4343 bs
->buffer_alignment
= align
;
4346 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
4348 return qemu_memalign((bs
&& bs
->buffer_alignment
) ? bs
->buffer_alignment
: 512, size
);
4352 * Check if all memory in this vector is sector aligned.
4354 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
4358 for (i
= 0; i
< qiov
->niov
; i
++) {
4359 if ((uintptr_t) qiov
->iov
[i
].iov_base
% bs
->buffer_alignment
) {
4367 void bdrv_set_dirty_tracking(BlockDriverState
*bs
, int granularity
)
4369 int64_t bitmap_size
;
4371 assert((granularity
& (granularity
- 1)) == 0);
4374 granularity
>>= BDRV_SECTOR_BITS
;
4375 assert(!bs
->dirty_bitmap
);
4376 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
);
4377 bs
->dirty_bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
4379 if (bs
->dirty_bitmap
) {
4380 hbitmap_free(bs
->dirty_bitmap
);
4381 bs
->dirty_bitmap
= NULL
;
4386 int bdrv_get_dirty(BlockDriverState
*bs
, int64_t sector
)
4388 if (bs
->dirty_bitmap
) {
4389 return hbitmap_get(bs
->dirty_bitmap
, sector
);
4395 void bdrv_dirty_iter_init(BlockDriverState
*bs
, HBitmapIter
*hbi
)
4397 hbitmap_iter_init(hbi
, bs
->dirty_bitmap
, 0);
4400 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4403 hbitmap_set(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4406 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
4409 hbitmap_reset(bs
->dirty_bitmap
, cur_sector
, nr_sectors
);
4412 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
)
4414 if (bs
->dirty_bitmap
) {
4415 return hbitmap_count(bs
->dirty_bitmap
);
4421 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
4423 assert(bs
->in_use
!= in_use
);
4424 bs
->in_use
= in_use
;
4427 int bdrv_in_use(BlockDriverState
*bs
)
4432 void bdrv_iostatus_enable(BlockDriverState
*bs
)
4434 bs
->iostatus_enabled
= true;
4435 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4438 /* The I/O status is only enabled if the drive explicitly
4439 * enables it _and_ the VM is configured to stop on errors */
4440 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
4442 return (bs
->iostatus_enabled
&&
4443 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
4444 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
4445 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
4448 void bdrv_iostatus_disable(BlockDriverState
*bs
)
4450 bs
->iostatus_enabled
= false;
4453 void bdrv_iostatus_reset(BlockDriverState
*bs
)
4455 if (bdrv_iostatus_is_enabled(bs
)) {
4456 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
4458 block_job_iostatus_reset(bs
->job
);
4463 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
4465 assert(bdrv_iostatus_is_enabled(bs
));
4466 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
4467 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
4468 BLOCK_DEVICE_IO_STATUS_FAILED
;
4473 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
4474 enum BlockAcctType type
)
4476 assert(type
< BDRV_MAX_IOTYPE
);
4478 cookie
->bytes
= bytes
;
4479 cookie
->start_time_ns
= get_clock();
4480 cookie
->type
= type
;
4484 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
4486 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
4488 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
4489 bs
->nr_ops
[cookie
->type
]++;
4490 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
4493 void bdrv_img_create(const char *filename
, const char *fmt
,
4494 const char *base_filename
, const char *base_fmt
,
4495 char *options
, uint64_t img_size
, int flags
,
4496 Error
**errp
, bool quiet
)
4498 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
4499 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
4500 BlockDriverState
*bs
= NULL
;
4501 BlockDriver
*drv
, *proto_drv
;
4502 BlockDriver
*backing_drv
= NULL
;
4505 /* Find driver and parse its options */
4506 drv
= bdrv_find_format(fmt
);
4508 error_setg(errp
, "Unknown file format '%s'", fmt
);
4512 proto_drv
= bdrv_find_protocol(filename
, true);
4514 error_setg(errp
, "Unknown protocol '%s'", filename
);
4518 create_options
= append_option_parameters(create_options
,
4519 drv
->create_options
);
4520 create_options
= append_option_parameters(create_options
,
4521 proto_drv
->create_options
);
4523 /* Create parameter list with default values */
4524 param
= parse_option_parameters("", create_options
, param
);
4526 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
4528 /* Parse -o options */
4530 param
= parse_option_parameters(options
, create_options
, param
);
4531 if (param
== NULL
) {
4532 error_setg(errp
, "Invalid options for file format '%s'.", fmt
);
4537 if (base_filename
) {
4538 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
4540 error_setg(errp
, "Backing file not supported for file format '%s'",
4547 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
4548 error_setg(errp
, "Backing file format not supported for file "
4549 "format '%s'", fmt
);
4554 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
4555 if (backing_file
&& backing_file
->value
.s
) {
4556 if (!strcmp(filename
, backing_file
->value
.s
)) {
4557 error_setg(errp
, "Error: Trying to create an image with the "
4558 "same filename as the backing file");
4563 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
4564 if (backing_fmt
&& backing_fmt
->value
.s
) {
4565 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
4567 error_setg(errp
, "Unknown backing file format '%s'",
4568 backing_fmt
->value
.s
);
4573 // The size for the image must always be specified, with one exception:
4574 // If we are using a backing file, we can obtain the size from there
4575 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
4576 if (size
&& size
->value
.n
== -1) {
4577 if (backing_file
&& backing_file
->value
.s
) {
4582 /* backing files always opened read-only */
4584 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
4588 ret
= bdrv_open(bs
, backing_file
->value
.s
, NULL
, back_flags
,
4591 error_setg_errno(errp
, -ret
, "Could not open '%s'",
4592 backing_file
->value
.s
);
4595 bdrv_get_geometry(bs
, &size
);
4598 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
4599 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
4601 error_setg(errp
, "Image creation needs a size parameter");
4607 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
4608 print_option_parameters(param
);
4611 ret
= bdrv_create(drv
, filename
, param
);
4613 if (ret
== -ENOTSUP
) {
4614 error_setg(errp
,"Formatting or formatting option not supported for "
4615 "file format '%s'", fmt
);
4616 } else if (ret
== -EFBIG
) {
4617 const char *cluster_size_hint
= "";
4618 if (get_option_parameter(create_options
, BLOCK_OPT_CLUSTER_SIZE
)) {
4619 cluster_size_hint
= " (try using a larger cluster size)";
4621 error_setg(errp
, "The image size is too large for file format '%s'%s",
4622 fmt
, cluster_size_hint
);
4624 error_setg(errp
, "%s: error while creating %s: %s", filename
, fmt
,
4630 free_option_parameters(create_options
);
4631 free_option_parameters(param
);
4638 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
4640 /* Currently BlockDriverState always uses the main loop AioContext */
4641 return qemu_get_aio_context();
4644 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
4645 NotifierWithReturn
*notifier
)
4647 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);