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 "block/qapi.h"
36 #include "qmp-commands.h"
37 #include "qemu/timer.h"
40 #include <sys/types.h>
42 #include <sys/ioctl.h>
43 #include <sys/queue.h>
53 struct BdrvDirtyBitmap
{
55 QLIST_ENTRY(BdrvDirtyBitmap
) list
;
58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
60 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
);
61 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
62 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
63 BlockDriverCompletionFunc
*cb
, void *opaque
);
64 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
65 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
66 BlockDriverCompletionFunc
*cb
, void *opaque
);
67 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
68 int64_t sector_num
, int nb_sectors
,
70 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
71 int64_t sector_num
, int nb_sectors
,
73 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
74 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
75 BdrvRequestFlags flags
);
76 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
77 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
78 BdrvRequestFlags flags
);
79 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
83 BdrvRequestFlags flags
,
84 BlockDriverCompletionFunc
*cb
,
87 static void coroutine_fn
bdrv_co_do_rw(void *opaque
);
88 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
89 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
);
91 static QTAILQ_HEAD(, BlockDriverState
) bdrv_states
=
92 QTAILQ_HEAD_INITIALIZER(bdrv_states
);
94 static QTAILQ_HEAD(, BlockDriverState
) graph_bdrv_states
=
95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states
);
97 static QLIST_HEAD(, BlockDriver
) bdrv_drivers
=
98 QLIST_HEAD_INITIALIZER(bdrv_drivers
);
100 /* If non-zero, use only whitelisted block drivers */
101 static int use_bdrv_whitelist
;
104 static int is_windows_drive_prefix(const char *filename
)
106 return (((filename
[0] >= 'a' && filename
[0] <= 'z') ||
107 (filename
[0] >= 'A' && filename
[0] <= 'Z')) &&
111 int is_windows_drive(const char *filename
)
113 if (is_windows_drive_prefix(filename
) &&
116 if (strstart(filename
, "\\\\.\\", NULL
) ||
117 strstart(filename
, "//./", NULL
))
123 /* throttling disk I/O limits */
124 void bdrv_set_io_limits(BlockDriverState
*bs
,
129 throttle_config(&bs
->throttle_state
, cfg
);
131 for (i
= 0; i
< 2; i
++) {
132 qemu_co_enter_next(&bs
->throttled_reqs
[i
]);
136 /* this function drain all the throttled IOs */
137 static bool bdrv_start_throttled_reqs(BlockDriverState
*bs
)
139 bool drained
= false;
140 bool enabled
= bs
->io_limits_enabled
;
143 bs
->io_limits_enabled
= false;
145 for (i
= 0; i
< 2; i
++) {
146 while (qemu_co_enter_next(&bs
->throttled_reqs
[i
])) {
151 bs
->io_limits_enabled
= enabled
;
156 void bdrv_io_limits_disable(BlockDriverState
*bs
)
158 bs
->io_limits_enabled
= false;
160 bdrv_start_throttled_reqs(bs
);
162 throttle_destroy(&bs
->throttle_state
);
165 static void bdrv_throttle_read_timer_cb(void *opaque
)
167 BlockDriverState
*bs
= opaque
;
168 qemu_co_enter_next(&bs
->throttled_reqs
[0]);
171 static void bdrv_throttle_write_timer_cb(void *opaque
)
173 BlockDriverState
*bs
= opaque
;
174 qemu_co_enter_next(&bs
->throttled_reqs
[1]);
177 /* should be called before bdrv_set_io_limits if a limit is set */
178 void bdrv_io_limits_enable(BlockDriverState
*bs
)
180 assert(!bs
->io_limits_enabled
);
181 throttle_init(&bs
->throttle_state
,
183 bdrv_throttle_read_timer_cb
,
184 bdrv_throttle_write_timer_cb
,
186 bs
->io_limits_enabled
= true;
189 /* This function makes an IO wait if needed
191 * @nb_sectors: the number of sectors of the IO
192 * @is_write: is the IO a write
194 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
198 /* does this io must wait */
199 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
201 /* if must wait or any request of this type throttled queue the IO */
203 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
204 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
207 /* the IO will be executed, do the accounting */
208 throttle_account(&bs
->throttle_state
,
210 nb_sectors
* BDRV_SECTOR_SIZE
);
212 /* if the next request must wait -> do nothing */
213 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
217 /* else queue next request for execution */
218 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
221 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
223 if (!bs
|| !bs
->drv
) {
224 /* 4k should be on the safe side */
228 return bs
->bl
.opt_mem_alignment
;
231 /* check if the path starts with "<protocol>:" */
232 static int path_has_protocol(const char *path
)
237 if (is_windows_drive(path
) ||
238 is_windows_drive_prefix(path
)) {
241 p
= path
+ strcspn(path
, ":/\\");
243 p
= path
+ strcspn(path
, ":/");
249 int path_is_absolute(const char *path
)
252 /* specific case for names like: "\\.\d:" */
253 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
256 return (*path
== '/' || *path
== '\\');
258 return (*path
== '/');
262 /* if filename is absolute, just copy it to dest. Otherwise, build a
263 path to it by considering it is relative to base_path. URL are
265 void path_combine(char *dest
, int dest_size
,
266 const char *base_path
,
267 const char *filename
)
274 if (path_is_absolute(filename
)) {
275 pstrcpy(dest
, dest_size
, filename
);
277 p
= strchr(base_path
, ':');
282 p1
= strrchr(base_path
, '/');
286 p2
= strrchr(base_path
, '\\');
298 if (len
> dest_size
- 1)
300 memcpy(dest
, base_path
, len
);
302 pstrcat(dest
, dest_size
, filename
);
306 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
308 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
309 pstrcpy(dest
, sz
, bs
->backing_file
);
311 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
315 void bdrv_register(BlockDriver
*bdrv
)
317 /* Block drivers without coroutine functions need emulation */
318 if (!bdrv
->bdrv_co_readv
) {
319 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
320 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
323 * the block driver lacks aio we need to emulate that too.
325 if (!bdrv
->bdrv_aio_readv
) {
326 /* add AIO emulation layer */
327 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
328 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
332 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
335 /* create a new block device (by default it is empty) */
336 BlockDriverState
*bdrv_new(const char *device_name
)
338 BlockDriverState
*bs
;
340 bs
= g_malloc0(sizeof(BlockDriverState
));
341 QLIST_INIT(&bs
->dirty_bitmaps
);
342 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
343 if (device_name
[0] != '\0') {
344 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
346 bdrv_iostatus_disable(bs
);
347 notifier_list_init(&bs
->close_notifiers
);
348 notifier_with_return_list_init(&bs
->before_write_notifiers
);
349 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
350 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
356 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
358 notifier_list_add(&bs
->close_notifiers
, notify
);
361 BlockDriver
*bdrv_find_format(const char *format_name
)
364 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
365 if (!strcmp(drv1
->format_name
, format_name
)) {
372 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
374 static const char *whitelist_rw
[] = {
375 CONFIG_BDRV_RW_WHITELIST
377 static const char *whitelist_ro
[] = {
378 CONFIG_BDRV_RO_WHITELIST
382 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
383 return 1; /* no whitelist, anything goes */
386 for (p
= whitelist_rw
; *p
; p
++) {
387 if (!strcmp(drv
->format_name
, *p
)) {
392 for (p
= whitelist_ro
; *p
; p
++) {
393 if (!strcmp(drv
->format_name
, *p
)) {
401 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
404 BlockDriver
*drv
= bdrv_find_format(format_name
);
405 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
408 typedef struct CreateCo
{
411 QEMUOptionParameter
*options
;
416 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
418 Error
*local_err
= NULL
;
421 CreateCo
*cco
= opaque
;
424 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
, &local_err
);
425 if (error_is_set(&local_err
)) {
426 error_propagate(&cco
->err
, local_err
);
431 int bdrv_create(BlockDriver
*drv
, const char* filename
,
432 QEMUOptionParameter
*options
, Error
**errp
)
439 .filename
= g_strdup(filename
),
445 if (!drv
->bdrv_create
) {
446 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
451 if (qemu_in_coroutine()) {
452 /* Fast-path if already in coroutine context */
453 bdrv_create_co_entry(&cco
);
455 co
= qemu_coroutine_create(bdrv_create_co_entry
);
456 qemu_coroutine_enter(co
, &cco
);
457 while (cco
.ret
== NOT_DONE
) {
464 if (error_is_set(&cco
.err
)) {
465 error_propagate(errp
, cco
.err
);
467 error_setg_errno(errp
, -ret
, "Could not create image");
472 g_free(cco
.filename
);
476 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
,
480 Error
*local_err
= NULL
;
483 drv
= bdrv_find_protocol(filename
, true);
485 error_setg(errp
, "Could not find protocol for file '%s'", filename
);
489 ret
= bdrv_create(drv
, filename
, options
, &local_err
);
490 if (error_is_set(&local_err
)) {
491 error_propagate(errp
, local_err
);
496 int bdrv_refresh_limits(BlockDriverState
*bs
)
498 BlockDriver
*drv
= bs
->drv
;
500 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
506 /* Take some limits from the children as a default */
508 bdrv_refresh_limits(bs
->file
);
509 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
510 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
512 bs
->bl
.opt_mem_alignment
= 512;
515 if (bs
->backing_hd
) {
516 bdrv_refresh_limits(bs
->backing_hd
);
517 bs
->bl
.opt_transfer_length
=
518 MAX(bs
->bl
.opt_transfer_length
,
519 bs
->backing_hd
->bl
.opt_transfer_length
);
520 bs
->bl
.opt_mem_alignment
=
521 MAX(bs
->bl
.opt_mem_alignment
,
522 bs
->backing_hd
->bl
.opt_mem_alignment
);
525 /* Then let the driver override it */
526 if (drv
->bdrv_refresh_limits
) {
527 return drv
->bdrv_refresh_limits(bs
);
534 * Create a uniquely-named empty temporary file.
535 * Return 0 upon success, otherwise a negative errno value.
537 int get_tmp_filename(char *filename
, int size
)
540 char temp_dir
[MAX_PATH
];
541 /* GetTempFileName requires that its output buffer (4th param)
542 have length MAX_PATH or greater. */
543 assert(size
>= MAX_PATH
);
544 return (GetTempPath(MAX_PATH
, temp_dir
)
545 && GetTempFileName(temp_dir
, "qem", 0, filename
)
546 ? 0 : -GetLastError());
550 tmpdir
= getenv("TMPDIR");
553 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
556 fd
= mkstemp(filename
);
560 if (close(fd
) != 0) {
569 * Detect host devices. By convention, /dev/cdrom[N] is always
570 * recognized as a host CDROM.
572 static BlockDriver
*find_hdev_driver(const char *filename
)
574 int score_max
= 0, score
;
575 BlockDriver
*drv
= NULL
, *d
;
577 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
578 if (d
->bdrv_probe_device
) {
579 score
= d
->bdrv_probe_device(filename
);
580 if (score
> score_max
) {
590 BlockDriver
*bdrv_find_protocol(const char *filename
,
591 bool allow_protocol_prefix
)
598 /* TODO Drivers without bdrv_file_open must be specified explicitly */
601 * XXX(hch): we really should not let host device detection
602 * override an explicit protocol specification, but moving this
603 * later breaks access to device names with colons in them.
604 * Thanks to the brain-dead persistent naming schemes on udev-
605 * based Linux systems those actually are quite common.
607 drv1
= find_hdev_driver(filename
);
612 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
613 return bdrv_find_format("file");
616 p
= strchr(filename
, ':');
619 if (len
> sizeof(protocol
) - 1)
620 len
= sizeof(protocol
) - 1;
621 memcpy(protocol
, filename
, len
);
622 protocol
[len
] = '\0';
623 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
624 if (drv1
->protocol_name
&&
625 !strcmp(drv1
->protocol_name
, protocol
)) {
632 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
633 BlockDriver
**pdrv
, Error
**errp
)
635 int score
, score_max
;
636 BlockDriver
*drv1
, *drv
;
640 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
641 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
642 drv
= bdrv_find_format("raw");
644 error_setg(errp
, "Could not find raw image format");
651 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
653 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
661 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
662 if (drv1
->bdrv_probe
) {
663 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
664 if (score
> score_max
) {
671 error_setg(errp
, "Could not determine image format: No compatible "
680 * Set the current 'total_sectors' value
682 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
684 BlockDriver
*drv
= bs
->drv
;
686 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
690 /* query actual device if possible, otherwise just trust the hint */
691 if (drv
->bdrv_getlength
) {
692 int64_t length
= drv
->bdrv_getlength(bs
);
696 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
699 bs
->total_sectors
= hint
;
704 * Set open flags for a given discard mode
706 * Return 0 on success, -1 if the discard mode was invalid.
708 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
710 *flags
&= ~BDRV_O_UNMAP
;
712 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
714 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
715 *flags
|= BDRV_O_UNMAP
;
724 * Set open flags for a given cache mode
726 * Return 0 on success, -1 if the cache mode was invalid.
728 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
730 *flags
&= ~BDRV_O_CACHE_MASK
;
732 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
733 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
734 } else if (!strcmp(mode
, "directsync")) {
735 *flags
|= BDRV_O_NOCACHE
;
736 } else if (!strcmp(mode
, "writeback")) {
737 *flags
|= BDRV_O_CACHE_WB
;
738 } else if (!strcmp(mode
, "unsafe")) {
739 *flags
|= BDRV_O_CACHE_WB
;
740 *flags
|= BDRV_O_NO_FLUSH
;
741 } else if (!strcmp(mode
, "writethrough")) {
742 /* this is the default */
751 * The copy-on-read flag is actually a reference count so multiple users may
752 * use the feature without worrying about clobbering its previous state.
753 * Copy-on-read stays enabled until all users have called to disable it.
755 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
760 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
762 assert(bs
->copy_on_read
> 0);
766 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
768 int open_flags
= flags
| BDRV_O_CACHE_WB
;
771 * Clear flags that are internal to the block layer before opening the
774 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
777 * Snapshots should be writable.
779 if (bs
->is_temporary
) {
780 open_flags
|= BDRV_O_RDWR
;
786 static int bdrv_assign_node_name(BlockDriverState
*bs
,
787 const char *node_name
,
794 /* empty string node name is invalid */
795 if (node_name
[0] == '\0') {
796 error_setg(errp
, "Empty node name");
800 /* takes care of avoiding duplicates node names */
801 if (bdrv_find_node(node_name
)) {
802 error_setg(errp
, "Duplicate node name");
806 /* copy node name into the bs and insert it into the graph list */
807 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
808 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
814 * Common part for opening disk images and files
816 * Removes all processed options from *options.
818 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
819 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
822 const char *filename
;
823 const char *node_name
= NULL
;
824 Error
*local_err
= NULL
;
827 assert(bs
->file
== NULL
);
828 assert(options
!= NULL
&& bs
->options
!= options
);
831 filename
= file
->filename
;
833 filename
= qdict_get_try_str(options
, "filename");
836 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
838 node_name
= qdict_get_try_str(options
, "node-name");
839 ret
= bdrv_assign_node_name(bs
, node_name
, errp
);
843 qdict_del(options
, "node-name");
845 /* bdrv_open() with directly using a protocol as drv. This layer is already
846 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
847 * and return immediately. */
848 if (file
!= NULL
&& drv
->bdrv_file_open
) {
853 bs
->open_flags
= flags
;
854 bs
->guest_block_size
= 512;
855 bs
->request_alignment
= 512;
856 bs
->zero_beyond_eof
= true;
857 open_flags
= bdrv_open_flags(bs
, flags
);
858 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
860 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
862 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
863 ? "Driver '%s' can only be used for read-only devices"
864 : "Driver '%s' is not whitelisted",
869 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
870 if (flags
& BDRV_O_COPY_ON_READ
) {
871 if (!bs
->read_only
) {
872 bdrv_enable_copy_on_read(bs
);
874 error_setg(errp
, "Can't use copy-on-read on read-only device");
879 if (filename
!= NULL
) {
880 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
882 bs
->filename
[0] = '\0';
886 bs
->opaque
= g_malloc0(drv
->instance_size
);
888 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
890 /* Open the image, either directly or using a protocol */
891 if (drv
->bdrv_file_open
) {
892 assert(file
== NULL
);
893 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
894 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
897 error_setg(errp
, "Can't use '%s' as a block driver for the "
898 "protocol level", drv
->format_name
);
903 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
907 if (error_is_set(&local_err
)) {
908 error_propagate(errp
, local_err
);
909 } else if (bs
->filename
[0]) {
910 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
912 error_setg_errno(errp
, -ret
, "Could not open image");
917 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
919 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
923 bdrv_refresh_limits(bs
);
924 assert(bdrv_opt_mem_align(bs
) != 0);
925 assert(bs
->request_alignment
!= 0);
928 if (bs
->is_temporary
) {
929 assert(bs
->filename
[0] != '\0');
930 unlink(bs
->filename
);
944 * Opens a file using a protocol (file, host_device, nbd, ...)
946 * options is a QDict of options to pass to the block drivers, or NULL for an
947 * empty set of options. The reference to the QDict belongs to the block layer
948 * after the call (even on failure), so if the caller intends to reuse the
949 * dictionary, it needs to use QINCREF() before calling bdrv_file_open.
951 int bdrv_file_open(BlockDriverState
**pbs
, const char *filename
,
952 const char *reference
, QDict
*options
, int flags
,
955 BlockDriverState
*bs
= NULL
;
958 bool allow_protocol_prefix
= false;
959 Error
*local_err
= NULL
;
962 /* NULL means an empty set of options */
963 if (options
== NULL
) {
964 options
= qdict_new();
968 if (filename
|| qdict_size(options
)) {
969 error_setg(errp
, "Cannot reference an existing block device with "
970 "additional options or a new filename");
975 bs
= bdrv_find(reference
);
977 error_setg(errp
, "Cannot find block device '%s'", reference
);
986 bs
->options
= options
;
987 options
= qdict_clone_shallow(options
);
989 /* Fetch the file name from the options QDict if necessary */
991 filename
= qdict_get_try_str(options
, "filename");
992 } else if (filename
&& !qdict_haskey(options
, "filename")) {
993 qdict_put(options
, "filename", qstring_from_str(filename
));
994 allow_protocol_prefix
= true;
996 error_setg(errp
, "Can't specify 'file' and 'filename' options at the "
1002 /* Find the right block driver */
1003 drvname
= qdict_get_try_str(options
, "driver");
1005 drv
= bdrv_find_format(drvname
);
1007 error_setg(errp
, "Unknown driver '%s'", drvname
);
1009 qdict_del(options
, "driver");
1010 } else if (filename
) {
1011 drv
= bdrv_find_protocol(filename
, allow_protocol_prefix
);
1013 error_setg(errp
, "Unknown protocol");
1016 error_setg(errp
, "Must specify either driver or file");
1021 /* errp has been set already */
1026 /* Parse the filename and open it */
1027 if (drv
->bdrv_parse_filename
&& filename
) {
1028 drv
->bdrv_parse_filename(filename
, options
, &local_err
);
1029 if (error_is_set(&local_err
)) {
1030 error_propagate(errp
, local_err
);
1034 qdict_del(options
, "filename");
1035 } else if (drv
->bdrv_needs_filename
&& !filename
) {
1036 error_setg(errp
, "The '%s' block driver requires a file name",
1042 if (!drv
->bdrv_file_open
) {
1043 ret
= bdrv_open(bs
, filename
, options
, flags
, drv
, &local_err
);
1046 ret
= bdrv_open_common(bs
, NULL
, options
, flags
, drv
, &local_err
);
1049 error_propagate(errp
, local_err
);
1053 /* Check if any unknown options were used */
1054 if (options
&& (qdict_size(options
) != 0)) {
1055 const QDictEntry
*entry
= qdict_first(options
);
1056 error_setg(errp
, "Block protocol '%s' doesn't support the option '%s'",
1057 drv
->format_name
, entry
->key
);
1070 QDECREF(bs
->options
);
1077 * Opens the backing file for a BlockDriverState if not yet open
1079 * options is a QDict of options to pass to the block drivers, or NULL for an
1080 * empty set of options. The reference to the QDict is transferred to this
1081 * function (even on failure), so if the caller intends to reuse the dictionary,
1082 * it needs to use QINCREF() before calling bdrv_file_open.
1084 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1086 char backing_filename
[PATH_MAX
];
1087 int back_flags
, ret
;
1088 BlockDriver
*back_drv
= NULL
;
1089 Error
*local_err
= NULL
;
1091 if (bs
->backing_hd
!= NULL
) {
1096 /* NULL means an empty set of options */
1097 if (options
== NULL
) {
1098 options
= qdict_new();
1101 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1102 if (qdict_haskey(options
, "file.filename")) {
1103 backing_filename
[0] = '\0';
1104 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1108 bdrv_get_full_backing_filename(bs
, backing_filename
,
1109 sizeof(backing_filename
));
1112 bs
->backing_hd
= bdrv_new("");
1114 if (bs
->backing_format
[0] != '\0') {
1115 back_drv
= bdrv_find_format(bs
->backing_format
);
1118 /* backing files always opened read-only */
1119 back_flags
= bs
->open_flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
|
1120 BDRV_O_COPY_ON_READ
);
1122 ret
= bdrv_open(bs
->backing_hd
,
1123 *backing_filename
? backing_filename
: NULL
, options
,
1124 back_flags
, back_drv
, &local_err
);
1126 bdrv_unref(bs
->backing_hd
);
1127 bs
->backing_hd
= NULL
;
1128 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1129 error_setg(errp
, "Could not open backing file: %s",
1130 error_get_pretty(local_err
));
1131 error_free(local_err
);
1135 if (bs
->backing_hd
->file
) {
1136 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
),
1137 bs
->backing_hd
->file
->filename
);
1140 /* Recalculate the BlockLimits with the backing file */
1141 bdrv_refresh_limits(bs
);
1147 * Opens a disk image whose options are given as BlockdevRef in another block
1150 * If force_raw is true, bdrv_file_open() will be used, thereby preventing any
1151 * image format auto-detection. If it is false and a filename is given,
1152 * bdrv_open() will be used for auto-detection.
1154 * If allow_none is true, no image will be opened if filename is false and no
1155 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1157 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1158 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1159 * itself, all options starting with "${bdref_key}." are considered part of the
1162 * The BlockdevRef will be removed from the options QDict.
1164 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1165 QDict
*options
, const char *bdref_key
, int flags
,
1166 bool force_raw
, bool allow_none
, Error
**errp
)
1168 QDict
*image_options
;
1170 char *bdref_key_dot
;
1171 const char *reference
;
1173 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1174 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1175 g_free(bdref_key_dot
);
1177 reference
= qdict_get_try_str(options
, bdref_key
);
1178 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1182 error_setg(errp
, "A block device must be specified for \"%s\"",
1189 if (filename
&& !force_raw
) {
1190 /* If a filename is given and the block driver should be detected
1191 automatically (instead of using none), use bdrv_open() in order to do
1192 that auto-detection. */
1193 BlockDriverState
*bs
;
1196 error_setg(errp
, "Cannot reference an existing block device while "
1197 "giving a filename");
1203 ret
= bdrv_open(bs
, filename
, image_options
, flags
, NULL
, errp
);
1210 ret
= bdrv_file_open(pbs
, filename
, reference
, image_options
, flags
,
1215 qdict_del(options
, bdref_key
);
1220 * Opens a disk image (raw, qcow2, vmdk, ...)
1222 * options is a QDict of options to pass to the block drivers, or NULL for an
1223 * empty set of options. The reference to the QDict belongs to the block layer
1224 * after the call (even on failure), so if the caller intends to reuse the
1225 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1227 int bdrv_open(BlockDriverState
*bs
, const char *filename
, QDict
*options
,
1228 int flags
, BlockDriver
*drv
, Error
**errp
)
1231 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1232 char tmp_filename
[PATH_MAX
+ 1];
1233 BlockDriverState
*file
= NULL
;
1234 const char *drvname
;
1235 Error
*local_err
= NULL
;
1237 /* NULL means an empty set of options */
1238 if (options
== NULL
) {
1239 options
= qdict_new();
1242 bs
->options
= options
;
1243 options
= qdict_clone_shallow(options
);
1245 /* For snapshot=on, create a temporary qcow2 overlay */
1246 if (flags
& BDRV_O_SNAPSHOT
) {
1247 BlockDriverState
*bs1
;
1249 BlockDriver
*bdrv_qcow2
;
1250 QEMUOptionParameter
*create_options
;
1251 QDict
*snapshot_options
;
1253 /* if snapshot, we create a temporary backing file and open it
1254 instead of opening 'filename' directly */
1256 /* Get the required size from the image */
1259 ret
= bdrv_open(bs1
, filename
, options
, BDRV_O_NO_BACKING
,
1265 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
1269 /* Create the temporary image */
1270 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
1272 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1276 bdrv_qcow2
= bdrv_find_format("qcow2");
1277 create_options
= parse_option_parameters("", bdrv_qcow2
->create_options
,
1280 set_option_parameter_int(create_options
, BLOCK_OPT_SIZE
, total_size
);
1282 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, create_options
, &local_err
);
1283 free_option_parameters(create_options
);
1285 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1286 "'%s': %s", tmp_filename
,
1287 error_get_pretty(local_err
));
1288 error_free(local_err
);
1293 /* Prepare a new options QDict for the temporary file, where user
1294 * options refer to the backing file */
1296 qdict_put(options
, "file.filename", qstring_from_str(filename
));
1299 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1302 snapshot_options
= qdict_new();
1303 qdict_put(snapshot_options
, "backing", options
);
1304 qdict_flatten(snapshot_options
);
1306 bs
->options
= snapshot_options
;
1307 options
= qdict_clone_shallow(bs
->options
);
1309 filename
= tmp_filename
;
1311 bs
->is_temporary
= 1;
1314 /* Open image file without format layer */
1315 if (flags
& BDRV_O_RDWR
) {
1316 flags
|= BDRV_O_ALLOW_RDWR
;
1319 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1320 bdrv_open_flags(bs
, flags
| BDRV_O_UNMAP
), true, true,
1326 /* Find the right image format driver */
1327 drvname
= qdict_get_try_str(options
, "driver");
1329 drv
= bdrv_find_format(drvname
);
1330 qdict_del(options
, "driver");
1332 error_setg(errp
, "Invalid driver: '%s'", drvname
);
1334 goto unlink_and_fail
;
1340 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1342 error_setg(errp
, "Must specify either driver or file");
1344 goto unlink_and_fail
;
1349 goto unlink_and_fail
;
1352 /* Open the image */
1353 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1355 goto unlink_and_fail
;
1358 if (file
&& (bs
->file
!= file
)) {
1363 /* If there is a backing file, use it */
1364 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1365 QDict
*backing_options
;
1367 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1368 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1370 goto close_and_fail
;
1374 /* Check if any unknown options were used */
1375 if (qdict_size(options
) != 0) {
1376 const QDictEntry
*entry
= qdict_first(options
);
1377 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1378 "support the option '%s'", drv
->format_name
, bs
->device_name
,
1382 goto close_and_fail
;
1386 if (!bdrv_key_required(bs
)) {
1387 bdrv_dev_change_media_cb(bs
, true);
1396 if (bs
->is_temporary
) {
1400 QDECREF(bs
->options
);
1403 if (error_is_set(&local_err
)) {
1404 error_propagate(errp
, local_err
);
1411 if (error_is_set(&local_err
)) {
1412 error_propagate(errp
, local_err
);
1417 typedef struct BlockReopenQueueEntry
{
1419 BDRVReopenState state
;
1420 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1421 } BlockReopenQueueEntry
;
1424 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1425 * reopen of multiple devices.
1427 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1428 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1429 * be created and initialized. This newly created BlockReopenQueue should be
1430 * passed back in for subsequent calls that are intended to be of the same
1433 * bs is the BlockDriverState to add to the reopen queue.
1435 * flags contains the open flags for the associated bs
1437 * returns a pointer to bs_queue, which is either the newly allocated
1438 * bs_queue, or the existing bs_queue being used.
1441 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1442 BlockDriverState
*bs
, int flags
)
1446 BlockReopenQueueEntry
*bs_entry
;
1447 if (bs_queue
== NULL
) {
1448 bs_queue
= g_new0(BlockReopenQueue
, 1);
1449 QSIMPLEQ_INIT(bs_queue
);
1453 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
1456 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1457 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1459 bs_entry
->state
.bs
= bs
;
1460 bs_entry
->state
.flags
= flags
;
1466 * Reopen multiple BlockDriverStates atomically & transactionally.
1468 * The queue passed in (bs_queue) must have been built up previous
1469 * via bdrv_reopen_queue().
1471 * Reopens all BDS specified in the queue, with the appropriate
1472 * flags. All devices are prepared for reopen, and failure of any
1473 * device will cause all device changes to be abandonded, and intermediate
1476 * If all devices prepare successfully, then the changes are committed
1480 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1483 BlockReopenQueueEntry
*bs_entry
, *next
;
1484 Error
*local_err
= NULL
;
1486 assert(bs_queue
!= NULL
);
1490 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1491 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1492 error_propagate(errp
, local_err
);
1495 bs_entry
->prepared
= true;
1498 /* If we reach this point, we have success and just need to apply the
1501 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1502 bdrv_reopen_commit(&bs_entry
->state
);
1508 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1509 if (ret
&& bs_entry
->prepared
) {
1510 bdrv_reopen_abort(&bs_entry
->state
);
1519 /* Reopen a single BlockDriverState with the specified flags. */
1520 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1523 Error
*local_err
= NULL
;
1524 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1526 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1527 if (local_err
!= NULL
) {
1528 error_propagate(errp
, local_err
);
1535 * Prepares a BlockDriverState for reopen. All changes are staged in the
1536 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1537 * the block driver layer .bdrv_reopen_prepare()
1539 * bs is the BlockDriverState to reopen
1540 * flags are the new open flags
1541 * queue is the reopen queue
1543 * Returns 0 on success, non-zero on error. On error errp will be set
1546 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1547 * It is the responsibility of the caller to then call the abort() or
1548 * commit() for any other BDS that have been left in a prepare() state
1551 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1555 Error
*local_err
= NULL
;
1558 assert(reopen_state
!= NULL
);
1559 assert(reopen_state
->bs
->drv
!= NULL
);
1560 drv
= reopen_state
->bs
->drv
;
1562 /* if we are to stay read-only, do not allow permission change
1564 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1565 reopen_state
->flags
& BDRV_O_RDWR
) {
1566 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1567 reopen_state
->bs
->device_name
);
1572 ret
= bdrv_flush(reopen_state
->bs
);
1574 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1579 if (drv
->bdrv_reopen_prepare
) {
1580 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1582 if (local_err
!= NULL
) {
1583 error_propagate(errp
, local_err
);
1585 error_setg(errp
, "failed while preparing to reopen image '%s'",
1586 reopen_state
->bs
->filename
);
1591 /* It is currently mandatory to have a bdrv_reopen_prepare()
1592 * handler for each supported drv. */
1593 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1594 drv
->format_name
, reopen_state
->bs
->device_name
,
1595 "reopening of file");
1607 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1608 * makes them final by swapping the staging BlockDriverState contents into
1609 * the active BlockDriverState contents.
1611 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1615 assert(reopen_state
!= NULL
);
1616 drv
= reopen_state
->bs
->drv
;
1617 assert(drv
!= NULL
);
1619 /* If there are any driver level actions to take */
1620 if (drv
->bdrv_reopen_commit
) {
1621 drv
->bdrv_reopen_commit(reopen_state
);
1624 /* set BDS specific flags now */
1625 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1626 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1628 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1630 bdrv_refresh_limits(reopen_state
->bs
);
1634 * Abort the reopen, and delete and free the staged changes in
1637 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1641 assert(reopen_state
!= NULL
);
1642 drv
= reopen_state
->bs
->drv
;
1643 assert(drv
!= NULL
);
1645 if (drv
->bdrv_reopen_abort
) {
1646 drv
->bdrv_reopen_abort(reopen_state
);
1651 void bdrv_close(BlockDriverState
*bs
)
1654 block_job_cancel_sync(bs
->job
);
1656 bdrv_drain_all(); /* complete I/O */
1658 bdrv_drain_all(); /* in case flush left pending I/O */
1659 notifier_list_notify(&bs
->close_notifiers
, bs
);
1662 if (bs
->backing_hd
) {
1663 bdrv_unref(bs
->backing_hd
);
1664 bs
->backing_hd
= NULL
;
1666 bs
->drv
->bdrv_close(bs
);
1669 if (bs
->is_temporary
) {
1670 unlink(bs
->filename
);
1675 bs
->copy_on_read
= 0;
1676 bs
->backing_file
[0] = '\0';
1677 bs
->backing_format
[0] = '\0';
1678 bs
->total_sectors
= 0;
1683 bs
->zero_beyond_eof
= false;
1684 QDECREF(bs
->options
);
1687 if (bs
->file
!= NULL
) {
1688 bdrv_unref(bs
->file
);
1693 bdrv_dev_change_media_cb(bs
, false);
1695 /*throttling disk I/O limits*/
1696 if (bs
->io_limits_enabled
) {
1697 bdrv_io_limits_disable(bs
);
1701 void bdrv_close_all(void)
1703 BlockDriverState
*bs
;
1705 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1710 /* Check if any requests are in-flight (including throttled requests) */
1711 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1713 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1716 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1719 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1722 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1725 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1731 static bool bdrv_requests_pending_all(void)
1733 BlockDriverState
*bs
;
1734 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1735 if (bdrv_requests_pending(bs
)) {
1743 * Wait for pending requests to complete across all BlockDriverStates
1745 * This function does not flush data to disk, use bdrv_flush_all() for that
1746 * after calling this function.
1748 * Note that completion of an asynchronous I/O operation can trigger any
1749 * number of other I/O operations on other devices---for example a coroutine
1750 * can be arbitrarily complex and a constant flow of I/O can come until the
1751 * coroutine is complete. Because of this, it is not possible to have a
1752 * function to drain a single device's I/O queue.
1754 void bdrv_drain_all(void)
1756 /* Always run first iteration so any pending completion BHs run */
1758 BlockDriverState
*bs
;
1761 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1762 bdrv_start_throttled_reqs(bs
);
1765 busy
= bdrv_requests_pending_all();
1766 busy
|= aio_poll(qemu_get_aio_context(), busy
);
1770 /* make a BlockDriverState anonymous by removing from bdrv_state and
1771 * graph_bdrv_state list.
1772 Also, NULL terminate the device_name to prevent double remove */
1773 void bdrv_make_anon(BlockDriverState
*bs
)
1775 if (bs
->device_name
[0] != '\0') {
1776 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1778 bs
->device_name
[0] = '\0';
1779 if (bs
->node_name
[0] != '\0') {
1780 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1782 bs
->node_name
[0] = '\0';
1785 static void bdrv_rebind(BlockDriverState
*bs
)
1787 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1788 bs
->drv
->bdrv_rebind(bs
);
1792 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1793 BlockDriverState
*bs_src
)
1795 /* move some fields that need to stay attached to the device */
1796 bs_dest
->open_flags
= bs_src
->open_flags
;
1799 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1800 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1801 bs_dest
->dev
= bs_src
->dev
;
1802 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1803 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1805 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1807 /* i/o throttled req */
1808 memcpy(&bs_dest
->throttle_state
,
1809 &bs_src
->throttle_state
,
1810 sizeof(ThrottleState
));
1811 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1812 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1813 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1816 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1817 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1820 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1821 bs_dest
->iostatus
= bs_src
->iostatus
;
1824 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1826 /* reference count */
1827 bs_dest
->refcnt
= bs_src
->refcnt
;
1830 bs_dest
->in_use
= bs_src
->in_use
;
1831 bs_dest
->job
= bs_src
->job
;
1833 /* keep the same entry in bdrv_states */
1834 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1835 bs_src
->device_name
);
1836 bs_dest
->device_list
= bs_src
->device_list
;
1838 /* keep the same entry in graph_bdrv_states
1839 * We do want to swap name but don't want to swap linked list entries
1841 bs_dest
->node_list
= bs_src
->node_list
;
1845 * Swap bs contents for two image chains while they are live,
1846 * while keeping required fields on the BlockDriverState that is
1847 * actually attached to a device.
1849 * This will modify the BlockDriverState fields, and swap contents
1850 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1852 * bs_new is required to be anonymous.
1854 * This function does not create any image files.
1856 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1858 BlockDriverState tmp
;
1860 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1861 assert(bs_new
->device_name
[0] == '\0');
1862 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
1863 assert(bs_new
->job
== NULL
);
1864 assert(bs_new
->dev
== NULL
);
1865 assert(bs_new
->in_use
== 0);
1866 assert(bs_new
->io_limits_enabled
== false);
1867 assert(!throttle_have_timer(&bs_new
->throttle_state
));
1873 /* there are some fields that should not be swapped, move them back */
1874 bdrv_move_feature_fields(&tmp
, bs_old
);
1875 bdrv_move_feature_fields(bs_old
, bs_new
);
1876 bdrv_move_feature_fields(bs_new
, &tmp
);
1878 /* bs_new shouldn't be in bdrv_states even after the swap! */
1879 assert(bs_new
->device_name
[0] == '\0');
1881 /* Check a few fields that should remain attached to the device */
1882 assert(bs_new
->dev
== NULL
);
1883 assert(bs_new
->job
== NULL
);
1884 assert(bs_new
->in_use
== 0);
1885 assert(bs_new
->io_limits_enabled
== false);
1886 assert(!throttle_have_timer(&bs_new
->throttle_state
));
1888 bdrv_rebind(bs_new
);
1889 bdrv_rebind(bs_old
);
1893 * Add new bs contents at the top of an image chain while the chain is
1894 * live, while keeping required fields on the top layer.
1896 * This will modify the BlockDriverState fields, and swap contents
1897 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1899 * bs_new is required to be anonymous.
1901 * This function does not create any image files.
1903 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1905 bdrv_swap(bs_new
, bs_top
);
1907 /* The contents of 'tmp' will become bs_top, as we are
1908 * swapping bs_new and bs_top contents. */
1909 bs_top
->backing_hd
= bs_new
;
1910 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1911 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1913 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1914 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1917 static void bdrv_delete(BlockDriverState
*bs
)
1921 assert(!bs
->in_use
);
1922 assert(!bs
->refcnt
);
1923 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
1927 /* remove from list, if necessary */
1933 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1934 /* TODO change to DeviceState *dev when all users are qdevified */
1940 bdrv_iostatus_reset(bs
);
1944 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1945 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1947 if (bdrv_attach_dev(bs
, dev
) < 0) {
1952 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1953 /* TODO change to DeviceState *dev when all users are qdevified */
1955 assert(bs
->dev
== dev
);
1958 bs
->dev_opaque
= NULL
;
1959 bs
->guest_block_size
= 512;
1962 /* TODO change to return DeviceState * when all users are qdevified */
1963 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1968 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
1972 bs
->dev_opaque
= opaque
;
1975 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
1976 enum MonitorEvent ev
,
1977 BlockErrorAction action
, bool is_read
)
1980 const char *action_str
;
1983 case BDRV_ACTION_REPORT
:
1984 action_str
= "report";
1986 case BDRV_ACTION_IGNORE
:
1987 action_str
= "ignore";
1989 case BDRV_ACTION_STOP
:
1990 action_str
= "stop";
1996 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1999 is_read
? "read" : "write");
2000 monitor_protocol_event(ev
, data
);
2002 qobject_decref(data
);
2005 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
2009 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2010 bdrv_get_device_name(bs
), ejected
);
2011 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
2013 qobject_decref(data
);
2016 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
2018 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
2019 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
2020 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
2021 if (tray_was_closed
) {
2023 bdrv_emit_qmp_eject_event(bs
, true);
2027 bdrv_emit_qmp_eject_event(bs
, false);
2032 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
2034 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
2037 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
2039 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
2040 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
2044 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
2046 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
2047 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
2052 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
2054 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
2055 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
2059 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
2061 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
2062 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
2068 * Run consistency checks on an image
2070 * Returns 0 if the check could be completed (it doesn't mean that the image is
2071 * free of errors) or -errno when an internal error occurred. The results of the
2072 * check are stored in res.
2074 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2076 if (bs
->drv
->bdrv_check
== NULL
) {
2080 memset(res
, 0, sizeof(*res
));
2081 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2084 #define COMMIT_BUF_SECTORS 2048
2086 /* commit COW file into the raw image */
2087 int bdrv_commit(BlockDriverState
*bs
)
2089 BlockDriver
*drv
= bs
->drv
;
2090 int64_t sector
, total_sectors
, length
, backing_length
;
2091 int n
, ro
, open_flags
;
2093 uint8_t *buf
= NULL
;
2094 char filename
[PATH_MAX
];
2099 if (!bs
->backing_hd
) {
2103 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
2107 ro
= bs
->backing_hd
->read_only
;
2108 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2109 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
2110 open_flags
= bs
->backing_hd
->open_flags
;
2113 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2118 length
= bdrv_getlength(bs
);
2124 backing_length
= bdrv_getlength(bs
->backing_hd
);
2125 if (backing_length
< 0) {
2126 ret
= backing_length
;
2130 /* If our top snapshot is larger than the backing file image,
2131 * grow the backing file image if possible. If not possible,
2132 * we must return an error */
2133 if (length
> backing_length
) {
2134 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2140 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2141 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2143 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2144 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2149 ret
= bdrv_read(bs
, sector
, buf
, n
);
2154 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2161 if (drv
->bdrv_make_empty
) {
2162 ret
= drv
->bdrv_make_empty(bs
);
2170 * Make sure all data we wrote to the backing device is actually
2173 if (bs
->backing_hd
) {
2174 bdrv_flush(bs
->backing_hd
);
2182 /* ignoring error return here */
2183 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2189 int bdrv_commit_all(void)
2191 BlockDriverState
*bs
;
2193 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2194 if (bs
->drv
&& bs
->backing_hd
) {
2195 int ret
= bdrv_commit(bs
);
2205 * Remove an active request from the tracked requests list
2207 * This function should be called when a tracked request is completing.
2209 static void tracked_request_end(BdrvTrackedRequest
*req
)
2211 if (req
->serialising
) {
2212 req
->bs
->serialising_in_flight
--;
2215 QLIST_REMOVE(req
, list
);
2216 qemu_co_queue_restart_all(&req
->wait_queue
);
2220 * Add an active request to the tracked requests list
2222 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2223 BlockDriverState
*bs
,
2225 unsigned int bytes
, bool is_write
)
2227 *req
= (BdrvTrackedRequest
){
2231 .is_write
= is_write
,
2232 .co
= qemu_coroutine_self(),
2233 .serialising
= false,
2234 .overlap_offset
= offset
,
2235 .overlap_bytes
= bytes
,
2238 qemu_co_queue_init(&req
->wait_queue
);
2240 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2243 static void mark_request_serialising(BdrvTrackedRequest
*req
, size_t align
)
2245 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2246 int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2249 if (!req
->serialising
) {
2250 req
->bs
->serialising_in_flight
++;
2251 req
->serialising
= true;
2254 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2255 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2259 * Round a region to cluster boundaries
2261 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2262 int64_t sector_num
, int nb_sectors
,
2263 int64_t *cluster_sector_num
,
2264 int *cluster_nb_sectors
)
2266 BlockDriverInfo bdi
;
2268 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2269 *cluster_sector_num
= sector_num
;
2270 *cluster_nb_sectors
= nb_sectors
;
2272 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2273 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2274 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2279 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2281 BlockDriverInfo bdi
;
2284 ret
= bdrv_get_info(bs
, &bdi
);
2285 if (ret
< 0 || bdi
.cluster_size
== 0) {
2286 return bs
->request_alignment
;
2288 return bdi
.cluster_size
;
2292 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2293 int64_t offset
, unsigned int bytes
)
2296 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2300 if (req
->overlap_offset
>= offset
+ bytes
) {
2306 static void coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2308 BlockDriverState
*bs
= self
->bs
;
2309 BdrvTrackedRequest
*req
;
2312 if (!bs
->serialising_in_flight
) {
2318 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2319 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2322 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2323 self
->overlap_bytes
))
2325 /* Hitting this means there was a reentrant request, for
2326 * example, a block driver issuing nested requests. This must
2327 * never happen since it means deadlock.
2329 assert(qemu_coroutine_self() != req
->co
);
2331 /* If the request is already (indirectly) waiting for us, or
2332 * will wait for us as soon as it wakes up, then just go on
2333 * (instead of producing a deadlock in the former case). */
2334 if (!req
->waiting_for
) {
2335 self
->waiting_for
= req
;
2336 qemu_co_queue_wait(&req
->wait_queue
);
2337 self
->waiting_for
= NULL
;
2349 * -EINVAL - backing format specified, but no file
2350 * -ENOSPC - can't update the backing file because no space is left in the
2352 * -ENOTSUP - format driver doesn't support changing the backing file
2354 int bdrv_change_backing_file(BlockDriverState
*bs
,
2355 const char *backing_file
, const char *backing_fmt
)
2357 BlockDriver
*drv
= bs
->drv
;
2360 /* Backing file format doesn't make sense without a backing file */
2361 if (backing_fmt
&& !backing_file
) {
2365 if (drv
->bdrv_change_backing_file
!= NULL
) {
2366 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2372 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2373 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2379 * Finds the image layer in the chain that has 'bs' as its backing file.
2381 * active is the current topmost image.
2383 * Returns NULL if bs is not found in active's image chain,
2384 * or if active == bs.
2386 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2387 BlockDriverState
*bs
)
2389 BlockDriverState
*overlay
= NULL
;
2390 BlockDriverState
*intermediate
;
2392 assert(active
!= NULL
);
2395 /* if bs is the same as active, then by definition it has no overlay
2401 intermediate
= active
;
2402 while (intermediate
->backing_hd
) {
2403 if (intermediate
->backing_hd
== bs
) {
2404 overlay
= intermediate
;
2407 intermediate
= intermediate
->backing_hd
;
2413 typedef struct BlkIntermediateStates
{
2414 BlockDriverState
*bs
;
2415 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2416 } BlkIntermediateStates
;
2420 * Drops images above 'base' up to and including 'top', and sets the image
2421 * above 'top' to have base as its backing file.
2423 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2424 * information in 'bs' can be properly updated.
2426 * E.g., this will convert the following chain:
2427 * bottom <- base <- intermediate <- top <- active
2431 * bottom <- base <- active
2433 * It is allowed for bottom==base, in which case it converts:
2435 * base <- intermediate <- top <- active
2442 * if active == top, that is considered an error
2445 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2446 BlockDriverState
*base
)
2448 BlockDriverState
*intermediate
;
2449 BlockDriverState
*base_bs
= NULL
;
2450 BlockDriverState
*new_top_bs
= NULL
;
2451 BlkIntermediateStates
*intermediate_state
, *next
;
2454 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2455 QSIMPLEQ_INIT(&states_to_delete
);
2457 if (!top
->drv
|| !base
->drv
) {
2461 new_top_bs
= bdrv_find_overlay(active
, top
);
2463 if (new_top_bs
== NULL
) {
2464 /* we could not find the image above 'top', this is an error */
2468 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2469 * to do, no intermediate images */
2470 if (new_top_bs
->backing_hd
== base
) {
2477 /* now we will go down through the list, and add each BDS we find
2478 * into our deletion queue, until we hit the 'base'
2480 while (intermediate
) {
2481 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
2482 intermediate_state
->bs
= intermediate
;
2483 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2485 if (intermediate
->backing_hd
== base
) {
2486 base_bs
= intermediate
->backing_hd
;
2489 intermediate
= intermediate
->backing_hd
;
2491 if (base_bs
== NULL
) {
2492 /* something went wrong, we did not end at the base. safely
2493 * unravel everything, and exit with error */
2497 /* success - we can delete the intermediate states, and link top->base */
2498 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
2499 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2503 new_top_bs
->backing_hd
= base_bs
;
2505 bdrv_refresh_limits(new_top_bs
);
2507 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2508 /* so that bdrv_close() does not recursively close the chain */
2509 intermediate_state
->bs
->backing_hd
= NULL
;
2510 bdrv_unref(intermediate_state
->bs
);
2515 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2516 g_free(intermediate_state
);
2522 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2527 if (!bdrv_is_inserted(bs
))
2533 len
= bdrv_getlength(bs
);
2538 if ((offset
> len
) || (len
- offset
< size
))
2544 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2547 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2548 nb_sectors
* BDRV_SECTOR_SIZE
);
2551 typedef struct RwCo
{
2552 BlockDriverState
*bs
;
2558 BdrvRequestFlags flags
;
2561 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2563 RwCo
*rwco
= opaque
;
2565 if (!rwco
->is_write
) {
2566 rwco
->ret
= bdrv_co_do_readv(rwco
->bs
, rwco
->sector_num
,
2567 rwco
->nb_sectors
, rwco
->qiov
,
2570 rwco
->ret
= bdrv_co_do_writev(rwco
->bs
, rwco
->sector_num
,
2571 rwco
->nb_sectors
, rwco
->qiov
,
2577 * Process a vectored synchronous request using coroutines
2579 static int bdrv_rwv_co(BlockDriverState
*bs
, int64_t sector_num
,
2580 QEMUIOVector
*qiov
, bool is_write
,
2581 BdrvRequestFlags flags
)
2586 .sector_num
= sector_num
,
2587 .nb_sectors
= qiov
->size
>> BDRV_SECTOR_BITS
,
2589 .is_write
= is_write
,
2593 assert((qiov
->size
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2596 * In sync call context, when the vcpu is blocked, this throttling timer
2597 * will not fire; so the I/O throttling function has to be disabled here
2598 * if it has been enabled.
2600 if (bs
->io_limits_enabled
) {
2601 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2602 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2603 bdrv_io_limits_disable(bs
);
2606 if (qemu_in_coroutine()) {
2607 /* Fast-path if already in coroutine context */
2608 bdrv_rw_co_entry(&rwco
);
2610 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2611 qemu_coroutine_enter(co
, &rwco
);
2612 while (rwco
.ret
== NOT_DONE
) {
2620 * Process a synchronous request using coroutines
2622 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2623 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2626 struct iovec iov
= {
2627 .iov_base
= (void *)buf
,
2628 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2631 qemu_iovec_init_external(&qiov
, &iov
, 1);
2632 return bdrv_rwv_co(bs
, sector_num
, &qiov
, is_write
, flags
);
2635 /* return < 0 if error. See bdrv_write() for the return codes */
2636 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2637 uint8_t *buf
, int nb_sectors
)
2639 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2642 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2643 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2644 uint8_t *buf
, int nb_sectors
)
2649 enabled
= bs
->io_limits_enabled
;
2650 bs
->io_limits_enabled
= false;
2651 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2652 bs
->io_limits_enabled
= enabled
;
2656 /* Return < 0 if error. Important errors are:
2657 -EIO generic I/O error (may happen for all errors)
2658 -ENOMEDIUM No media inserted.
2659 -EINVAL Invalid sector number or nb_sectors
2660 -EACCES Trying to write a read-only device
2662 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2663 const uint8_t *buf
, int nb_sectors
)
2665 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2668 int bdrv_writev(BlockDriverState
*bs
, int64_t sector_num
, QEMUIOVector
*qiov
)
2670 return bdrv_rwv_co(bs
, sector_num
, qiov
, true, 0);
2673 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2674 int nb_sectors
, BdrvRequestFlags flags
)
2676 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2677 BDRV_REQ_ZERO_WRITE
| flags
);
2681 * Completely zero out a block device with the help of bdrv_write_zeroes.
2682 * The operation is sped up by checking the block status and only writing
2683 * zeroes to the device if they currently do not return zeroes. Optional
2684 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2686 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2688 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2690 int64_t target_size
= bdrv_getlength(bs
) / BDRV_SECTOR_SIZE
;
2691 int64_t ret
, nb_sectors
, sector_num
= 0;
2695 nb_sectors
= target_size
- sector_num
;
2696 if (nb_sectors
<= 0) {
2699 if (nb_sectors
> INT_MAX
) {
2700 nb_sectors
= INT_MAX
;
2702 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2704 error_report("error getting block status at sector %" PRId64
": %s",
2705 sector_num
, strerror(-ret
));
2708 if (ret
& BDRV_BLOCK_ZERO
) {
2712 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2714 error_report("error writing zeroes at sector %" PRId64
": %s",
2715 sector_num
, strerror(-ret
));
2722 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
,
2723 void *buf
, int count1
)
2725 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2726 int len
, nb_sectors
, count
;
2731 /* first read to align to sector start */
2732 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2735 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2737 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2739 memcpy(buf
, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)), len
);
2747 /* read the sectors "in place" */
2748 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2749 if (nb_sectors
> 0) {
2750 if ((ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
)) < 0)
2752 sector_num
+= nb_sectors
;
2753 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2758 /* add data from the last sector */
2760 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2762 memcpy(buf
, tmp_buf
, count
);
2767 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2769 uint8_t tmp_buf
[BDRV_SECTOR_SIZE
];
2770 int len
, nb_sectors
, count
;
2776 /* first write to align to sector start */
2777 len
= (BDRV_SECTOR_SIZE
- offset
) & (BDRV_SECTOR_SIZE
- 1);
2780 sector_num
= offset
>> BDRV_SECTOR_BITS
;
2782 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2784 qemu_iovec_to_buf(qiov
, 0, tmp_buf
+ (offset
& (BDRV_SECTOR_SIZE
- 1)),
2786 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2794 /* write the sectors "in place" */
2795 nb_sectors
= count
>> BDRV_SECTOR_BITS
;
2796 if (nb_sectors
> 0) {
2797 QEMUIOVector qiov_inplace
;
2799 qemu_iovec_init(&qiov_inplace
, qiov
->niov
);
2800 qemu_iovec_concat(&qiov_inplace
, qiov
, len
,
2801 nb_sectors
<< BDRV_SECTOR_BITS
);
2802 ret
= bdrv_writev(bs
, sector_num
, &qiov_inplace
);
2803 qemu_iovec_destroy(&qiov_inplace
);
2808 sector_num
+= nb_sectors
;
2809 len
= nb_sectors
<< BDRV_SECTOR_BITS
;
2813 /* add data from the last sector */
2815 if ((ret
= bdrv_read(bs
, sector_num
, tmp_buf
, 1)) < 0)
2817 qemu_iovec_to_buf(qiov
, qiov
->size
- count
, tmp_buf
, count
);
2818 if ((ret
= bdrv_write(bs
, sector_num
, tmp_buf
, 1)) < 0)
2824 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2825 const void *buf
, int count1
)
2828 struct iovec iov
= {
2829 .iov_base
= (void *) buf
,
2833 qemu_iovec_init_external(&qiov
, &iov
, 1);
2834 return bdrv_pwritev(bs
, offset
, &qiov
);
2838 * Writes to the file and ensures that no writes are reordered across this
2839 * request (acts as a barrier)
2841 * Returns 0 on success, -errno in error cases.
2843 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2844 const void *buf
, int count
)
2848 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2853 /* No flush needed for cache modes that already do it */
2854 if (bs
->enable_write_cache
) {
2861 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2862 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2864 /* Perform I/O through a temporary buffer so that users who scribble over
2865 * their read buffer while the operation is in progress do not end up
2866 * modifying the image file. This is critical for zero-copy guest I/O
2867 * where anything might happen inside guest memory.
2869 void *bounce_buffer
;
2871 BlockDriver
*drv
= bs
->drv
;
2873 QEMUIOVector bounce_qiov
;
2874 int64_t cluster_sector_num
;
2875 int cluster_nb_sectors
;
2879 /* Cover entire cluster so no additional backing file I/O is required when
2880 * allocating cluster in the image file.
2882 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2883 &cluster_sector_num
, &cluster_nb_sectors
);
2885 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2886 cluster_sector_num
, cluster_nb_sectors
);
2888 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2889 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2890 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2892 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2898 if (drv
->bdrv_co_write_zeroes
&&
2899 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2900 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2901 cluster_nb_sectors
, 0);
2903 /* This does not change the data on the disk, it is not necessary
2904 * to flush even in cache=writethrough mode.
2906 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2911 /* It might be okay to ignore write errors for guest requests. If this
2912 * is a deliberate copy-on-read then we don't want to ignore the error.
2913 * Simply report it in all cases.
2918 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2919 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2920 nb_sectors
* BDRV_SECTOR_SIZE
);
2923 qemu_vfree(bounce_buffer
);
2928 * Forwards an already correctly aligned request to the BlockDriver. This
2929 * handles copy on read and zeroing after EOF; any other features must be
2930 * implemented by the caller.
2932 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
2933 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
2934 int64_t align
, QEMUIOVector
*qiov
, int flags
)
2936 BlockDriver
*drv
= bs
->drv
;
2939 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
2940 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
2942 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2943 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2945 /* Handle Copy on Read and associated serialisation */
2946 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2947 /* If we touch the same cluster it counts as an overlap. This
2948 * guarantees that allocating writes will be serialized and not race
2949 * with each other for the same cluster. For example, in copy-on-read
2950 * it ensures that the CoR read and write operations are atomic and
2951 * guest writes cannot interleave between them. */
2952 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
2955 wait_serialising_requests(req
);
2957 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2960 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2965 if (!ret
|| pnum
!= nb_sectors
) {
2966 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2971 /* Forward the request to the BlockDriver */
2972 if (!(bs
->zero_beyond_eof
&& bs
->growable
)) {
2973 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2975 /* Read zeros after EOF of growable BDSes */
2976 int64_t len
, total_sectors
, max_nb_sectors
;
2978 len
= bdrv_getlength(bs
);
2984 total_sectors
= DIV_ROUND_UP(len
, BDRV_SECTOR_SIZE
);
2985 max_nb_sectors
= MAX(0, ROUND_UP(total_sectors
- sector_num
,
2986 align
>> BDRV_SECTOR_BITS
));
2987 if (max_nb_sectors
> 0) {
2988 ret
= drv
->bdrv_co_readv(bs
, sector_num
,
2989 MIN(nb_sectors
, max_nb_sectors
), qiov
);
2994 /* Reading beyond end of file is supposed to produce zeroes */
2995 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
2996 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
2997 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
2999 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3008 * Handle a read request in coroutine context
3010 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3011 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3012 BdrvRequestFlags flags
)
3014 BlockDriver
*drv
= bs
->drv
;
3015 BdrvTrackedRequest req
;
3017 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3018 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3019 uint8_t *head_buf
= NULL
;
3020 uint8_t *tail_buf
= NULL
;
3021 QEMUIOVector local_qiov
;
3022 bool use_local_qiov
= false;
3028 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3032 if (bs
->copy_on_read
) {
3033 flags
|= BDRV_REQ_COPY_ON_READ
;
3036 /* throttling disk I/O */
3037 if (bs
->io_limits_enabled
) {
3038 /* TODO Switch to byte granularity */
3039 bdrv_io_limits_intercept(bs
, bytes
>> BDRV_SECTOR_BITS
, false);
3042 /* Align read if necessary by padding qiov */
3043 if (offset
& (align
- 1)) {
3044 head_buf
= qemu_blockalign(bs
, align
);
3045 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3046 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3047 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3048 use_local_qiov
= true;
3050 bytes
+= offset
& (align
- 1);
3051 offset
= offset
& ~(align
- 1);
3054 if ((offset
+ bytes
) & (align
- 1)) {
3055 if (!use_local_qiov
) {
3056 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3057 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3058 use_local_qiov
= true;
3060 tail_buf
= qemu_blockalign(bs
, align
);
3061 qemu_iovec_add(&local_qiov
, tail_buf
,
3062 align
- ((offset
+ bytes
) & (align
- 1)));
3064 bytes
= ROUND_UP(bytes
, align
);
3067 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3068 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3069 use_local_qiov
? &local_qiov
: qiov
,
3071 tracked_request_end(&req
);
3073 if (use_local_qiov
) {
3074 qemu_iovec_destroy(&local_qiov
);
3075 qemu_vfree(head_buf
);
3076 qemu_vfree(tail_buf
);
3082 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3083 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3084 BdrvRequestFlags flags
)
3086 if (nb_sectors
< 0 || nb_sectors
> (UINT_MAX
>> BDRV_SECTOR_BITS
)) {
3090 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3091 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3094 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3095 int nb_sectors
, QEMUIOVector
*qiov
)
3097 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3099 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3102 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3103 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3105 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3107 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3108 BDRV_REQ_COPY_ON_READ
);
3111 /* if no limit is specified in the BlockLimits use a default
3112 * of 32768 512-byte sectors (16 MiB) per request.
3114 #define MAX_WRITE_ZEROES_DEFAULT 32768
3116 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3117 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3119 BlockDriver
*drv
= bs
->drv
;
3121 struct iovec iov
= {0};
3124 int max_write_zeroes
= bs
->bl
.max_write_zeroes
?
3125 bs
->bl
.max_write_zeroes
: MAX_WRITE_ZEROES_DEFAULT
;
3127 while (nb_sectors
> 0 && !ret
) {
3128 int num
= nb_sectors
;
3130 /* Align request. Block drivers can expect the "bulk" of the request
3133 if (bs
->bl
.write_zeroes_alignment
3134 && num
> bs
->bl
.write_zeroes_alignment
) {
3135 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3136 /* Make a small request up to the first aligned sector. */
3137 num
= bs
->bl
.write_zeroes_alignment
;
3138 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3139 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3140 /* Shorten the request to the last aligned sector. num cannot
3141 * underflow because num > bs->bl.write_zeroes_alignment.
3143 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3147 /* limit request size */
3148 if (num
> max_write_zeroes
) {
3149 num
= max_write_zeroes
;
3153 /* First try the efficient write zeroes operation */
3154 if (drv
->bdrv_co_write_zeroes
) {
3155 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3158 if (ret
== -ENOTSUP
) {
3159 /* Fall back to bounce buffer if write zeroes is unsupported */
3160 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3161 if (iov
.iov_base
== NULL
) {
3162 iov
.iov_base
= qemu_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3163 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3165 qemu_iovec_init_external(&qiov
, &iov
, 1);
3167 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3169 /* Keep bounce buffer around if it is big enough for all
3170 * all future requests.
3172 if (num
< max_write_zeroes
) {
3173 qemu_vfree(iov
.iov_base
);
3174 iov
.iov_base
= NULL
;
3182 qemu_vfree(iov
.iov_base
);
3187 * Forwards an already correctly aligned write request to the BlockDriver.
3189 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3190 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3191 QEMUIOVector
*qiov
, int flags
)
3193 BlockDriver
*drv
= bs
->drv
;
3196 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3197 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3199 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3200 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3202 wait_serialising_requests(req
);
3204 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3207 /* Do nothing, write notifier decided to fail this request */
3208 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3209 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3211 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3214 if (ret
== 0 && !bs
->enable_write_cache
) {
3215 ret
= bdrv_co_flush(bs
);
3218 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3220 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
3221 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
3223 if (bs
->growable
&& ret
>= 0) {
3224 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3231 * Handle a write request in coroutine context
3233 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3234 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3235 BdrvRequestFlags flags
)
3237 BdrvTrackedRequest req
;
3238 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3239 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3240 uint8_t *head_buf
= NULL
;
3241 uint8_t *tail_buf
= NULL
;
3242 QEMUIOVector local_qiov
;
3243 bool use_local_qiov
= false;
3249 if (bs
->read_only
) {
3252 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3256 /* throttling disk I/O */
3257 if (bs
->io_limits_enabled
) {
3258 /* TODO Switch to byte granularity */
3259 bdrv_io_limits_intercept(bs
, bytes
>> BDRV_SECTOR_BITS
, true);
3263 * Align write if necessary by performing a read-modify-write cycle.
3264 * Pad qiov with the read parts and be sure to have a tracked request not
3265 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3267 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3269 if (offset
& (align
- 1)) {
3270 QEMUIOVector head_qiov
;
3271 struct iovec head_iov
;
3273 mark_request_serialising(&req
, align
);
3274 wait_serialising_requests(&req
);
3276 head_buf
= qemu_blockalign(bs
, align
);
3277 head_iov
= (struct iovec
) {
3278 .iov_base
= head_buf
,
3281 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3283 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3284 align
, &head_qiov
, 0);
3289 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3290 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3291 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3292 use_local_qiov
= true;
3294 bytes
+= offset
& (align
- 1);
3295 offset
= offset
& ~(align
- 1);
3298 if ((offset
+ bytes
) & (align
- 1)) {
3299 QEMUIOVector tail_qiov
;
3300 struct iovec tail_iov
;
3303 mark_request_serialising(&req
, align
);
3304 wait_serialising_requests(&req
);
3306 tail_buf
= qemu_blockalign(bs
, align
);
3307 tail_iov
= (struct iovec
) {
3308 .iov_base
= tail_buf
,
3311 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3313 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3314 align
, &tail_qiov
, 0);
3319 if (!use_local_qiov
) {
3320 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3321 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3322 use_local_qiov
= true;
3325 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3326 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3328 bytes
= ROUND_UP(bytes
, align
);
3331 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3332 use_local_qiov
? &local_qiov
: qiov
,
3336 tracked_request_end(&req
);
3338 if (use_local_qiov
) {
3339 qemu_iovec_destroy(&local_qiov
);
3340 qemu_vfree(head_buf
);
3341 qemu_vfree(tail_buf
);
3347 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3348 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3349 BdrvRequestFlags flags
)
3351 if (nb_sectors
< 0 || nb_sectors
> (INT_MAX
>> BDRV_SECTOR_BITS
)) {
3355 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3356 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3359 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3360 int nb_sectors
, QEMUIOVector
*qiov
)
3362 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3364 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3367 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3368 int64_t sector_num
, int nb_sectors
,
3369 BdrvRequestFlags flags
)
3371 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3373 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3374 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3377 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3378 BDRV_REQ_ZERO_WRITE
| flags
);
3382 * Truncate file to 'offset' bytes (needed only for file protocols)
3384 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3386 BlockDriver
*drv
= bs
->drv
;
3390 if (!drv
->bdrv_truncate
)
3394 if (bdrv_in_use(bs
))
3396 ret
= drv
->bdrv_truncate(bs
, offset
);
3398 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3399 bdrv_dev_resize_cb(bs
);
3405 * Length of a allocated file in bytes. Sparse files are counted by actual
3406 * allocated space. Return < 0 if error or unknown.
3408 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3410 BlockDriver
*drv
= bs
->drv
;
3414 if (drv
->bdrv_get_allocated_file_size
) {
3415 return drv
->bdrv_get_allocated_file_size(bs
);
3418 return bdrv_get_allocated_file_size(bs
->file
);
3424 * Length of a file in bytes. Return < 0 if error or unknown.
3426 int64_t bdrv_getlength(BlockDriverState
*bs
)
3428 BlockDriver
*drv
= bs
->drv
;
3432 if (drv
->has_variable_length
) {
3433 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3438 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3441 /* return 0 as number of sectors if no device present or error */
3442 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3445 length
= bdrv_getlength(bs
);
3449 length
= length
>> BDRV_SECTOR_BITS
;
3450 *nb_sectors_ptr
= length
;
3453 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3454 BlockdevOnError on_write_error
)
3456 bs
->on_read_error
= on_read_error
;
3457 bs
->on_write_error
= on_write_error
;
3460 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3462 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3465 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3467 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3470 case BLOCKDEV_ON_ERROR_ENOSPC
:
3471 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
3472 case BLOCKDEV_ON_ERROR_STOP
:
3473 return BDRV_ACTION_STOP
;
3474 case BLOCKDEV_ON_ERROR_REPORT
:
3475 return BDRV_ACTION_REPORT
;
3476 case BLOCKDEV_ON_ERROR_IGNORE
:
3477 return BDRV_ACTION_IGNORE
;
3483 /* This is done by device models because, while the block layer knows
3484 * about the error, it does not know whether an operation comes from
3485 * the device or the block layer (from a job, for example).
3487 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3488 bool is_read
, int error
)
3491 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
3492 if (action
== BDRV_ACTION_STOP
) {
3493 vm_stop(RUN_STATE_IO_ERROR
);
3494 bdrv_iostatus_set_err(bs
, error
);
3498 int bdrv_is_read_only(BlockDriverState
*bs
)
3500 return bs
->read_only
;
3503 int bdrv_is_sg(BlockDriverState
*bs
)
3508 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3510 return bs
->enable_write_cache
;
3513 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3515 bs
->enable_write_cache
= wce
;
3517 /* so a reopen() will preserve wce */
3519 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3521 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3525 int bdrv_is_encrypted(BlockDriverState
*bs
)
3527 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3529 return bs
->encrypted
;
3532 int bdrv_key_required(BlockDriverState
*bs
)
3534 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3536 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3538 return (bs
->encrypted
&& !bs
->valid_key
);
3541 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3544 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3545 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3551 if (!bs
->encrypted
) {
3553 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3556 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3559 } else if (!bs
->valid_key
) {
3561 /* call the change callback now, we skipped it on open */
3562 bdrv_dev_change_media_cb(bs
, true);
3567 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3569 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3572 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3577 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3578 it(opaque
, drv
->format_name
);
3582 /* This function is to find block backend bs */
3583 BlockDriverState
*bdrv_find(const char *name
)
3585 BlockDriverState
*bs
;
3587 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3588 if (!strcmp(name
, bs
->device_name
)) {
3595 /* This function is to find a node in the bs graph */
3596 BlockDriverState
*bdrv_find_node(const char *node_name
)
3598 BlockDriverState
*bs
;
3602 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3603 if (!strcmp(node_name
, bs
->node_name
)) {
3610 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3611 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3613 BlockDeviceInfoList
*list
, *entry
;
3614 BlockDriverState
*bs
;
3617 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3618 entry
= g_malloc0(sizeof(*entry
));
3619 entry
->value
= bdrv_block_device_info(bs
);
3627 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3628 const char *node_name
,
3631 BlockDriverState
*bs
= NULL
;
3633 if ((!device
&& !node_name
) || (device
&& node_name
)) {
3634 error_setg(errp
, "Use either device or node-name but not both");
3639 bs
= bdrv_find(device
);
3642 error_set(errp
, QERR_DEVICE_NOT_FOUND
, device
);
3649 bs
= bdrv_find_node(node_name
);
3652 error_set(errp
, QERR_DEVICE_NOT_FOUND
, node_name
);
3659 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3662 return QTAILQ_FIRST(&bdrv_states
);
3664 return QTAILQ_NEXT(bs
, device_list
);
3667 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
3669 BlockDriverState
*bs
;
3671 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3676 const char *bdrv_get_device_name(BlockDriverState
*bs
)
3678 return bs
->device_name
;
3681 int bdrv_get_flags(BlockDriverState
*bs
)
3683 return bs
->open_flags
;
3686 int bdrv_flush_all(void)
3688 BlockDriverState
*bs
;
3691 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3692 int ret
= bdrv_flush(bs
);
3693 if (ret
< 0 && !result
) {
3701 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3706 int bdrv_has_zero_init(BlockDriverState
*bs
)
3710 /* If BS is a copy on write image, it is initialized to
3711 the contents of the base image, which may not be zeroes. */
3712 if (bs
->backing_hd
) {
3715 if (bs
->drv
->bdrv_has_zero_init
) {
3716 return bs
->drv
->bdrv_has_zero_init(bs
);
3723 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3725 BlockDriverInfo bdi
;
3727 if (bs
->backing_hd
) {
3731 if (bdrv_get_info(bs
, &bdi
) == 0) {
3732 return bdi
.unallocated_blocks_are_zero
;
3738 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3740 BlockDriverInfo bdi
;
3742 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3746 if (bdrv_get_info(bs
, &bdi
) == 0) {
3747 return bdi
.can_write_zeroes_with_unmap
;
3753 typedef struct BdrvCoGetBlockStatusData
{
3754 BlockDriverState
*bs
;
3755 BlockDriverState
*base
;
3761 } BdrvCoGetBlockStatusData
;
3764 * Returns true iff the specified sector is present in the disk image. Drivers
3765 * not implementing the functionality are assumed to not support backing files,
3766 * hence all their sectors are reported as allocated.
3768 * If 'sector_num' is beyond the end of the disk image the return value is 0
3769 * and 'pnum' is set to 0.
3771 * 'pnum' is set to the number of sectors (including and immediately following
3772 * the specified sector) that are known to be in the same
3773 * allocated/unallocated state.
3775 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3776 * beyond the end of the disk image it will be clamped.
3778 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
3780 int nb_sectors
, int *pnum
)
3786 length
= bdrv_getlength(bs
);
3791 if (sector_num
>= (length
>> BDRV_SECTOR_BITS
)) {
3796 n
= bs
->total_sectors
- sector_num
;
3797 if (n
< nb_sectors
) {
3801 if (!bs
->drv
->bdrv_co_get_block_status
) {
3803 ret
= BDRV_BLOCK_DATA
;
3804 if (bs
->drv
->protocol_name
) {
3805 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
3810 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
3816 if (ret
& BDRV_BLOCK_RAW
) {
3817 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
3818 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3822 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
3823 if (bdrv_unallocated_blocks_are_zero(bs
)) {
3824 ret
|= BDRV_BLOCK_ZERO
;
3825 } else if (bs
->backing_hd
) {
3826 BlockDriverState
*bs2
= bs
->backing_hd
;
3827 int64_t length2
= bdrv_getlength(bs2
);
3828 if (length2
>= 0 && sector_num
>= (length2
>> BDRV_SECTOR_BITS
)) {
3829 ret
|= BDRV_BLOCK_ZERO
;
3835 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
3836 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
3837 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3840 /* Ignore errors. This is just providing extra information, it
3841 * is useful but not necessary.
3843 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
3850 /* Coroutine wrapper for bdrv_get_block_status() */
3851 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
3853 BdrvCoGetBlockStatusData
*data
= opaque
;
3854 BlockDriverState
*bs
= data
->bs
;
3856 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
3862 * Synchronous wrapper around bdrv_co_get_block_status().
3864 * See bdrv_co_get_block_status() for details.
3866 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
3867 int nb_sectors
, int *pnum
)
3870 BdrvCoGetBlockStatusData data
= {
3872 .sector_num
= sector_num
,
3873 .nb_sectors
= nb_sectors
,
3878 if (qemu_in_coroutine()) {
3879 /* Fast-path if already in coroutine context */
3880 bdrv_get_block_status_co_entry(&data
);
3882 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
3883 qemu_coroutine_enter(co
, &data
);
3884 while (!data
.done
) {
3891 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
3892 int nb_sectors
, int *pnum
)
3894 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
3899 (ret
& BDRV_BLOCK_DATA
) ||
3900 ((ret
& BDRV_BLOCK_ZERO
) && !bdrv_has_zero_init(bs
));
3904 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3906 * Return true if the given sector is allocated in any image between
3907 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3908 * sector is allocated in any image of the chain. Return false otherwise.
3910 * 'pnum' is set to the number of sectors (including and immediately following
3911 * the specified sector) that are known to be in the same
3912 * allocated/unallocated state.
3915 int bdrv_is_allocated_above(BlockDriverState
*top
,
3916 BlockDriverState
*base
,
3918 int nb_sectors
, int *pnum
)
3920 BlockDriverState
*intermediate
;
3921 int ret
, n
= nb_sectors
;
3924 while (intermediate
&& intermediate
!= base
) {
3926 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
3936 * [sector_num, nb_sectors] is unallocated on top but intermediate
3939 * [sector_num+x, nr_sectors] allocated.
3941 if (n
> pnum_inter
&&
3942 (intermediate
== top
||
3943 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
3947 intermediate
= intermediate
->backing_hd
;
3954 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3956 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3957 return bs
->backing_file
;
3958 else if (bs
->encrypted
)
3959 return bs
->filename
;
3964 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3965 char *filename
, int filename_size
)
3967 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3970 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
3971 const uint8_t *buf
, int nb_sectors
)
3973 BlockDriver
*drv
= bs
->drv
;
3976 if (!drv
->bdrv_write_compressed
)
3978 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
3981 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
3983 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
3986 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3988 BlockDriver
*drv
= bs
->drv
;
3991 if (!drv
->bdrv_get_info
)
3993 memset(bdi
, 0, sizeof(*bdi
));
3994 return drv
->bdrv_get_info(bs
, bdi
);
3997 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3999 BlockDriver
*drv
= bs
->drv
;
4000 if (drv
&& drv
->bdrv_get_specific_info
) {
4001 return drv
->bdrv_get_specific_info(bs
);
4006 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
4007 int64_t pos
, int size
)
4010 struct iovec iov
= {
4011 .iov_base
= (void *) buf
,
4015 qemu_iovec_init_external(&qiov
, &iov
, 1);
4016 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
4019 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
4021 BlockDriver
*drv
= bs
->drv
;
4025 } else if (drv
->bdrv_save_vmstate
) {
4026 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
4027 } else if (bs
->file
) {
4028 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4034 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4035 int64_t pos
, int size
)
4037 BlockDriver
*drv
= bs
->drv
;
4040 if (drv
->bdrv_load_vmstate
)
4041 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4043 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4047 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4049 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4053 bs
->drv
->bdrv_debug_event(bs
, event
);
4056 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4059 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4063 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4064 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4070 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4072 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4076 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4077 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4083 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4085 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_resume
) {
4089 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4090 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4096 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4098 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4102 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4103 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4109 int bdrv_is_snapshot(BlockDriverState
*bs
)
4111 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4114 /* backing_file can either be relative, or absolute, or a protocol. If it is
4115 * relative, it must be relative to the chain. So, passing in bs->filename
4116 * from a BDS as backing_file should not be done, as that may be relative to
4117 * the CWD rather than the chain. */
4118 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4119 const char *backing_file
)
4121 char *filename_full
= NULL
;
4122 char *backing_file_full
= NULL
;
4123 char *filename_tmp
= NULL
;
4124 int is_protocol
= 0;
4125 BlockDriverState
*curr_bs
= NULL
;
4126 BlockDriverState
*retval
= NULL
;
4128 if (!bs
|| !bs
->drv
|| !backing_file
) {
4132 filename_full
= g_malloc(PATH_MAX
);
4133 backing_file_full
= g_malloc(PATH_MAX
);
4134 filename_tmp
= g_malloc(PATH_MAX
);
4136 is_protocol
= path_has_protocol(backing_file
);
4138 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4140 /* If either of the filename paths is actually a protocol, then
4141 * compare unmodified paths; otherwise make paths relative */
4142 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4143 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4144 retval
= curr_bs
->backing_hd
;
4148 /* If not an absolute filename path, make it relative to the current
4149 * image's filename path */
4150 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4153 /* We are going to compare absolute pathnames */
4154 if (!realpath(filename_tmp
, filename_full
)) {
4158 /* We need to make sure the backing filename we are comparing against
4159 * is relative to the current image filename (or absolute) */
4160 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4161 curr_bs
->backing_file
);
4163 if (!realpath(filename_tmp
, backing_file_full
)) {
4167 if (strcmp(backing_file_full
, filename_full
) == 0) {
4168 retval
= curr_bs
->backing_hd
;
4174 g_free(filename_full
);
4175 g_free(backing_file_full
);
4176 g_free(filename_tmp
);
4180 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4186 if (!bs
->backing_hd
) {
4190 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4193 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
4195 BlockDriverState
*curr_bs
= NULL
;
4203 while (curr_bs
->backing_hd
) {
4204 curr_bs
= curr_bs
->backing_hd
;
4209 /**************************************************************/
4212 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4213 QEMUIOVector
*qiov
, int nb_sectors
,
4214 BlockDriverCompletionFunc
*cb
, void *opaque
)
4216 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4218 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4222 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4223 QEMUIOVector
*qiov
, int nb_sectors
,
4224 BlockDriverCompletionFunc
*cb
, void *opaque
)
4226 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4228 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4232 BlockDriverAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4233 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4234 BlockDriverCompletionFunc
*cb
, void *opaque
)
4236 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4238 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4239 BDRV_REQ_ZERO_WRITE
| flags
,
4244 typedef struct MultiwriteCB
{
4249 BlockDriverCompletionFunc
*cb
;
4251 QEMUIOVector
*free_qiov
;
4255 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4259 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4260 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4261 if (mcb
->callbacks
[i
].free_qiov
) {
4262 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4264 g_free(mcb
->callbacks
[i
].free_qiov
);
4268 static void multiwrite_cb(void *opaque
, int ret
)
4270 MultiwriteCB
*mcb
= opaque
;
4272 trace_multiwrite_cb(mcb
, ret
);
4274 if (ret
< 0 && !mcb
->error
) {
4278 mcb
->num_requests
--;
4279 if (mcb
->num_requests
== 0) {
4280 multiwrite_user_cb(mcb
);
4285 static int multiwrite_req_compare(const void *a
, const void *b
)
4287 const BlockRequest
*req1
= a
, *req2
= b
;
4290 * Note that we can't simply subtract req2->sector from req1->sector
4291 * here as that could overflow the return value.
4293 if (req1
->sector
> req2
->sector
) {
4295 } else if (req1
->sector
< req2
->sector
) {
4303 * Takes a bunch of requests and tries to merge them. Returns the number of
4304 * requests that remain after merging.
4306 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4307 int num_reqs
, MultiwriteCB
*mcb
)
4311 // Sort requests by start sector
4312 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4314 // Check if adjacent requests touch the same clusters. If so, combine them,
4315 // filling up gaps with zero sectors.
4317 for (i
= 1; i
< num_reqs
; i
++) {
4319 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4321 // Handle exactly sequential writes and overlapping writes.
4322 if (reqs
[i
].sector
<= oldreq_last
) {
4326 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4332 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4333 qemu_iovec_init(qiov
,
4334 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4336 // Add the first request to the merged one. If the requests are
4337 // overlapping, drop the last sectors of the first request.
4338 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4339 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4341 // We should need to add any zeros between the two requests
4342 assert (reqs
[i
].sector
<= oldreq_last
);
4344 // Add the second request
4345 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4347 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4348 reqs
[outidx
].qiov
= qiov
;
4350 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4353 reqs
[outidx
].sector
= reqs
[i
].sector
;
4354 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4355 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4363 * Submit multiple AIO write requests at once.
4365 * On success, the function returns 0 and all requests in the reqs array have
4366 * been submitted. In error case this function returns -1, and any of the
4367 * requests may or may not be submitted yet. In particular, this means that the
4368 * callback will be called for some of the requests, for others it won't. The
4369 * caller must check the error field of the BlockRequest to wait for the right
4370 * callbacks (if error != 0, no callback will be called).
4372 * The implementation may modify the contents of the reqs array, e.g. to merge
4373 * requests. However, the fields opaque and error are left unmodified as they
4374 * are used to signal failure for a single request to the caller.
4376 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4381 /* don't submit writes if we don't have a medium */
4382 if (bs
->drv
== NULL
) {
4383 for (i
= 0; i
< num_reqs
; i
++) {
4384 reqs
[i
].error
= -ENOMEDIUM
;
4389 if (num_reqs
== 0) {
4393 // Create MultiwriteCB structure
4394 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4395 mcb
->num_requests
= 0;
4396 mcb
->num_callbacks
= num_reqs
;
4398 for (i
= 0; i
< num_reqs
; i
++) {
4399 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4400 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4403 // Check for mergable requests
4404 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4406 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4408 /* Run the aio requests. */
4409 mcb
->num_requests
= num_reqs
;
4410 for (i
= 0; i
< num_reqs
; i
++) {
4411 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4412 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4420 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
4422 acb
->aiocb_info
->cancel(acb
);
4425 /**************************************************************/
4426 /* async block device emulation */
4428 typedef struct BlockDriverAIOCBSync
{
4429 BlockDriverAIOCB common
;
4432 /* vector translation state */
4436 } BlockDriverAIOCBSync
;
4438 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
4440 BlockDriverAIOCBSync
*acb
=
4441 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
4442 qemu_bh_delete(acb
->bh
);
4444 qemu_aio_release(acb
);
4447 static const AIOCBInfo bdrv_em_aiocb_info
= {
4448 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
4449 .cancel
= bdrv_aio_cancel_em
,
4452 static void bdrv_aio_bh_cb(void *opaque
)
4454 BlockDriverAIOCBSync
*acb
= opaque
;
4457 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4458 qemu_vfree(acb
->bounce
);
4459 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4460 qemu_bh_delete(acb
->bh
);
4462 qemu_aio_release(acb
);
4465 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4469 BlockDriverCompletionFunc
*cb
,
4474 BlockDriverAIOCBSync
*acb
;
4476 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4477 acb
->is_write
= is_write
;
4479 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
4480 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
4483 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4484 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4486 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4489 qemu_bh_schedule(acb
->bh
);
4491 return &acb
->common
;
4494 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4495 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4496 BlockDriverCompletionFunc
*cb
, void *opaque
)
4498 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4501 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4502 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4503 BlockDriverCompletionFunc
*cb
, void *opaque
)
4505 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4509 typedef struct BlockDriverAIOCBCoroutine
{
4510 BlockDriverAIOCB common
;
4515 } BlockDriverAIOCBCoroutine
;
4517 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
4519 BlockDriverAIOCBCoroutine
*acb
=
4520 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
4529 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4530 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
4531 .cancel
= bdrv_aio_co_cancel_em
,
4534 static void bdrv_co_em_bh(void *opaque
)
4536 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4538 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4544 qemu_bh_delete(acb
->bh
);
4545 qemu_aio_release(acb
);
4548 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4549 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4551 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4552 BlockDriverState
*bs
= acb
->common
.bs
;
4554 if (!acb
->is_write
) {
4555 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4556 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4558 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4559 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4562 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4563 qemu_bh_schedule(acb
->bh
);
4566 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4570 BdrvRequestFlags flags
,
4571 BlockDriverCompletionFunc
*cb
,
4576 BlockDriverAIOCBCoroutine
*acb
;
4578 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4579 acb
->req
.sector
= sector_num
;
4580 acb
->req
.nb_sectors
= nb_sectors
;
4581 acb
->req
.qiov
= qiov
;
4582 acb
->req
.flags
= flags
;
4583 acb
->is_write
= is_write
;
4586 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4587 qemu_coroutine_enter(co
, acb
);
4589 return &acb
->common
;
4592 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4594 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4595 BlockDriverState
*bs
= acb
->common
.bs
;
4597 acb
->req
.error
= bdrv_co_flush(bs
);
4598 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4599 qemu_bh_schedule(acb
->bh
);
4602 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4603 BlockDriverCompletionFunc
*cb
, void *opaque
)
4605 trace_bdrv_aio_flush(bs
, opaque
);
4608 BlockDriverAIOCBCoroutine
*acb
;
4610 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4613 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4614 qemu_coroutine_enter(co
, acb
);
4616 return &acb
->common
;
4619 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4621 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4622 BlockDriverState
*bs
= acb
->common
.bs
;
4624 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4625 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4626 qemu_bh_schedule(acb
->bh
);
4629 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4630 int64_t sector_num
, int nb_sectors
,
4631 BlockDriverCompletionFunc
*cb
, void *opaque
)
4634 BlockDriverAIOCBCoroutine
*acb
;
4636 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4638 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4639 acb
->req
.sector
= sector_num
;
4640 acb
->req
.nb_sectors
= nb_sectors
;
4642 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4643 qemu_coroutine_enter(co
, acb
);
4645 return &acb
->common
;
4648 void bdrv_init(void)
4650 module_call_init(MODULE_INIT_BLOCK
);
4653 void bdrv_init_with_whitelist(void)
4655 use_bdrv_whitelist
= 1;
4659 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4660 BlockDriverCompletionFunc
*cb
, void *opaque
)
4662 BlockDriverAIOCB
*acb
;
4664 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4665 acb
->aiocb_info
= aiocb_info
;
4668 acb
->opaque
= opaque
;
4672 void qemu_aio_release(void *p
)
4674 BlockDriverAIOCB
*acb
= p
;
4675 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4678 /**************************************************************/
4679 /* Coroutine block device emulation */
4681 typedef struct CoroutineIOCompletion
{
4682 Coroutine
*coroutine
;
4684 } CoroutineIOCompletion
;
4686 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4688 CoroutineIOCompletion
*co
= opaque
;
4691 qemu_coroutine_enter(co
->coroutine
, NULL
);
4694 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4695 int nb_sectors
, QEMUIOVector
*iov
,
4698 CoroutineIOCompletion co
= {
4699 .coroutine
= qemu_coroutine_self(),
4701 BlockDriverAIOCB
*acb
;
4704 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4705 bdrv_co_io_em_complete
, &co
);
4707 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4708 bdrv_co_io_em_complete
, &co
);
4711 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4715 qemu_coroutine_yield();
4720 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4721 int64_t sector_num
, int nb_sectors
,
4724 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4727 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4728 int64_t sector_num
, int nb_sectors
,
4731 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4734 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4736 RwCo
*rwco
= opaque
;
4738 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4741 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4745 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4749 /* Write back cached data to the OS even with cache=unsafe */
4750 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4751 if (bs
->drv
->bdrv_co_flush_to_os
) {
4752 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4758 /* But don't actually force it to the disk with cache=unsafe */
4759 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4763 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
4764 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4765 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4766 } else if (bs
->drv
->bdrv_aio_flush
) {
4767 BlockDriverAIOCB
*acb
;
4768 CoroutineIOCompletion co
= {
4769 .coroutine
= qemu_coroutine_self(),
4772 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4776 qemu_coroutine_yield();
4781 * Some block drivers always operate in either writethrough or unsafe
4782 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4783 * know how the server works (because the behaviour is hardcoded or
4784 * depends on server-side configuration), so we can't ensure that
4785 * everything is safe on disk. Returning an error doesn't work because
4786 * that would break guests even if the server operates in writethrough
4789 * Let's hope the user knows what he's doing.
4797 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4798 * in the case of cache=unsafe, so there are no useless flushes.
4801 return bdrv_co_flush(bs
->file
);
4804 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4806 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4807 bs
->drv
->bdrv_invalidate_cache(bs
);
4811 void bdrv_invalidate_cache_all(void)
4813 BlockDriverState
*bs
;
4815 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4816 bdrv_invalidate_cache(bs
);
4820 void bdrv_clear_incoming_migration_all(void)
4822 BlockDriverState
*bs
;
4824 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4825 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4829 int bdrv_flush(BlockDriverState
*bs
)
4837 if (qemu_in_coroutine()) {
4838 /* Fast-path if already in coroutine context */
4839 bdrv_flush_co_entry(&rwco
);
4841 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4842 qemu_coroutine_enter(co
, &rwco
);
4843 while (rwco
.ret
== NOT_DONE
) {
4851 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4853 RwCo
*rwco
= opaque
;
4855 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4858 /* if no limit is specified in the BlockLimits use a default
4859 * of 32768 512-byte sectors (16 MiB) per request.
4861 #define MAX_DISCARD_DEFAULT 32768
4863 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4870 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4872 } else if (bs
->read_only
) {
4876 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
4878 /* Do nothing if disabled. */
4879 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
4883 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
4887 max_discard
= bs
->bl
.max_discard
? bs
->bl
.max_discard
: MAX_DISCARD_DEFAULT
;
4888 while (nb_sectors
> 0) {
4890 int num
= nb_sectors
;
4893 if (bs
->bl
.discard_alignment
&&
4894 num
>= bs
->bl
.discard_alignment
&&
4895 sector_num
% bs
->bl
.discard_alignment
) {
4896 if (num
> bs
->bl
.discard_alignment
) {
4897 num
= bs
->bl
.discard_alignment
;
4899 num
-= sector_num
% bs
->bl
.discard_alignment
;
4902 /* limit request size */
4903 if (num
> max_discard
) {
4907 if (bs
->drv
->bdrv_co_discard
) {
4908 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
4910 BlockDriverAIOCB
*acb
;
4911 CoroutineIOCompletion co
= {
4912 .coroutine
= qemu_coroutine_self(),
4915 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4916 bdrv_co_io_em_complete
, &co
);
4920 qemu_coroutine_yield();
4924 if (ret
&& ret
!= -ENOTSUP
) {
4934 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4939 .sector_num
= sector_num
,
4940 .nb_sectors
= nb_sectors
,
4944 if (qemu_in_coroutine()) {
4945 /* Fast-path if already in coroutine context */
4946 bdrv_discard_co_entry(&rwco
);
4948 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4949 qemu_coroutine_enter(co
, &rwco
);
4950 while (rwco
.ret
== NOT_DONE
) {
4958 /**************************************************************/
4959 /* removable device support */
4962 * Return TRUE if the media is present
4964 int bdrv_is_inserted(BlockDriverState
*bs
)
4966 BlockDriver
*drv
= bs
->drv
;
4970 if (!drv
->bdrv_is_inserted
)
4972 return drv
->bdrv_is_inserted(bs
);
4976 * Return whether the media changed since the last call to this
4977 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4979 int bdrv_media_changed(BlockDriverState
*bs
)
4981 BlockDriver
*drv
= bs
->drv
;
4983 if (drv
&& drv
->bdrv_media_changed
) {
4984 return drv
->bdrv_media_changed(bs
);
4990 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4992 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4994 BlockDriver
*drv
= bs
->drv
;
4996 if (drv
&& drv
->bdrv_eject
) {
4997 drv
->bdrv_eject(bs
, eject_flag
);
5000 if (bs
->device_name
[0] != '\0') {
5001 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
5006 * Lock or unlock the media (if it is locked, the user won't be able
5007 * to eject it manually).
5009 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
5011 BlockDriver
*drv
= bs
->drv
;
5013 trace_bdrv_lock_medium(bs
, locked
);
5015 if (drv
&& drv
->bdrv_lock_medium
) {
5016 drv
->bdrv_lock_medium(bs
, locked
);
5020 /* needed for generic scsi interface */
5022 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5024 BlockDriver
*drv
= bs
->drv
;
5026 if (drv
&& drv
->bdrv_ioctl
)
5027 return drv
->bdrv_ioctl(bs
, req
, buf
);
5031 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5032 unsigned long int req
, void *buf
,
5033 BlockDriverCompletionFunc
*cb
, void *opaque
)
5035 BlockDriver
*drv
= bs
->drv
;
5037 if (drv
&& drv
->bdrv_aio_ioctl
)
5038 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5042 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5044 bs
->guest_block_size
= align
;
5047 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5049 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5053 * Check if all memory in this vector is sector aligned.
5055 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5058 size_t alignment
= bdrv_opt_mem_align(bs
);
5060 for (i
= 0; i
< qiov
->niov
; i
++) {
5061 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5064 if (qiov
->iov
[i
].iov_len
% alignment
) {
5072 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
)
5074 int64_t bitmap_size
;
5075 BdrvDirtyBitmap
*bitmap
;
5077 assert((granularity
& (granularity
- 1)) == 0);
5079 granularity
>>= BDRV_SECTOR_BITS
;
5080 assert(granularity
);
5081 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
);
5082 bitmap
= g_malloc0(sizeof(BdrvDirtyBitmap
));
5083 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
5084 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5088 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5090 BdrvDirtyBitmap
*bm
, *next
;
5091 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5093 QLIST_REMOVE(bitmap
, list
);
5094 hbitmap_free(bitmap
->bitmap
);
5101 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5103 BdrvDirtyBitmap
*bm
;
5104 BlockDirtyInfoList
*list
= NULL
;
5105 BlockDirtyInfoList
**plist
= &list
;
5107 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5108 BlockDirtyInfo
*info
= g_malloc0(sizeof(BlockDirtyInfo
));
5109 BlockDirtyInfoList
*entry
= g_malloc0(sizeof(BlockDirtyInfoList
));
5110 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5112 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5113 entry
->value
= info
;
5115 plist
= &entry
->next
;
5121 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5124 return hbitmap_get(bitmap
->bitmap
, sector
);
5130 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5131 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5133 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5136 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5139 BdrvDirtyBitmap
*bitmap
;
5140 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5141 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5145 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
, int nr_sectors
)
5147 BdrvDirtyBitmap
*bitmap
;
5148 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5149 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5153 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5155 return hbitmap_count(bitmap
->bitmap
);
5158 /* Get a reference to bs */
5159 void bdrv_ref(BlockDriverState
*bs
)
5164 /* Release a previously grabbed reference to bs.
5165 * If after releasing, reference count is zero, the BlockDriverState is
5167 void bdrv_unref(BlockDriverState
*bs
)
5169 assert(bs
->refcnt
> 0);
5170 if (--bs
->refcnt
== 0) {
5175 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
5177 assert(bs
->in_use
!= in_use
);
5178 bs
->in_use
= in_use
;
5181 int bdrv_in_use(BlockDriverState
*bs
)
5186 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5188 bs
->iostatus_enabled
= true;
5189 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5192 /* The I/O status is only enabled if the drive explicitly
5193 * enables it _and_ the VM is configured to stop on errors */
5194 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5196 return (bs
->iostatus_enabled
&&
5197 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5198 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5199 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5202 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5204 bs
->iostatus_enabled
= false;
5207 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5209 if (bdrv_iostatus_is_enabled(bs
)) {
5210 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5212 block_job_iostatus_reset(bs
->job
);
5217 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5219 assert(bdrv_iostatus_is_enabled(bs
));
5220 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5221 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5222 BLOCK_DEVICE_IO_STATUS_FAILED
;
5227 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
5228 enum BlockAcctType type
)
5230 assert(type
< BDRV_MAX_IOTYPE
);
5232 cookie
->bytes
= bytes
;
5233 cookie
->start_time_ns
= get_clock();
5234 cookie
->type
= type
;
5238 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
5240 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
5242 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
5243 bs
->nr_ops
[cookie
->type
]++;
5244 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
5247 void bdrv_img_create(const char *filename
, const char *fmt
,
5248 const char *base_filename
, const char *base_fmt
,
5249 char *options
, uint64_t img_size
, int flags
,
5250 Error
**errp
, bool quiet
)
5252 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
5253 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
5254 BlockDriver
*drv
, *proto_drv
;
5255 BlockDriver
*backing_drv
= NULL
;
5256 Error
*local_err
= NULL
;
5259 /* Find driver and parse its options */
5260 drv
= bdrv_find_format(fmt
);
5262 error_setg(errp
, "Unknown file format '%s'", fmt
);
5266 proto_drv
= bdrv_find_protocol(filename
, true);
5268 error_setg(errp
, "Unknown protocol '%s'", filename
);
5272 create_options
= append_option_parameters(create_options
,
5273 drv
->create_options
);
5274 create_options
= append_option_parameters(create_options
,
5275 proto_drv
->create_options
);
5277 /* Create parameter list with default values */
5278 param
= parse_option_parameters("", create_options
, param
);
5280 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
5282 /* Parse -o options */
5284 param
= parse_option_parameters(options
, create_options
, param
);
5285 if (param
== NULL
) {
5286 error_setg(errp
, "Invalid options for file format '%s'.", fmt
);
5291 if (base_filename
) {
5292 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
5294 error_setg(errp
, "Backing file not supported for file format '%s'",
5301 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
5302 error_setg(errp
, "Backing file format not supported for file "
5303 "format '%s'", fmt
);
5308 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
5309 if (backing_file
&& backing_file
->value
.s
) {
5310 if (!strcmp(filename
, backing_file
->value
.s
)) {
5311 error_setg(errp
, "Error: Trying to create an image with the "
5312 "same filename as the backing file");
5317 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
5318 if (backing_fmt
&& backing_fmt
->value
.s
) {
5319 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
5321 error_setg(errp
, "Unknown backing file format '%s'",
5322 backing_fmt
->value
.s
);
5327 // The size for the image must always be specified, with one exception:
5328 // If we are using a backing file, we can obtain the size from there
5329 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
5330 if (size
&& size
->value
.n
== -1) {
5331 if (backing_file
&& backing_file
->value
.s
) {
5332 BlockDriverState
*bs
;
5337 /* backing files always opened read-only */
5339 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5343 ret
= bdrv_open(bs
, backing_file
->value
.s
, NULL
, back_flags
,
5344 backing_drv
, &local_err
);
5346 error_setg_errno(errp
, -ret
, "Could not open '%s': %s",
5347 backing_file
->value
.s
,
5348 error_get_pretty(local_err
));
5349 error_free(local_err
);
5354 bdrv_get_geometry(bs
, &size
);
5357 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
5358 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
5362 error_setg(errp
, "Image creation needs a size parameter");
5368 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
5369 print_option_parameters(param
);
5372 ret
= bdrv_create(drv
, filename
, param
, &local_err
);
5373 if (ret
== -EFBIG
) {
5374 /* This is generally a better message than whatever the driver would
5375 * deliver (especially because of the cluster_size_hint), since that
5376 * is most probably not much different from "image too large". */
5377 const char *cluster_size_hint
= "";
5378 if (get_option_parameter(create_options
, BLOCK_OPT_CLUSTER_SIZE
)) {
5379 cluster_size_hint
= " (try using a larger cluster size)";
5381 error_setg(errp
, "The image size is too large for file format '%s'"
5382 "%s", fmt
, cluster_size_hint
);
5383 error_free(local_err
);
5388 free_option_parameters(create_options
);
5389 free_option_parameters(param
);
5391 if (error_is_set(&local_err
)) {
5392 error_propagate(errp
, local_err
);
5396 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5398 /* Currently BlockDriverState always uses the main loop AioContext */
5399 return qemu_get_aio_context();
5402 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
5403 NotifierWithReturn
*notifier
)
5405 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
5408 int bdrv_amend_options(BlockDriverState
*bs
, QEMUOptionParameter
*options
)
5410 if (bs
->drv
->bdrv_amend_options
== NULL
) {
5413 return bs
->drv
->bdrv_amend_options(bs
, options
);
5416 /* Used to recurse on single child block filters.
5417 * Single child block filter will store their child in bs->file.
5419 bool bdrv_generic_is_first_non_filter(BlockDriverState
*bs
,
5420 BlockDriverState
*candidate
)
5426 if (!bs
->drv
->authorizations
[BS_IS_A_FILTER
]) {
5427 if (bs
== candidate
) {
5434 if (!bs
->drv
->authorizations
[BS_FILTER_PASS_DOWN
]) {
5442 return bdrv_recurse_is_first_non_filter(bs
->file
, candidate
);
5445 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
5446 BlockDriverState
*candidate
)
5448 if (bs
->drv
&& bs
->drv
->bdrv_recurse_is_first_non_filter
) {
5449 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
5452 return bdrv_generic_is_first_non_filter(bs
, candidate
);
5455 /* This function checks if the candidate is the first non filter bs down it's
5456 * bs chain. Since we don't have pointers to parents it explore all bs chains
5457 * from the top. Some filters can choose not to pass down the recursion.
5459 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
5461 BlockDriverState
*bs
;
5463 /* walk down the bs forest recursively */
5464 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5471 perm
= bdrv_recurse_is_first_non_filter(bs
->file
, candidate
);
5473 /* candidate is the first non filter */