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_preadv(BlockDriverState
*bs
,
74 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
75 BdrvRequestFlags flags
);
76 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
77 int64_t offset
, unsigned int bytes
, 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
, is_write
, bytes
);
211 /* if the next request must wait -> do nothing */
212 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
216 /* else queue next request for execution */
217 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
220 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
222 if (!bs
|| !bs
->drv
) {
223 /* 4k should be on the safe side */
227 return bs
->bl
.opt_mem_alignment
;
230 /* check if the path starts with "<protocol>:" */
231 static int path_has_protocol(const char *path
)
236 if (is_windows_drive(path
) ||
237 is_windows_drive_prefix(path
)) {
240 p
= path
+ strcspn(path
, ":/\\");
242 p
= path
+ strcspn(path
, ":/");
248 int path_is_absolute(const char *path
)
251 /* specific case for names like: "\\.\d:" */
252 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
255 return (*path
== '/' || *path
== '\\');
257 return (*path
== '/');
261 /* if filename is absolute, just copy it to dest. Otherwise, build a
262 path to it by considering it is relative to base_path. URL are
264 void path_combine(char *dest
, int dest_size
,
265 const char *base_path
,
266 const char *filename
)
273 if (path_is_absolute(filename
)) {
274 pstrcpy(dest
, dest_size
, filename
);
276 p
= strchr(base_path
, ':');
281 p1
= strrchr(base_path
, '/');
285 p2
= strrchr(base_path
, '\\');
297 if (len
> dest_size
- 1)
299 memcpy(dest
, base_path
, len
);
301 pstrcat(dest
, dest_size
, filename
);
305 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
307 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
308 pstrcpy(dest
, sz
, bs
->backing_file
);
310 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
314 void bdrv_register(BlockDriver
*bdrv
)
316 /* Block drivers without coroutine functions need emulation */
317 if (!bdrv
->bdrv_co_readv
) {
318 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
319 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
321 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
322 * the block driver lacks aio we need to emulate that too.
324 if (!bdrv
->bdrv_aio_readv
) {
325 /* add AIO emulation layer */
326 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
327 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
331 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
334 /* create a new block device (by default it is empty) */
335 BlockDriverState
*bdrv_new(const char *device_name
)
337 BlockDriverState
*bs
;
339 bs
= g_malloc0(sizeof(BlockDriverState
));
340 QLIST_INIT(&bs
->dirty_bitmaps
);
341 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
342 if (device_name
[0] != '\0') {
343 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
345 bdrv_iostatus_disable(bs
);
346 notifier_list_init(&bs
->close_notifiers
);
347 notifier_with_return_list_init(&bs
->before_write_notifiers
);
348 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
349 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
355 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
357 notifier_list_add(&bs
->close_notifiers
, notify
);
360 BlockDriver
*bdrv_find_format(const char *format_name
)
363 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
364 if (!strcmp(drv1
->format_name
, format_name
)) {
371 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
373 static const char *whitelist_rw
[] = {
374 CONFIG_BDRV_RW_WHITELIST
376 static const char *whitelist_ro
[] = {
377 CONFIG_BDRV_RO_WHITELIST
381 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
382 return 1; /* no whitelist, anything goes */
385 for (p
= whitelist_rw
; *p
; p
++) {
386 if (!strcmp(drv
->format_name
, *p
)) {
391 for (p
= whitelist_ro
; *p
; p
++) {
392 if (!strcmp(drv
->format_name
, *p
)) {
400 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
403 BlockDriver
*drv
= bdrv_find_format(format_name
);
404 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
407 typedef struct CreateCo
{
410 QEMUOptionParameter
*options
;
415 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
417 Error
*local_err
= NULL
;
420 CreateCo
*cco
= opaque
;
423 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->options
, &local_err
);
425 error_propagate(&cco
->err
, local_err
);
430 int bdrv_create(BlockDriver
*drv
, const char* filename
,
431 QEMUOptionParameter
*options
, Error
**errp
)
438 .filename
= g_strdup(filename
),
444 if (!drv
->bdrv_create
) {
445 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
450 if (qemu_in_coroutine()) {
451 /* Fast-path if already in coroutine context */
452 bdrv_create_co_entry(&cco
);
454 co
= qemu_coroutine_create(bdrv_create_co_entry
);
455 qemu_coroutine_enter(co
, &cco
);
456 while (cco
.ret
== NOT_DONE
) {
464 error_propagate(errp
, cco
.err
);
466 error_setg_errno(errp
, -ret
, "Could not create image");
471 g_free(cco
.filename
);
475 int bdrv_create_file(const char* filename
, QEMUOptionParameter
*options
,
479 Error
*local_err
= NULL
;
482 drv
= bdrv_find_protocol(filename
, true);
484 error_setg(errp
, "Could not find protocol for file '%s'", filename
);
488 ret
= bdrv_create(drv
, filename
, options
, &local_err
);
490 error_propagate(errp
, local_err
);
495 int bdrv_refresh_limits(BlockDriverState
*bs
)
497 BlockDriver
*drv
= bs
->drv
;
499 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
505 /* Take some limits from the children as a default */
507 bdrv_refresh_limits(bs
->file
);
508 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
509 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
511 bs
->bl
.opt_mem_alignment
= 512;
514 if (bs
->backing_hd
) {
515 bdrv_refresh_limits(bs
->backing_hd
);
516 bs
->bl
.opt_transfer_length
=
517 MAX(bs
->bl
.opt_transfer_length
,
518 bs
->backing_hd
->bl
.opt_transfer_length
);
519 bs
->bl
.opt_mem_alignment
=
520 MAX(bs
->bl
.opt_mem_alignment
,
521 bs
->backing_hd
->bl
.opt_mem_alignment
);
524 /* Then let the driver override it */
525 if (drv
->bdrv_refresh_limits
) {
526 return drv
->bdrv_refresh_limits(bs
);
533 * Create a uniquely-named empty temporary file.
534 * Return 0 upon success, otherwise a negative errno value.
536 int get_tmp_filename(char *filename
, int size
)
539 char temp_dir
[MAX_PATH
];
540 /* GetTempFileName requires that its output buffer (4th param)
541 have length MAX_PATH or greater. */
542 assert(size
>= MAX_PATH
);
543 return (GetTempPath(MAX_PATH
, temp_dir
)
544 && GetTempFileName(temp_dir
, "qem", 0, filename
)
545 ? 0 : -GetLastError());
549 tmpdir
= getenv("TMPDIR");
552 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
555 fd
= mkstemp(filename
);
559 if (close(fd
) != 0) {
568 * Detect host devices. By convention, /dev/cdrom[N] is always
569 * recognized as a host CDROM.
571 static BlockDriver
*find_hdev_driver(const char *filename
)
573 int score_max
= 0, score
;
574 BlockDriver
*drv
= NULL
, *d
;
576 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
577 if (d
->bdrv_probe_device
) {
578 score
= d
->bdrv_probe_device(filename
);
579 if (score
> score_max
) {
589 BlockDriver
*bdrv_find_protocol(const char *filename
,
590 bool allow_protocol_prefix
)
597 /* TODO Drivers without bdrv_file_open must be specified explicitly */
600 * XXX(hch): we really should not let host device detection
601 * override an explicit protocol specification, but moving this
602 * later breaks access to device names with colons in them.
603 * Thanks to the brain-dead persistent naming schemes on udev-
604 * based Linux systems those actually are quite common.
606 drv1
= find_hdev_driver(filename
);
611 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
612 return bdrv_find_format("file");
615 p
= strchr(filename
, ':');
618 if (len
> sizeof(protocol
) - 1)
619 len
= sizeof(protocol
) - 1;
620 memcpy(protocol
, filename
, len
);
621 protocol
[len
] = '\0';
622 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
623 if (drv1
->protocol_name
&&
624 !strcmp(drv1
->protocol_name
, protocol
)) {
631 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
632 BlockDriver
**pdrv
, Error
**errp
)
634 int score
, score_max
;
635 BlockDriver
*drv1
, *drv
;
639 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
640 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
641 drv
= bdrv_find_format("raw");
643 error_setg(errp
, "Could not find raw image format");
650 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
652 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
660 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
661 if (drv1
->bdrv_probe
) {
662 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
663 if (score
> score_max
) {
670 error_setg(errp
, "Could not determine image format: No compatible "
679 * Set the current 'total_sectors' value
681 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
683 BlockDriver
*drv
= bs
->drv
;
685 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
689 /* query actual device if possible, otherwise just trust the hint */
690 if (drv
->bdrv_getlength
) {
691 int64_t length
= drv
->bdrv_getlength(bs
);
695 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
698 bs
->total_sectors
= hint
;
703 * Set open flags for a given discard mode
705 * Return 0 on success, -1 if the discard mode was invalid.
707 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
709 *flags
&= ~BDRV_O_UNMAP
;
711 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
713 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
714 *flags
|= BDRV_O_UNMAP
;
723 * Set open flags for a given cache mode
725 * Return 0 on success, -1 if the cache mode was invalid.
727 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
729 *flags
&= ~BDRV_O_CACHE_MASK
;
731 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
732 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
733 } else if (!strcmp(mode
, "directsync")) {
734 *flags
|= BDRV_O_NOCACHE
;
735 } else if (!strcmp(mode
, "writeback")) {
736 *flags
|= BDRV_O_CACHE_WB
;
737 } else if (!strcmp(mode
, "unsafe")) {
738 *flags
|= BDRV_O_CACHE_WB
;
739 *flags
|= BDRV_O_NO_FLUSH
;
740 } else if (!strcmp(mode
, "writethrough")) {
741 /* this is the default */
750 * The copy-on-read flag is actually a reference count so multiple users may
751 * use the feature without worrying about clobbering its previous state.
752 * Copy-on-read stays enabled until all users have called to disable it.
754 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
759 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
761 assert(bs
->copy_on_read
> 0);
765 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
767 int open_flags
= flags
| BDRV_O_CACHE_WB
;
770 * Clear flags that are internal to the block layer before opening the
773 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
776 * Snapshots should be writable.
778 if (bs
->is_temporary
) {
779 open_flags
|= BDRV_O_RDWR
;
785 static int bdrv_assign_node_name(BlockDriverState
*bs
,
786 const char *node_name
,
793 /* empty string node name is invalid */
794 if (node_name
[0] == '\0') {
795 error_setg(errp
, "Empty node name");
799 /* takes care of avoiding namespaces collisions */
800 if (bdrv_find(node_name
)) {
801 error_setg(errp
, "node-name=%s is conflicting with a device id",
806 /* takes care of avoiding duplicates node names */
807 if (bdrv_find_node(node_name
)) {
808 error_setg(errp
, "Duplicate node name");
812 /* copy node name into the bs and insert it into the graph list */
813 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
814 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
820 * Common part for opening disk images and files
822 * Removes all processed options from *options.
824 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
825 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
828 const char *filename
;
829 const char *node_name
= NULL
;
830 Error
*local_err
= NULL
;
833 assert(bs
->file
== NULL
);
834 assert(options
!= NULL
&& bs
->options
!= options
);
837 filename
= file
->filename
;
839 filename
= qdict_get_try_str(options
, "filename");
842 if (drv
->bdrv_needs_filename
&& !filename
) {
843 error_setg(errp
, "The '%s' block driver requires a file name",
848 trace_bdrv_open_common(bs
, filename
?: "", flags
, drv
->format_name
);
850 node_name
= qdict_get_try_str(options
, "node-name");
851 ret
= bdrv_assign_node_name(bs
, node_name
, errp
);
855 qdict_del(options
, "node-name");
857 /* bdrv_open() with directly using a protocol as drv. This layer is already
858 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
859 * and return immediately. */
860 if (file
!= NULL
&& drv
->bdrv_file_open
) {
865 bs
->open_flags
= flags
;
866 bs
->guest_block_size
= 512;
867 bs
->request_alignment
= 512;
868 bs
->zero_beyond_eof
= true;
869 open_flags
= bdrv_open_flags(bs
, flags
);
870 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
872 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
874 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
875 ? "Driver '%s' can only be used for read-only devices"
876 : "Driver '%s' is not whitelisted",
881 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
882 if (flags
& BDRV_O_COPY_ON_READ
) {
883 if (!bs
->read_only
) {
884 bdrv_enable_copy_on_read(bs
);
886 error_setg(errp
, "Can't use copy-on-read on read-only device");
891 if (filename
!= NULL
) {
892 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
894 bs
->filename
[0] = '\0';
898 bs
->opaque
= g_malloc0(drv
->instance_size
);
900 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
902 /* Open the image, either directly or using a protocol */
903 if (drv
->bdrv_file_open
) {
904 assert(file
== NULL
);
905 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
906 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
909 error_setg(errp
, "Can't use '%s' as a block driver for the "
910 "protocol level", drv
->format_name
);
915 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
920 error_propagate(errp
, local_err
);
921 } else if (bs
->filename
[0]) {
922 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
924 error_setg_errno(errp
, -ret
, "Could not open image");
929 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
931 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
935 bdrv_refresh_limits(bs
);
936 assert(bdrv_opt_mem_align(bs
) != 0);
937 assert(bs
->request_alignment
!= 0);
940 if (bs
->is_temporary
) {
941 assert(bs
->filename
[0] != '\0');
942 unlink(bs
->filename
);
956 * Opens a file using a protocol (file, host_device, nbd, ...)
958 * options is an indirect pointer to a QDict of options to pass to the block
959 * drivers, or pointer to NULL for an empty set of options. If this function
960 * takes ownership of the QDict reference, it will set *options to NULL;
961 * otherwise, it will contain unused/unrecognized options after this function
962 * returns. Then, the caller is responsible for freeing it. If it intends to
963 * reuse the QDict, QINCREF() should be called beforehand.
965 static int bdrv_file_open(BlockDriverState
*bs
, const char *filename
,
966 QDict
**options
, int flags
, Error
**errp
)
970 bool allow_protocol_prefix
= false;
971 Error
*local_err
= NULL
;
974 /* Fetch the file name from the options QDict if necessary */
976 filename
= qdict_get_try_str(*options
, "filename");
977 } else if (filename
&& !qdict_haskey(*options
, "filename")) {
978 qdict_put(*options
, "filename", qstring_from_str(filename
));
979 allow_protocol_prefix
= true;
981 error_setg(errp
, "Can't specify 'file' and 'filename' options at the "
987 /* Find the right block driver */
988 drvname
= qdict_get_try_str(*options
, "driver");
990 drv
= bdrv_find_format(drvname
);
992 error_setg(errp
, "Unknown driver '%s'", drvname
);
994 qdict_del(*options
, "driver");
995 } else if (filename
) {
996 drv
= bdrv_find_protocol(filename
, allow_protocol_prefix
);
998 error_setg(errp
, "Unknown protocol");
1001 error_setg(errp
, "Must specify either driver or file");
1006 /* errp has been set already */
1011 /* Parse the filename and open it */
1012 if (drv
->bdrv_parse_filename
&& filename
) {
1013 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1015 error_propagate(errp
, local_err
);
1019 qdict_del(*options
, "filename");
1022 if (!drv
->bdrv_file_open
) {
1023 ret
= bdrv_open(&bs
, filename
, NULL
, *options
, flags
, drv
, &local_err
);
1026 ret
= bdrv_open_common(bs
, NULL
, *options
, flags
, drv
, &local_err
);
1029 error_propagate(errp
, local_err
);
1041 * Opens the backing file for a BlockDriverState if not yet open
1043 * options is a QDict of options to pass to the block drivers, or NULL for an
1044 * empty set of options. The reference to the QDict is transferred to this
1045 * function (even on failure), so if the caller intends to reuse the dictionary,
1046 * it needs to use QINCREF() before calling bdrv_file_open.
1048 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1050 char backing_filename
[PATH_MAX
];
1051 int back_flags
, ret
;
1052 BlockDriver
*back_drv
= NULL
;
1053 Error
*local_err
= NULL
;
1055 if (bs
->backing_hd
!= NULL
) {
1060 /* NULL means an empty set of options */
1061 if (options
== NULL
) {
1062 options
= qdict_new();
1065 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1066 if (qdict_haskey(options
, "file.filename")) {
1067 backing_filename
[0] = '\0';
1068 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1072 bdrv_get_full_backing_filename(bs
, backing_filename
,
1073 sizeof(backing_filename
));
1076 if (bs
->backing_format
[0] != '\0') {
1077 back_drv
= bdrv_find_format(bs
->backing_format
);
1080 /* backing files always opened read-only */
1081 back_flags
= bs
->open_flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
|
1082 BDRV_O_COPY_ON_READ
);
1084 assert(bs
->backing_hd
== NULL
);
1085 ret
= bdrv_open(&bs
->backing_hd
,
1086 *backing_filename
? backing_filename
: NULL
, NULL
, options
,
1087 back_flags
, back_drv
, &local_err
);
1089 bs
->backing_hd
= NULL
;
1090 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1091 error_setg(errp
, "Could not open backing file: %s",
1092 error_get_pretty(local_err
));
1093 error_free(local_err
);
1097 if (bs
->backing_hd
->file
) {
1098 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
),
1099 bs
->backing_hd
->file
->filename
);
1102 /* Recalculate the BlockLimits with the backing file */
1103 bdrv_refresh_limits(bs
);
1109 * Opens a disk image whose options are given as BlockdevRef in another block
1112 * If force_raw is true, bdrv_file_open() will be used, thereby preventing any
1113 * image format auto-detection. If it is false and a filename is given,
1114 * bdrv_open() will be used for auto-detection.
1116 * If allow_none is true, no image will be opened if filename is false and no
1117 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1119 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1120 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1121 * itself, all options starting with "${bdref_key}." are considered part of the
1124 * The BlockdevRef will be removed from the options QDict.
1126 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1128 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1129 QDict
*options
, const char *bdref_key
, int flags
,
1130 bool force_raw
, bool allow_none
, Error
**errp
)
1132 QDict
*image_options
;
1134 char *bdref_key_dot
;
1135 const char *reference
;
1138 assert(*pbs
== NULL
);
1140 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1141 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1142 g_free(bdref_key_dot
);
1144 reference
= qdict_get_try_str(options
, bdref_key
);
1145 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1149 error_setg(errp
, "A block device must be specified for \"%s\"",
1156 if (filename
&& !force_raw
) {
1157 /* If a filename is given and the block driver should be detected
1158 automatically (instead of using none), use bdrv_open() in order to do
1159 that auto-detection. */
1161 error_setg(errp
, "Cannot reference an existing block device while "
1162 "giving a filename");
1167 ret
= bdrv_open(pbs
, filename
, NULL
, image_options
, flags
, NULL
, errp
);
1169 ret
= bdrv_open(pbs
, filename
, reference
, image_options
,
1170 flags
| BDRV_O_PROTOCOL
, NULL
, errp
);
1174 qdict_del(options
, bdref_key
);
1179 * Opens a disk image (raw, qcow2, vmdk, ...)
1181 * options is a QDict of options to pass to the block drivers, or NULL for an
1182 * empty set of options. The reference to the QDict belongs to the block layer
1183 * after the call (even on failure), so if the caller intends to reuse the
1184 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1186 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1187 * If it is not NULL, the referenced BDS will be reused.
1189 * The reference parameter may be used to specify an existing block device which
1190 * should be opened. If specified, neither options nor a filename may be given,
1191 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1193 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1194 const char *reference
, QDict
*options
, int flags
,
1195 BlockDriver
*drv
, Error
**errp
)
1198 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1199 char tmp_filename
[PATH_MAX
+ 1];
1200 BlockDriverState
*file
= NULL
, *bs
;
1201 const char *drvname
;
1202 Error
*local_err
= NULL
;
1207 bool options_non_empty
= options
? qdict_size(options
) : false;
1211 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1212 "another block device");
1216 if (filename
|| options_non_empty
) {
1217 error_setg(errp
, "Cannot reference an existing block device with "
1218 "additional options or a new filename");
1222 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
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 if (flags
& BDRV_O_PROTOCOL
) {
1247 ret
= bdrv_file_open(bs
, filename
, &options
, flags
& ~BDRV_O_PROTOCOL
,
1251 } else if (bs
->drv
) {
1252 goto close_and_fail
;
1258 /* For snapshot=on, create a temporary qcow2 overlay */
1259 if (flags
& BDRV_O_SNAPSHOT
) {
1260 BlockDriverState
*bs1
;
1262 BlockDriver
*bdrv_qcow2
;
1263 QEMUOptionParameter
*create_options
;
1264 QDict
*snapshot_options
;
1266 /* if snapshot, we create a temporary backing file and open it
1267 instead of opening 'filename' directly */
1269 /* Get the required size from the image */
1272 ret
= bdrv_open(&bs1
, filename
, NULL
, options
, BDRV_O_NO_BACKING
,
1277 total_size
= bdrv_getlength(bs1
) & BDRV_SECTOR_MASK
;
1281 /* Create the temporary image */
1282 ret
= get_tmp_filename(tmp_filename
, sizeof(tmp_filename
));
1284 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1288 bdrv_qcow2
= bdrv_find_format("qcow2");
1289 create_options
= parse_option_parameters("", bdrv_qcow2
->create_options
,
1292 set_option_parameter_int(create_options
, BLOCK_OPT_SIZE
, total_size
);
1294 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, create_options
, &local_err
);
1295 free_option_parameters(create_options
);
1297 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1298 "'%s': %s", tmp_filename
,
1299 error_get_pretty(local_err
));
1300 error_free(local_err
);
1305 /* Prepare a new options QDict for the temporary file, where user
1306 * options refer to the backing file */
1308 qdict_put(options
, "file.filename", qstring_from_str(filename
));
1311 qdict_put(options
, "driver", qstring_from_str(drv
->format_name
));
1314 snapshot_options
= qdict_new();
1315 qdict_put(snapshot_options
, "backing", options
);
1316 qdict_flatten(snapshot_options
);
1318 bs
->options
= snapshot_options
;
1319 options
= qdict_clone_shallow(bs
->options
);
1321 filename
= tmp_filename
;
1323 bs
->is_temporary
= 1;
1326 /* Open image file without format layer */
1327 if (flags
& BDRV_O_RDWR
) {
1328 flags
|= BDRV_O_ALLOW_RDWR
;
1331 assert(file
== NULL
);
1332 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1333 bdrv_open_flags(bs
, flags
| BDRV_O_UNMAP
), true, true,
1339 /* Find the right image format driver */
1340 drvname
= qdict_get_try_str(options
, "driver");
1342 drv
= bdrv_find_format(drvname
);
1343 qdict_del(options
, "driver");
1345 error_setg(errp
, "Invalid driver: '%s'", drvname
);
1347 goto unlink_and_fail
;
1353 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1355 error_setg(errp
, "Must specify either driver or file");
1357 goto unlink_and_fail
;
1362 goto unlink_and_fail
;
1365 /* Open the image */
1366 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1368 goto unlink_and_fail
;
1371 if (file
&& (bs
->file
!= file
)) {
1376 /* If there is a backing file, use it */
1377 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1378 QDict
*backing_options
;
1380 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1381 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1383 goto close_and_fail
;
1388 /* Check if any unknown options were used */
1389 if (options
&& (qdict_size(options
) != 0)) {
1390 const QDictEntry
*entry
= qdict_first(options
);
1391 if (flags
& BDRV_O_PROTOCOL
) {
1392 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1393 "'%s'", drv
->format_name
, entry
->key
);
1395 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1396 "support the option '%s'", drv
->format_name
,
1397 bs
->device_name
, entry
->key
);
1401 goto close_and_fail
;
1405 if (!bdrv_key_required(bs
)) {
1406 bdrv_dev_change_media_cb(bs
, true);
1416 if (bs
->is_temporary
) {
1420 QDECREF(bs
->options
);
1424 /* If *pbs is NULL, a new BDS has been created in this function and
1425 needs to be freed now. Otherwise, it does not need to be closed,
1426 since it has not really been opened yet. */
1430 error_propagate(errp
, local_err
);
1435 /* See fail path, but now the BDS has to be always closed */
1443 error_propagate(errp
, local_err
);
1448 typedef struct BlockReopenQueueEntry
{
1450 BDRVReopenState state
;
1451 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1452 } BlockReopenQueueEntry
;
1455 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1456 * reopen of multiple devices.
1458 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1459 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1460 * be created and initialized. This newly created BlockReopenQueue should be
1461 * passed back in for subsequent calls that are intended to be of the same
1464 * bs is the BlockDriverState to add to the reopen queue.
1466 * flags contains the open flags for the associated bs
1468 * returns a pointer to bs_queue, which is either the newly allocated
1469 * bs_queue, or the existing bs_queue being used.
1472 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1473 BlockDriverState
*bs
, int flags
)
1477 BlockReopenQueueEntry
*bs_entry
;
1478 if (bs_queue
== NULL
) {
1479 bs_queue
= g_new0(BlockReopenQueue
, 1);
1480 QSIMPLEQ_INIT(bs_queue
);
1484 bdrv_reopen_queue(bs_queue
, bs
->file
, flags
);
1487 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1488 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1490 bs_entry
->state
.bs
= bs
;
1491 bs_entry
->state
.flags
= flags
;
1497 * Reopen multiple BlockDriverStates atomically & transactionally.
1499 * The queue passed in (bs_queue) must have been built up previous
1500 * via bdrv_reopen_queue().
1502 * Reopens all BDS specified in the queue, with the appropriate
1503 * flags. All devices are prepared for reopen, and failure of any
1504 * device will cause all device changes to be abandonded, and intermediate
1507 * If all devices prepare successfully, then the changes are committed
1511 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1514 BlockReopenQueueEntry
*bs_entry
, *next
;
1515 Error
*local_err
= NULL
;
1517 assert(bs_queue
!= NULL
);
1521 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1522 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1523 error_propagate(errp
, local_err
);
1526 bs_entry
->prepared
= true;
1529 /* If we reach this point, we have success and just need to apply the
1532 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1533 bdrv_reopen_commit(&bs_entry
->state
);
1539 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1540 if (ret
&& bs_entry
->prepared
) {
1541 bdrv_reopen_abort(&bs_entry
->state
);
1550 /* Reopen a single BlockDriverState with the specified flags. */
1551 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1554 Error
*local_err
= NULL
;
1555 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1557 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1558 if (local_err
!= NULL
) {
1559 error_propagate(errp
, local_err
);
1566 * Prepares a BlockDriverState for reopen. All changes are staged in the
1567 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1568 * the block driver layer .bdrv_reopen_prepare()
1570 * bs is the BlockDriverState to reopen
1571 * flags are the new open flags
1572 * queue is the reopen queue
1574 * Returns 0 on success, non-zero on error. On error errp will be set
1577 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1578 * It is the responsibility of the caller to then call the abort() or
1579 * commit() for any other BDS that have been left in a prepare() state
1582 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1586 Error
*local_err
= NULL
;
1589 assert(reopen_state
!= NULL
);
1590 assert(reopen_state
->bs
->drv
!= NULL
);
1591 drv
= reopen_state
->bs
->drv
;
1593 /* if we are to stay read-only, do not allow permission change
1595 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1596 reopen_state
->flags
& BDRV_O_RDWR
) {
1597 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1598 reopen_state
->bs
->device_name
);
1603 ret
= bdrv_flush(reopen_state
->bs
);
1605 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1610 if (drv
->bdrv_reopen_prepare
) {
1611 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1613 if (local_err
!= NULL
) {
1614 error_propagate(errp
, local_err
);
1616 error_setg(errp
, "failed while preparing to reopen image '%s'",
1617 reopen_state
->bs
->filename
);
1622 /* It is currently mandatory to have a bdrv_reopen_prepare()
1623 * handler for each supported drv. */
1624 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1625 drv
->format_name
, reopen_state
->bs
->device_name
,
1626 "reopening of file");
1638 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1639 * makes them final by swapping the staging BlockDriverState contents into
1640 * the active BlockDriverState contents.
1642 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1646 assert(reopen_state
!= NULL
);
1647 drv
= reopen_state
->bs
->drv
;
1648 assert(drv
!= NULL
);
1650 /* If there are any driver level actions to take */
1651 if (drv
->bdrv_reopen_commit
) {
1652 drv
->bdrv_reopen_commit(reopen_state
);
1655 /* set BDS specific flags now */
1656 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1657 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1659 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1661 bdrv_refresh_limits(reopen_state
->bs
);
1665 * Abort the reopen, and delete and free the staged changes in
1668 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1672 assert(reopen_state
!= NULL
);
1673 drv
= reopen_state
->bs
->drv
;
1674 assert(drv
!= NULL
);
1676 if (drv
->bdrv_reopen_abort
) {
1677 drv
->bdrv_reopen_abort(reopen_state
);
1682 void bdrv_close(BlockDriverState
*bs
)
1685 block_job_cancel_sync(bs
->job
);
1687 bdrv_drain_all(); /* complete I/O */
1689 bdrv_drain_all(); /* in case flush left pending I/O */
1690 notifier_list_notify(&bs
->close_notifiers
, bs
);
1693 if (bs
->backing_hd
) {
1694 bdrv_unref(bs
->backing_hd
);
1695 bs
->backing_hd
= NULL
;
1697 bs
->drv
->bdrv_close(bs
);
1700 if (bs
->is_temporary
) {
1701 unlink(bs
->filename
);
1706 bs
->copy_on_read
= 0;
1707 bs
->backing_file
[0] = '\0';
1708 bs
->backing_format
[0] = '\0';
1709 bs
->total_sectors
= 0;
1714 bs
->zero_beyond_eof
= false;
1715 QDECREF(bs
->options
);
1718 if (bs
->file
!= NULL
) {
1719 bdrv_unref(bs
->file
);
1724 bdrv_dev_change_media_cb(bs
, false);
1726 /*throttling disk I/O limits*/
1727 if (bs
->io_limits_enabled
) {
1728 bdrv_io_limits_disable(bs
);
1732 void bdrv_close_all(void)
1734 BlockDriverState
*bs
;
1736 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1741 /* Check if any requests are in-flight (including throttled requests) */
1742 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1744 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1747 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1750 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1753 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1756 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1762 static bool bdrv_requests_pending_all(void)
1764 BlockDriverState
*bs
;
1765 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1766 if (bdrv_requests_pending(bs
)) {
1774 * Wait for pending requests to complete across all BlockDriverStates
1776 * This function does not flush data to disk, use bdrv_flush_all() for that
1777 * after calling this function.
1779 * Note that completion of an asynchronous I/O operation can trigger any
1780 * number of other I/O operations on other devices---for example a coroutine
1781 * can be arbitrarily complex and a constant flow of I/O can come until the
1782 * coroutine is complete. Because of this, it is not possible to have a
1783 * function to drain a single device's I/O queue.
1785 void bdrv_drain_all(void)
1787 /* Always run first iteration so any pending completion BHs run */
1789 BlockDriverState
*bs
;
1792 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1793 bdrv_start_throttled_reqs(bs
);
1796 busy
= bdrv_requests_pending_all();
1797 busy
|= aio_poll(qemu_get_aio_context(), busy
);
1801 /* make a BlockDriverState anonymous by removing from bdrv_state and
1802 * graph_bdrv_state list.
1803 Also, NULL terminate the device_name to prevent double remove */
1804 void bdrv_make_anon(BlockDriverState
*bs
)
1806 if (bs
->device_name
[0] != '\0') {
1807 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1809 bs
->device_name
[0] = '\0';
1810 if (bs
->node_name
[0] != '\0') {
1811 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1813 bs
->node_name
[0] = '\0';
1816 static void bdrv_rebind(BlockDriverState
*bs
)
1818 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1819 bs
->drv
->bdrv_rebind(bs
);
1823 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1824 BlockDriverState
*bs_src
)
1826 /* move some fields that need to stay attached to the device */
1827 bs_dest
->open_flags
= bs_src
->open_flags
;
1830 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1831 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1832 bs_dest
->dev
= bs_src
->dev
;
1833 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1834 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1836 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1838 /* i/o throttled req */
1839 memcpy(&bs_dest
->throttle_state
,
1840 &bs_src
->throttle_state
,
1841 sizeof(ThrottleState
));
1842 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1843 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1844 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1847 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1848 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1851 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1852 bs_dest
->iostatus
= bs_src
->iostatus
;
1855 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1857 /* reference count */
1858 bs_dest
->refcnt
= bs_src
->refcnt
;
1861 bs_dest
->in_use
= bs_src
->in_use
;
1862 bs_dest
->job
= bs_src
->job
;
1864 /* keep the same entry in bdrv_states */
1865 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1866 bs_src
->device_name
);
1867 bs_dest
->device_list
= bs_src
->device_list
;
1869 /* keep the same entry in graph_bdrv_states
1870 * We do want to swap name but don't want to swap linked list entries
1872 bs_dest
->node_list
= bs_src
->node_list
;
1876 * Swap bs contents for two image chains while they are live,
1877 * while keeping required fields on the BlockDriverState that is
1878 * actually attached to a device.
1880 * This will modify the BlockDriverState fields, and swap contents
1881 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1883 * bs_new is required to be anonymous.
1885 * This function does not create any image files.
1887 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
1889 BlockDriverState tmp
;
1891 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1892 assert(bs_new
->device_name
[0] == '\0');
1893 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
1894 assert(bs_new
->job
== NULL
);
1895 assert(bs_new
->dev
== NULL
);
1896 assert(bs_new
->in_use
== 0);
1897 assert(bs_new
->io_limits_enabled
== false);
1898 assert(!throttle_have_timer(&bs_new
->throttle_state
));
1904 /* there are some fields that should not be swapped, move them back */
1905 bdrv_move_feature_fields(&tmp
, bs_old
);
1906 bdrv_move_feature_fields(bs_old
, bs_new
);
1907 bdrv_move_feature_fields(bs_new
, &tmp
);
1909 /* bs_new shouldn't be in bdrv_states even after the swap! */
1910 assert(bs_new
->device_name
[0] == '\0');
1912 /* Check a few fields that should remain attached to the device */
1913 assert(bs_new
->dev
== NULL
);
1914 assert(bs_new
->job
== NULL
);
1915 assert(bs_new
->in_use
== 0);
1916 assert(bs_new
->io_limits_enabled
== false);
1917 assert(!throttle_have_timer(&bs_new
->throttle_state
));
1919 bdrv_rebind(bs_new
);
1920 bdrv_rebind(bs_old
);
1924 * Add new bs contents at the top of an image chain while the chain is
1925 * live, while keeping required fields on the top layer.
1927 * This will modify the BlockDriverState fields, and swap contents
1928 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1930 * bs_new is required to be anonymous.
1932 * This function does not create any image files.
1934 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
1936 bdrv_swap(bs_new
, bs_top
);
1938 /* The contents of 'tmp' will become bs_top, as we are
1939 * swapping bs_new and bs_top contents. */
1940 bs_top
->backing_hd
= bs_new
;
1941 bs_top
->open_flags
&= ~BDRV_O_NO_BACKING
;
1942 pstrcpy(bs_top
->backing_file
, sizeof(bs_top
->backing_file
),
1944 pstrcpy(bs_top
->backing_format
, sizeof(bs_top
->backing_format
),
1945 bs_new
->drv
? bs_new
->drv
->format_name
: "");
1948 static void bdrv_delete(BlockDriverState
*bs
)
1952 assert(!bs
->in_use
);
1953 assert(!bs
->refcnt
);
1954 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
1958 /* remove from list, if necessary */
1964 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
1965 /* TODO change to DeviceState *dev when all users are qdevified */
1971 bdrv_iostatus_reset(bs
);
1975 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1976 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
1978 if (bdrv_attach_dev(bs
, dev
) < 0) {
1983 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
1984 /* TODO change to DeviceState *dev when all users are qdevified */
1986 assert(bs
->dev
== dev
);
1989 bs
->dev_opaque
= NULL
;
1990 bs
->guest_block_size
= 512;
1993 /* TODO change to return DeviceState * when all users are qdevified */
1994 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
1999 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
2003 bs
->dev_opaque
= opaque
;
2006 void bdrv_emit_qmp_error_event(const BlockDriverState
*bdrv
,
2007 enum MonitorEvent ev
,
2008 BlockErrorAction action
, bool is_read
)
2011 const char *action_str
;
2014 case BDRV_ACTION_REPORT
:
2015 action_str
= "report";
2017 case BDRV_ACTION_IGNORE
:
2018 action_str
= "ignore";
2020 case BDRV_ACTION_STOP
:
2021 action_str
= "stop";
2027 data
= qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
2030 is_read
? "read" : "write");
2031 monitor_protocol_event(ev
, data
);
2033 qobject_decref(data
);
2036 static void bdrv_emit_qmp_eject_event(BlockDriverState
*bs
, bool ejected
)
2040 data
= qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
2041 bdrv_get_device_name(bs
), ejected
);
2042 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED
, data
);
2044 qobject_decref(data
);
2047 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
2049 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
2050 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
2051 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
2052 if (tray_was_closed
) {
2054 bdrv_emit_qmp_eject_event(bs
, true);
2058 bdrv_emit_qmp_eject_event(bs
, false);
2063 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
2065 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
2068 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
2070 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
2071 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
2075 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
2077 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
2078 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
2083 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
2085 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
2086 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
2090 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
2092 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
2093 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
2099 * Run consistency checks on an image
2101 * Returns 0 if the check could be completed (it doesn't mean that the image is
2102 * free of errors) or -errno when an internal error occurred. The results of the
2103 * check are stored in res.
2105 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2107 if (bs
->drv
->bdrv_check
== NULL
) {
2111 memset(res
, 0, sizeof(*res
));
2112 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2115 #define COMMIT_BUF_SECTORS 2048
2117 /* commit COW file into the raw image */
2118 int bdrv_commit(BlockDriverState
*bs
)
2120 BlockDriver
*drv
= bs
->drv
;
2121 int64_t sector
, total_sectors
, length
, backing_length
;
2122 int n
, ro
, open_flags
;
2124 uint8_t *buf
= NULL
;
2125 char filename
[PATH_MAX
];
2130 if (!bs
->backing_hd
) {
2134 if (bdrv_in_use(bs
) || bdrv_in_use(bs
->backing_hd
)) {
2138 ro
= bs
->backing_hd
->read_only
;
2139 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2140 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
2141 open_flags
= bs
->backing_hd
->open_flags
;
2144 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2149 length
= bdrv_getlength(bs
);
2155 backing_length
= bdrv_getlength(bs
->backing_hd
);
2156 if (backing_length
< 0) {
2157 ret
= backing_length
;
2161 /* If our top snapshot is larger than the backing file image,
2162 * grow the backing file image if possible. If not possible,
2163 * we must return an error */
2164 if (length
> backing_length
) {
2165 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2171 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2172 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2174 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2175 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2180 ret
= bdrv_read(bs
, sector
, buf
, n
);
2185 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2192 if (drv
->bdrv_make_empty
) {
2193 ret
= drv
->bdrv_make_empty(bs
);
2201 * Make sure all data we wrote to the backing device is actually
2204 if (bs
->backing_hd
) {
2205 bdrv_flush(bs
->backing_hd
);
2213 /* ignoring error return here */
2214 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2220 int bdrv_commit_all(void)
2222 BlockDriverState
*bs
;
2224 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2225 if (bs
->drv
&& bs
->backing_hd
) {
2226 int ret
= bdrv_commit(bs
);
2236 * Remove an active request from the tracked requests list
2238 * This function should be called when a tracked request is completing.
2240 static void tracked_request_end(BdrvTrackedRequest
*req
)
2242 if (req
->serialising
) {
2243 req
->bs
->serialising_in_flight
--;
2246 QLIST_REMOVE(req
, list
);
2247 qemu_co_queue_restart_all(&req
->wait_queue
);
2251 * Add an active request to the tracked requests list
2253 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2254 BlockDriverState
*bs
,
2256 unsigned int bytes
, bool is_write
)
2258 *req
= (BdrvTrackedRequest
){
2262 .is_write
= is_write
,
2263 .co
= qemu_coroutine_self(),
2264 .serialising
= false,
2265 .overlap_offset
= offset
,
2266 .overlap_bytes
= bytes
,
2269 qemu_co_queue_init(&req
->wait_queue
);
2271 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2274 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2276 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2277 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2280 if (!req
->serialising
) {
2281 req
->bs
->serialising_in_flight
++;
2282 req
->serialising
= true;
2285 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2286 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2290 * Round a region to cluster boundaries
2292 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2293 int64_t sector_num
, int nb_sectors
,
2294 int64_t *cluster_sector_num
,
2295 int *cluster_nb_sectors
)
2297 BlockDriverInfo bdi
;
2299 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2300 *cluster_sector_num
= sector_num
;
2301 *cluster_nb_sectors
= nb_sectors
;
2303 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2304 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2305 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2310 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2312 BlockDriverInfo bdi
;
2315 ret
= bdrv_get_info(bs
, &bdi
);
2316 if (ret
< 0 || bdi
.cluster_size
== 0) {
2317 return bs
->request_alignment
;
2319 return bdi
.cluster_size
;
2323 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2324 int64_t offset
, unsigned int bytes
)
2327 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2331 if (req
->overlap_offset
>= offset
+ bytes
) {
2337 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2339 BlockDriverState
*bs
= self
->bs
;
2340 BdrvTrackedRequest
*req
;
2342 bool waited
= false;
2344 if (!bs
->serialising_in_flight
) {
2350 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2351 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2354 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2355 self
->overlap_bytes
))
2357 /* Hitting this means there was a reentrant request, for
2358 * example, a block driver issuing nested requests. This must
2359 * never happen since it means deadlock.
2361 assert(qemu_coroutine_self() != req
->co
);
2363 /* If the request is already (indirectly) waiting for us, or
2364 * will wait for us as soon as it wakes up, then just go on
2365 * (instead of producing a deadlock in the former case). */
2366 if (!req
->waiting_for
) {
2367 self
->waiting_for
= req
;
2368 qemu_co_queue_wait(&req
->wait_queue
);
2369 self
->waiting_for
= NULL
;
2384 * -EINVAL - backing format specified, but no file
2385 * -ENOSPC - can't update the backing file because no space is left in the
2387 * -ENOTSUP - format driver doesn't support changing the backing file
2389 int bdrv_change_backing_file(BlockDriverState
*bs
,
2390 const char *backing_file
, const char *backing_fmt
)
2392 BlockDriver
*drv
= bs
->drv
;
2395 /* Backing file format doesn't make sense without a backing file */
2396 if (backing_fmt
&& !backing_file
) {
2400 if (drv
->bdrv_change_backing_file
!= NULL
) {
2401 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2407 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file
?: "");
2408 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt
?: "");
2414 * Finds the image layer in the chain that has 'bs' as its backing file.
2416 * active is the current topmost image.
2418 * Returns NULL if bs is not found in active's image chain,
2419 * or if active == bs.
2421 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2422 BlockDriverState
*bs
)
2424 BlockDriverState
*overlay
= NULL
;
2425 BlockDriverState
*intermediate
;
2427 assert(active
!= NULL
);
2430 /* if bs is the same as active, then by definition it has no overlay
2436 intermediate
= active
;
2437 while (intermediate
->backing_hd
) {
2438 if (intermediate
->backing_hd
== bs
) {
2439 overlay
= intermediate
;
2442 intermediate
= intermediate
->backing_hd
;
2448 typedef struct BlkIntermediateStates
{
2449 BlockDriverState
*bs
;
2450 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2451 } BlkIntermediateStates
;
2455 * Drops images above 'base' up to and including 'top', and sets the image
2456 * above 'top' to have base as its backing file.
2458 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2459 * information in 'bs' can be properly updated.
2461 * E.g., this will convert the following chain:
2462 * bottom <- base <- intermediate <- top <- active
2466 * bottom <- base <- active
2468 * It is allowed for bottom==base, in which case it converts:
2470 * base <- intermediate <- top <- active
2477 * if active == top, that is considered an error
2480 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2481 BlockDriverState
*base
)
2483 BlockDriverState
*intermediate
;
2484 BlockDriverState
*base_bs
= NULL
;
2485 BlockDriverState
*new_top_bs
= NULL
;
2486 BlkIntermediateStates
*intermediate_state
, *next
;
2489 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2490 QSIMPLEQ_INIT(&states_to_delete
);
2492 if (!top
->drv
|| !base
->drv
) {
2496 new_top_bs
= bdrv_find_overlay(active
, top
);
2498 if (new_top_bs
== NULL
) {
2499 /* we could not find the image above 'top', this is an error */
2503 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2504 * to do, no intermediate images */
2505 if (new_top_bs
->backing_hd
== base
) {
2512 /* now we will go down through the list, and add each BDS we find
2513 * into our deletion queue, until we hit the 'base'
2515 while (intermediate
) {
2516 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
2517 intermediate_state
->bs
= intermediate
;
2518 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2520 if (intermediate
->backing_hd
== base
) {
2521 base_bs
= intermediate
->backing_hd
;
2524 intermediate
= intermediate
->backing_hd
;
2526 if (base_bs
== NULL
) {
2527 /* something went wrong, we did not end at the base. safely
2528 * unravel everything, and exit with error */
2532 /* success - we can delete the intermediate states, and link top->base */
2533 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
2534 base_bs
->drv
? base_bs
->drv
->format_name
: "");
2538 new_top_bs
->backing_hd
= base_bs
;
2540 bdrv_refresh_limits(new_top_bs
);
2542 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2543 /* so that bdrv_close() does not recursively close the chain */
2544 intermediate_state
->bs
->backing_hd
= NULL
;
2545 bdrv_unref(intermediate_state
->bs
);
2550 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2551 g_free(intermediate_state
);
2557 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2562 if (!bdrv_is_inserted(bs
))
2568 len
= bdrv_getlength(bs
);
2573 if ((offset
> len
) || (len
- offset
< size
))
2579 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2582 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2583 nb_sectors
* BDRV_SECTOR_SIZE
);
2586 typedef struct RwCo
{
2587 BlockDriverState
*bs
;
2592 BdrvRequestFlags flags
;
2595 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2597 RwCo
*rwco
= opaque
;
2599 if (!rwco
->is_write
) {
2600 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2601 rwco
->qiov
->size
, rwco
->qiov
,
2604 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2605 rwco
->qiov
->size
, rwco
->qiov
,
2611 * Process a vectored synchronous request using coroutines
2613 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2614 QEMUIOVector
*qiov
, bool is_write
,
2615 BdrvRequestFlags flags
)
2622 .is_write
= is_write
,
2628 * In sync call context, when the vcpu is blocked, this throttling timer
2629 * will not fire; so the I/O throttling function has to be disabled here
2630 * if it has been enabled.
2632 if (bs
->io_limits_enabled
) {
2633 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2634 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2635 bdrv_io_limits_disable(bs
);
2638 if (qemu_in_coroutine()) {
2639 /* Fast-path if already in coroutine context */
2640 bdrv_rw_co_entry(&rwco
);
2642 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2643 qemu_coroutine_enter(co
, &rwco
);
2644 while (rwco
.ret
== NOT_DONE
) {
2652 * Process a synchronous request using coroutines
2654 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2655 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2658 struct iovec iov
= {
2659 .iov_base
= (void *)buf
,
2660 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2663 qemu_iovec_init_external(&qiov
, &iov
, 1);
2664 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2665 &qiov
, is_write
, flags
);
2668 /* return < 0 if error. See bdrv_write() for the return codes */
2669 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2670 uint8_t *buf
, int nb_sectors
)
2672 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2675 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2676 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2677 uint8_t *buf
, int nb_sectors
)
2682 enabled
= bs
->io_limits_enabled
;
2683 bs
->io_limits_enabled
= false;
2684 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2685 bs
->io_limits_enabled
= enabled
;
2689 /* Return < 0 if error. Important errors are:
2690 -EIO generic I/O error (may happen for all errors)
2691 -ENOMEDIUM No media inserted.
2692 -EINVAL Invalid sector number or nb_sectors
2693 -EACCES Trying to write a read-only device
2695 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2696 const uint8_t *buf
, int nb_sectors
)
2698 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2701 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2702 int nb_sectors
, BdrvRequestFlags flags
)
2704 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2705 BDRV_REQ_ZERO_WRITE
| flags
);
2709 * Completely zero out a block device with the help of bdrv_write_zeroes.
2710 * The operation is sped up by checking the block status and only writing
2711 * zeroes to the device if they currently do not return zeroes. Optional
2712 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2714 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2716 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2718 int64_t target_size
= bdrv_getlength(bs
) / BDRV_SECTOR_SIZE
;
2719 int64_t ret
, nb_sectors
, sector_num
= 0;
2723 nb_sectors
= target_size
- sector_num
;
2724 if (nb_sectors
<= 0) {
2727 if (nb_sectors
> INT_MAX
) {
2728 nb_sectors
= INT_MAX
;
2730 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2732 error_report("error getting block status at sector %" PRId64
": %s",
2733 sector_num
, strerror(-ret
));
2736 if (ret
& BDRV_BLOCK_ZERO
) {
2740 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2742 error_report("error writing zeroes at sector %" PRId64
": %s",
2743 sector_num
, strerror(-ret
));
2750 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2753 struct iovec iov
= {
2754 .iov_base
= (void *)buf
,
2763 qemu_iovec_init_external(&qiov
, &iov
, 1);
2764 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2772 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2776 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2784 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2785 const void *buf
, int bytes
)
2788 struct iovec iov
= {
2789 .iov_base
= (void *) buf
,
2797 qemu_iovec_init_external(&qiov
, &iov
, 1);
2798 return bdrv_pwritev(bs
, offset
, &qiov
);
2802 * Writes to the file and ensures that no writes are reordered across this
2803 * request (acts as a barrier)
2805 * Returns 0 on success, -errno in error cases.
2807 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2808 const void *buf
, int count
)
2812 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2817 /* No flush needed for cache modes that already do it */
2818 if (bs
->enable_write_cache
) {
2825 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2826 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2828 /* Perform I/O through a temporary buffer so that users who scribble over
2829 * their read buffer while the operation is in progress do not end up
2830 * modifying the image file. This is critical for zero-copy guest I/O
2831 * where anything might happen inside guest memory.
2833 void *bounce_buffer
;
2835 BlockDriver
*drv
= bs
->drv
;
2837 QEMUIOVector bounce_qiov
;
2838 int64_t cluster_sector_num
;
2839 int cluster_nb_sectors
;
2843 /* Cover entire cluster so no additional backing file I/O is required when
2844 * allocating cluster in the image file.
2846 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2847 &cluster_sector_num
, &cluster_nb_sectors
);
2849 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2850 cluster_sector_num
, cluster_nb_sectors
);
2852 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2853 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2854 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2856 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2862 if (drv
->bdrv_co_write_zeroes
&&
2863 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2864 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2865 cluster_nb_sectors
, 0);
2867 /* This does not change the data on the disk, it is not necessary
2868 * to flush even in cache=writethrough mode.
2870 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2875 /* It might be okay to ignore write errors for guest requests. If this
2876 * is a deliberate copy-on-read then we don't want to ignore the error.
2877 * Simply report it in all cases.
2882 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2883 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2884 nb_sectors
* BDRV_SECTOR_SIZE
);
2887 qemu_vfree(bounce_buffer
);
2892 * Forwards an already correctly aligned request to the BlockDriver. This
2893 * handles copy on read and zeroing after EOF; any other features must be
2894 * implemented by the caller.
2896 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
2897 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
2898 int64_t align
, QEMUIOVector
*qiov
, int flags
)
2900 BlockDriver
*drv
= bs
->drv
;
2903 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
2904 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
2906 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2907 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
2909 /* Handle Copy on Read and associated serialisation */
2910 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2911 /* If we touch the same cluster it counts as an overlap. This
2912 * guarantees that allocating writes will be serialized and not race
2913 * with each other for the same cluster. For example, in copy-on-read
2914 * it ensures that the CoR read and write operations are atomic and
2915 * guest writes cannot interleave between them. */
2916 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
2919 wait_serialising_requests(req
);
2921 if (flags
& BDRV_REQ_COPY_ON_READ
) {
2924 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
2929 if (!ret
|| pnum
!= nb_sectors
) {
2930 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
2935 /* Forward the request to the BlockDriver */
2936 if (!(bs
->zero_beyond_eof
&& bs
->growable
)) {
2937 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
2939 /* Read zeros after EOF of growable BDSes */
2940 int64_t len
, total_sectors
, max_nb_sectors
;
2942 len
= bdrv_getlength(bs
);
2948 total_sectors
= DIV_ROUND_UP(len
, BDRV_SECTOR_SIZE
);
2949 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
2950 align
>> BDRV_SECTOR_BITS
);
2951 if (max_nb_sectors
> 0) {
2952 ret
= drv
->bdrv_co_readv(bs
, sector_num
,
2953 MIN(nb_sectors
, max_nb_sectors
), qiov
);
2958 /* Reading beyond end of file is supposed to produce zeroes */
2959 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
2960 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
2961 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
2963 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
2972 * Handle a read request in coroutine context
2974 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
2975 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
2976 BdrvRequestFlags flags
)
2978 BlockDriver
*drv
= bs
->drv
;
2979 BdrvTrackedRequest req
;
2981 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
2982 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
2983 uint8_t *head_buf
= NULL
;
2984 uint8_t *tail_buf
= NULL
;
2985 QEMUIOVector local_qiov
;
2986 bool use_local_qiov
= false;
2992 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
2996 if (bs
->copy_on_read
) {
2997 flags
|= BDRV_REQ_COPY_ON_READ
;
3000 /* throttling disk I/O */
3001 if (bs
->io_limits_enabled
) {
3002 bdrv_io_limits_intercept(bs
, bytes
, false);
3005 /* Align read if necessary by padding qiov */
3006 if (offset
& (align
- 1)) {
3007 head_buf
= qemu_blockalign(bs
, align
);
3008 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3009 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3010 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3011 use_local_qiov
= true;
3013 bytes
+= offset
& (align
- 1);
3014 offset
= offset
& ~(align
- 1);
3017 if ((offset
+ bytes
) & (align
- 1)) {
3018 if (!use_local_qiov
) {
3019 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3020 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3021 use_local_qiov
= true;
3023 tail_buf
= qemu_blockalign(bs
, align
);
3024 qemu_iovec_add(&local_qiov
, tail_buf
,
3025 align
- ((offset
+ bytes
) & (align
- 1)));
3027 bytes
= ROUND_UP(bytes
, align
);
3030 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3031 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3032 use_local_qiov
? &local_qiov
: qiov
,
3034 tracked_request_end(&req
);
3036 if (use_local_qiov
) {
3037 qemu_iovec_destroy(&local_qiov
);
3038 qemu_vfree(head_buf
);
3039 qemu_vfree(tail_buf
);
3045 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3046 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3047 BdrvRequestFlags flags
)
3049 if (nb_sectors
< 0 || nb_sectors
> (UINT_MAX
>> BDRV_SECTOR_BITS
)) {
3053 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3054 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3057 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3058 int nb_sectors
, QEMUIOVector
*qiov
)
3060 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3062 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3065 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3066 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3068 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3070 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3071 BDRV_REQ_COPY_ON_READ
);
3074 /* if no limit is specified in the BlockLimits use a default
3075 * of 32768 512-byte sectors (16 MiB) per request.
3077 #define MAX_WRITE_ZEROES_DEFAULT 32768
3079 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3080 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3082 BlockDriver
*drv
= bs
->drv
;
3084 struct iovec iov
= {0};
3087 int max_write_zeroes
= bs
->bl
.max_write_zeroes
?
3088 bs
->bl
.max_write_zeroes
: MAX_WRITE_ZEROES_DEFAULT
;
3090 while (nb_sectors
> 0 && !ret
) {
3091 int num
= nb_sectors
;
3093 /* Align request. Block drivers can expect the "bulk" of the request
3096 if (bs
->bl
.write_zeroes_alignment
3097 && num
> bs
->bl
.write_zeroes_alignment
) {
3098 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3099 /* Make a small request up to the first aligned sector. */
3100 num
= bs
->bl
.write_zeroes_alignment
;
3101 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3102 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3103 /* Shorten the request to the last aligned sector. num cannot
3104 * underflow because num > bs->bl.write_zeroes_alignment.
3106 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3110 /* limit request size */
3111 if (num
> max_write_zeroes
) {
3112 num
= max_write_zeroes
;
3116 /* First try the efficient write zeroes operation */
3117 if (drv
->bdrv_co_write_zeroes
) {
3118 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3121 if (ret
== -ENOTSUP
) {
3122 /* Fall back to bounce buffer if write zeroes is unsupported */
3123 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3124 if (iov
.iov_base
== NULL
) {
3125 iov
.iov_base
= qemu_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3126 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3128 qemu_iovec_init_external(&qiov
, &iov
, 1);
3130 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3132 /* Keep bounce buffer around if it is big enough for all
3133 * all future requests.
3135 if (num
< max_write_zeroes
) {
3136 qemu_vfree(iov
.iov_base
);
3137 iov
.iov_base
= NULL
;
3145 qemu_vfree(iov
.iov_base
);
3150 * Forwards an already correctly aligned write request to the BlockDriver.
3152 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3153 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3154 QEMUIOVector
*qiov
, int flags
)
3156 BlockDriver
*drv
= bs
->drv
;
3160 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3161 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3163 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3164 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3166 waited
= wait_serialising_requests(req
);
3167 assert(!waited
|| !req
->serialising
);
3168 assert(req
->overlap_offset
<= offset
);
3169 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3171 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3174 /* Do nothing, write notifier decided to fail this request */
3175 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3176 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3177 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3179 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3180 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3182 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3184 if (ret
== 0 && !bs
->enable_write_cache
) {
3185 ret
= bdrv_co_flush(bs
);
3188 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3190 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
3191 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
3193 if (bs
->growable
&& ret
>= 0) {
3194 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3201 * Handle a write request in coroutine context
3203 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3204 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3205 BdrvRequestFlags flags
)
3207 BdrvTrackedRequest req
;
3208 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3209 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3210 uint8_t *head_buf
= NULL
;
3211 uint8_t *tail_buf
= NULL
;
3212 QEMUIOVector local_qiov
;
3213 bool use_local_qiov
= false;
3219 if (bs
->read_only
) {
3222 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3226 /* throttling disk I/O */
3227 if (bs
->io_limits_enabled
) {
3228 bdrv_io_limits_intercept(bs
, bytes
, true);
3232 * Align write if necessary by performing a read-modify-write cycle.
3233 * Pad qiov with the read parts and be sure to have a tracked request not
3234 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3236 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3238 if (offset
& (align
- 1)) {
3239 QEMUIOVector head_qiov
;
3240 struct iovec head_iov
;
3242 mark_request_serialising(&req
, align
);
3243 wait_serialising_requests(&req
);
3245 head_buf
= qemu_blockalign(bs
, align
);
3246 head_iov
= (struct iovec
) {
3247 .iov_base
= head_buf
,
3250 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3252 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3253 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3254 align
, &head_qiov
, 0);
3258 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3260 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3261 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3262 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3263 use_local_qiov
= true;
3265 bytes
+= offset
& (align
- 1);
3266 offset
= offset
& ~(align
- 1);
3269 if ((offset
+ bytes
) & (align
- 1)) {
3270 QEMUIOVector tail_qiov
;
3271 struct iovec tail_iov
;
3275 mark_request_serialising(&req
, align
);
3276 waited
= wait_serialising_requests(&req
);
3277 assert(!waited
|| !use_local_qiov
);
3279 tail_buf
= qemu_blockalign(bs
, align
);
3280 tail_iov
= (struct iovec
) {
3281 .iov_base
= tail_buf
,
3284 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3286 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3287 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3288 align
, &tail_qiov
, 0);
3292 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3294 if (!use_local_qiov
) {
3295 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3296 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3297 use_local_qiov
= true;
3300 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3301 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3303 bytes
= ROUND_UP(bytes
, align
);
3306 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3307 use_local_qiov
? &local_qiov
: qiov
,
3311 tracked_request_end(&req
);
3313 if (use_local_qiov
) {
3314 qemu_iovec_destroy(&local_qiov
);
3316 qemu_vfree(head_buf
);
3317 qemu_vfree(tail_buf
);
3322 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3323 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3324 BdrvRequestFlags flags
)
3326 if (nb_sectors
< 0 || nb_sectors
> (INT_MAX
>> BDRV_SECTOR_BITS
)) {
3330 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3331 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3334 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3335 int nb_sectors
, QEMUIOVector
*qiov
)
3337 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3339 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3342 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3343 int64_t sector_num
, int nb_sectors
,
3344 BdrvRequestFlags flags
)
3346 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3348 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3349 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3352 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3353 BDRV_REQ_ZERO_WRITE
| flags
);
3357 * Truncate file to 'offset' bytes (needed only for file protocols)
3359 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3361 BlockDriver
*drv
= bs
->drv
;
3365 if (!drv
->bdrv_truncate
)
3369 if (bdrv_in_use(bs
))
3371 ret
= drv
->bdrv_truncate(bs
, offset
);
3373 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3374 bdrv_dev_resize_cb(bs
);
3380 * Length of a allocated file in bytes. Sparse files are counted by actual
3381 * allocated space. Return < 0 if error or unknown.
3383 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3385 BlockDriver
*drv
= bs
->drv
;
3389 if (drv
->bdrv_get_allocated_file_size
) {
3390 return drv
->bdrv_get_allocated_file_size(bs
);
3393 return bdrv_get_allocated_file_size(bs
->file
);
3399 * Length of a file in bytes. Return < 0 if error or unknown.
3401 int64_t bdrv_getlength(BlockDriverState
*bs
)
3403 BlockDriver
*drv
= bs
->drv
;
3407 if (drv
->has_variable_length
) {
3408 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3413 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3416 /* return 0 as number of sectors if no device present or error */
3417 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3420 length
= bdrv_getlength(bs
);
3424 length
= length
>> BDRV_SECTOR_BITS
;
3425 *nb_sectors_ptr
= length
;
3428 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3429 BlockdevOnError on_write_error
)
3431 bs
->on_read_error
= on_read_error
;
3432 bs
->on_write_error
= on_write_error
;
3435 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)
3437 return is_read
? bs
->on_read_error
: bs
->on_write_error
;
3440 BlockErrorAction
bdrv_get_error_action(BlockDriverState
*bs
, bool is_read
, int error
)
3442 BlockdevOnError on_err
= is_read
? bs
->on_read_error
: bs
->on_write_error
;
3445 case BLOCKDEV_ON_ERROR_ENOSPC
:
3446 return (error
== ENOSPC
) ? BDRV_ACTION_STOP
: BDRV_ACTION_REPORT
;
3447 case BLOCKDEV_ON_ERROR_STOP
:
3448 return BDRV_ACTION_STOP
;
3449 case BLOCKDEV_ON_ERROR_REPORT
:
3450 return BDRV_ACTION_REPORT
;
3451 case BLOCKDEV_ON_ERROR_IGNORE
:
3452 return BDRV_ACTION_IGNORE
;
3458 /* This is done by device models because, while the block layer knows
3459 * about the error, it does not know whether an operation comes from
3460 * the device or the block layer (from a job, for example).
3462 void bdrv_error_action(BlockDriverState
*bs
, BlockErrorAction action
,
3463 bool is_read
, int error
)
3466 bdrv_emit_qmp_error_event(bs
, QEVENT_BLOCK_IO_ERROR
, action
, is_read
);
3467 if (action
== BDRV_ACTION_STOP
) {
3468 vm_stop(RUN_STATE_IO_ERROR
);
3469 bdrv_iostatus_set_err(bs
, error
);
3473 int bdrv_is_read_only(BlockDriverState
*bs
)
3475 return bs
->read_only
;
3478 int bdrv_is_sg(BlockDriverState
*bs
)
3483 int bdrv_enable_write_cache(BlockDriverState
*bs
)
3485 return bs
->enable_write_cache
;
3488 void bdrv_set_enable_write_cache(BlockDriverState
*bs
, bool wce
)
3490 bs
->enable_write_cache
= wce
;
3492 /* so a reopen() will preserve wce */
3494 bs
->open_flags
|= BDRV_O_CACHE_WB
;
3496 bs
->open_flags
&= ~BDRV_O_CACHE_WB
;
3500 int bdrv_is_encrypted(BlockDriverState
*bs
)
3502 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3504 return bs
->encrypted
;
3507 int bdrv_key_required(BlockDriverState
*bs
)
3509 BlockDriverState
*backing_hd
= bs
->backing_hd
;
3511 if (backing_hd
&& backing_hd
->encrypted
&& !backing_hd
->valid_key
)
3513 return (bs
->encrypted
&& !bs
->valid_key
);
3516 int bdrv_set_key(BlockDriverState
*bs
, const char *key
)
3519 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
) {
3520 ret
= bdrv_set_key(bs
->backing_hd
, key
);
3526 if (!bs
->encrypted
) {
3528 } else if (!bs
->drv
|| !bs
->drv
->bdrv_set_key
) {
3531 ret
= bs
->drv
->bdrv_set_key(bs
, key
);
3534 } else if (!bs
->valid_key
) {
3536 /* call the change callback now, we skipped it on open */
3537 bdrv_dev_change_media_cb(bs
, true);
3542 const char *bdrv_get_format_name(BlockDriverState
*bs
)
3544 return bs
->drv
? bs
->drv
->format_name
: NULL
;
3547 void bdrv_iterate_format(void (*it
)(void *opaque
, const char *name
),
3552 QLIST_FOREACH(drv
, &bdrv_drivers
, list
) {
3553 it(opaque
, drv
->format_name
);
3557 /* This function is to find block backend bs */
3558 BlockDriverState
*bdrv_find(const char *name
)
3560 BlockDriverState
*bs
;
3562 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3563 if (!strcmp(name
, bs
->device_name
)) {
3570 /* This function is to find a node in the bs graph */
3571 BlockDriverState
*bdrv_find_node(const char *node_name
)
3573 BlockDriverState
*bs
;
3577 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3578 if (!strcmp(node_name
, bs
->node_name
)) {
3585 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3586 BlockDeviceInfoList
*bdrv_named_nodes_list(void)
3588 BlockDeviceInfoList
*list
, *entry
;
3589 BlockDriverState
*bs
;
3592 QTAILQ_FOREACH(bs
, &graph_bdrv_states
, node_list
) {
3593 entry
= g_malloc0(sizeof(*entry
));
3594 entry
->value
= bdrv_block_device_info(bs
);
3602 BlockDriverState
*bdrv_lookup_bs(const char *device
,
3603 const char *node_name
,
3606 BlockDriverState
*bs
= NULL
;
3609 bs
= bdrv_find(device
);
3617 bs
= bdrv_find_node(node_name
);
3624 error_setg(errp
, "Cannot find device=%s nor node_name=%s",
3625 device
? device
: "",
3626 node_name
? node_name
: "");
3630 BlockDriverState
*bdrv_next(BlockDriverState
*bs
)
3633 return QTAILQ_FIRST(&bdrv_states
);
3635 return QTAILQ_NEXT(bs
, device_list
);
3638 void bdrv_iterate(void (*it
)(void *opaque
, BlockDriverState
*bs
), void *opaque
)
3640 BlockDriverState
*bs
;
3642 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3647 const char *bdrv_get_device_name(BlockDriverState
*bs
)
3649 return bs
->device_name
;
3652 int bdrv_get_flags(BlockDriverState
*bs
)
3654 return bs
->open_flags
;
3657 int bdrv_flush_all(void)
3659 BlockDriverState
*bs
;
3662 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
3663 int ret
= bdrv_flush(bs
);
3664 if (ret
< 0 && !result
) {
3672 int bdrv_has_zero_init_1(BlockDriverState
*bs
)
3677 int bdrv_has_zero_init(BlockDriverState
*bs
)
3681 /* If BS is a copy on write image, it is initialized to
3682 the contents of the base image, which may not be zeroes. */
3683 if (bs
->backing_hd
) {
3686 if (bs
->drv
->bdrv_has_zero_init
) {
3687 return bs
->drv
->bdrv_has_zero_init(bs
);
3694 bool bdrv_unallocated_blocks_are_zero(BlockDriverState
*bs
)
3696 BlockDriverInfo bdi
;
3698 if (bs
->backing_hd
) {
3702 if (bdrv_get_info(bs
, &bdi
) == 0) {
3703 return bdi
.unallocated_blocks_are_zero
;
3709 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState
*bs
)
3711 BlockDriverInfo bdi
;
3713 if (bs
->backing_hd
|| !(bs
->open_flags
& BDRV_O_UNMAP
)) {
3717 if (bdrv_get_info(bs
, &bdi
) == 0) {
3718 return bdi
.can_write_zeroes_with_unmap
;
3724 typedef struct BdrvCoGetBlockStatusData
{
3725 BlockDriverState
*bs
;
3726 BlockDriverState
*base
;
3732 } BdrvCoGetBlockStatusData
;
3735 * Returns true iff the specified sector is present in the disk image. Drivers
3736 * not implementing the functionality are assumed to not support backing files,
3737 * hence all their sectors are reported as allocated.
3739 * If 'sector_num' is beyond the end of the disk image the return value is 0
3740 * and 'pnum' is set to 0.
3742 * 'pnum' is set to the number of sectors (including and immediately following
3743 * the specified sector) that are known to be in the same
3744 * allocated/unallocated state.
3746 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3747 * beyond the end of the disk image it will be clamped.
3749 static int64_t coroutine_fn
bdrv_co_get_block_status(BlockDriverState
*bs
,
3751 int nb_sectors
, int *pnum
)
3757 length
= bdrv_getlength(bs
);
3762 if (sector_num
>= (length
>> BDRV_SECTOR_BITS
)) {
3767 n
= bs
->total_sectors
- sector_num
;
3768 if (n
< nb_sectors
) {
3772 if (!bs
->drv
->bdrv_co_get_block_status
) {
3774 ret
= BDRV_BLOCK_DATA
;
3775 if (bs
->drv
->protocol_name
) {
3776 ret
|= BDRV_BLOCK_OFFSET_VALID
| (sector_num
* BDRV_SECTOR_SIZE
);
3781 ret
= bs
->drv
->bdrv_co_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
3787 if (ret
& BDRV_BLOCK_RAW
) {
3788 assert(ret
& BDRV_BLOCK_OFFSET_VALID
);
3789 return bdrv_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3793 if (!(ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
)) {
3794 if (bdrv_unallocated_blocks_are_zero(bs
)) {
3795 ret
|= BDRV_BLOCK_ZERO
;
3796 } else if (bs
->backing_hd
) {
3797 BlockDriverState
*bs2
= bs
->backing_hd
;
3798 int64_t length2
= bdrv_getlength(bs2
);
3799 if (length2
>= 0 && sector_num
>= (length2
>> BDRV_SECTOR_BITS
)) {
3800 ret
|= BDRV_BLOCK_ZERO
;
3806 (ret
& BDRV_BLOCK_DATA
) && !(ret
& BDRV_BLOCK_ZERO
) &&
3807 (ret
& BDRV_BLOCK_OFFSET_VALID
)) {
3808 ret2
= bdrv_co_get_block_status(bs
->file
, ret
>> BDRV_SECTOR_BITS
,
3811 /* Ignore errors. This is just providing extra information, it
3812 * is useful but not necessary.
3814 ret
|= (ret2
& BDRV_BLOCK_ZERO
);
3821 /* Coroutine wrapper for bdrv_get_block_status() */
3822 static void coroutine_fn
bdrv_get_block_status_co_entry(void *opaque
)
3824 BdrvCoGetBlockStatusData
*data
= opaque
;
3825 BlockDriverState
*bs
= data
->bs
;
3827 data
->ret
= bdrv_co_get_block_status(bs
, data
->sector_num
, data
->nb_sectors
,
3833 * Synchronous wrapper around bdrv_co_get_block_status().
3835 * See bdrv_co_get_block_status() for details.
3837 int64_t bdrv_get_block_status(BlockDriverState
*bs
, int64_t sector_num
,
3838 int nb_sectors
, int *pnum
)
3841 BdrvCoGetBlockStatusData data
= {
3843 .sector_num
= sector_num
,
3844 .nb_sectors
= nb_sectors
,
3849 if (qemu_in_coroutine()) {
3850 /* Fast-path if already in coroutine context */
3851 bdrv_get_block_status_co_entry(&data
);
3853 co
= qemu_coroutine_create(bdrv_get_block_status_co_entry
);
3854 qemu_coroutine_enter(co
, &data
);
3855 while (!data
.done
) {
3862 int coroutine_fn
bdrv_is_allocated(BlockDriverState
*bs
, int64_t sector_num
,
3863 int nb_sectors
, int *pnum
)
3865 int64_t ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, pnum
);
3870 (ret
& BDRV_BLOCK_DATA
) ||
3871 ((ret
& BDRV_BLOCK_ZERO
) && !bdrv_has_zero_init(bs
));
3875 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
3877 * Return true if the given sector is allocated in any image between
3878 * BASE and TOP (inclusive). BASE can be NULL to check if the given
3879 * sector is allocated in any image of the chain. Return false otherwise.
3881 * 'pnum' is set to the number of sectors (including and immediately following
3882 * the specified sector) that are known to be in the same
3883 * allocated/unallocated state.
3886 int bdrv_is_allocated_above(BlockDriverState
*top
,
3887 BlockDriverState
*base
,
3889 int nb_sectors
, int *pnum
)
3891 BlockDriverState
*intermediate
;
3892 int ret
, n
= nb_sectors
;
3895 while (intermediate
&& intermediate
!= base
) {
3897 ret
= bdrv_is_allocated(intermediate
, sector_num
, nb_sectors
,
3907 * [sector_num, nb_sectors] is unallocated on top but intermediate
3910 * [sector_num+x, nr_sectors] allocated.
3912 if (n
> pnum_inter
&&
3913 (intermediate
== top
||
3914 sector_num
+ pnum_inter
< intermediate
->total_sectors
)) {
3918 intermediate
= intermediate
->backing_hd
;
3925 const char *bdrv_get_encrypted_filename(BlockDriverState
*bs
)
3927 if (bs
->backing_hd
&& bs
->backing_hd
->encrypted
)
3928 return bs
->backing_file
;
3929 else if (bs
->encrypted
)
3930 return bs
->filename
;
3935 void bdrv_get_backing_filename(BlockDriverState
*bs
,
3936 char *filename
, int filename_size
)
3938 pstrcpy(filename
, filename_size
, bs
->backing_file
);
3941 int bdrv_write_compressed(BlockDriverState
*bs
, int64_t sector_num
,
3942 const uint8_t *buf
, int nb_sectors
)
3944 BlockDriver
*drv
= bs
->drv
;
3947 if (!drv
->bdrv_write_compressed
)
3949 if (bdrv_check_request(bs
, sector_num
, nb_sectors
))
3952 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
3954 return drv
->bdrv_write_compressed(bs
, sector_num
, buf
, nb_sectors
);
3957 int bdrv_get_info(BlockDriverState
*bs
, BlockDriverInfo
*bdi
)
3959 BlockDriver
*drv
= bs
->drv
;
3962 if (!drv
->bdrv_get_info
)
3964 memset(bdi
, 0, sizeof(*bdi
));
3965 return drv
->bdrv_get_info(bs
, bdi
);
3968 ImageInfoSpecific
*bdrv_get_specific_info(BlockDriverState
*bs
)
3970 BlockDriver
*drv
= bs
->drv
;
3971 if (drv
&& drv
->bdrv_get_specific_info
) {
3972 return drv
->bdrv_get_specific_info(bs
);
3977 int bdrv_save_vmstate(BlockDriverState
*bs
, const uint8_t *buf
,
3978 int64_t pos
, int size
)
3981 struct iovec iov
= {
3982 .iov_base
= (void *) buf
,
3986 qemu_iovec_init_external(&qiov
, &iov
, 1);
3987 return bdrv_writev_vmstate(bs
, &qiov
, pos
);
3990 int bdrv_writev_vmstate(BlockDriverState
*bs
, QEMUIOVector
*qiov
, int64_t pos
)
3992 BlockDriver
*drv
= bs
->drv
;
3996 } else if (drv
->bdrv_save_vmstate
) {
3997 return drv
->bdrv_save_vmstate(bs
, qiov
, pos
);
3998 } else if (bs
->file
) {
3999 return bdrv_writev_vmstate(bs
->file
, qiov
, pos
);
4005 int bdrv_load_vmstate(BlockDriverState
*bs
, uint8_t *buf
,
4006 int64_t pos
, int size
)
4008 BlockDriver
*drv
= bs
->drv
;
4011 if (drv
->bdrv_load_vmstate
)
4012 return drv
->bdrv_load_vmstate(bs
, buf
, pos
, size
);
4014 return bdrv_load_vmstate(bs
->file
, buf
, pos
, size
);
4018 void bdrv_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
4020 if (!bs
|| !bs
->drv
|| !bs
->drv
->bdrv_debug_event
) {
4024 bs
->drv
->bdrv_debug_event(bs
, event
);
4027 int bdrv_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
4030 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_breakpoint
) {
4034 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_breakpoint
) {
4035 return bs
->drv
->bdrv_debug_breakpoint(bs
, event
, tag
);
4041 int bdrv_debug_remove_breakpoint(BlockDriverState
*bs
, const char *tag
)
4043 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_remove_breakpoint
) {
4047 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_remove_breakpoint
) {
4048 return bs
->drv
->bdrv_debug_remove_breakpoint(bs
, tag
);
4054 int bdrv_debug_resume(BlockDriverState
*bs
, const char *tag
)
4056 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_resume
) {
4060 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_resume
) {
4061 return bs
->drv
->bdrv_debug_resume(bs
, tag
);
4067 bool bdrv_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
4069 while (bs
&& bs
->drv
&& !bs
->drv
->bdrv_debug_is_suspended
) {
4073 if (bs
&& bs
->drv
&& bs
->drv
->bdrv_debug_is_suspended
) {
4074 return bs
->drv
->bdrv_debug_is_suspended(bs
, tag
);
4080 int bdrv_is_snapshot(BlockDriverState
*bs
)
4082 return !!(bs
->open_flags
& BDRV_O_SNAPSHOT
);
4085 /* backing_file can either be relative, or absolute, or a protocol. If it is
4086 * relative, it must be relative to the chain. So, passing in bs->filename
4087 * from a BDS as backing_file should not be done, as that may be relative to
4088 * the CWD rather than the chain. */
4089 BlockDriverState
*bdrv_find_backing_image(BlockDriverState
*bs
,
4090 const char *backing_file
)
4092 char *filename_full
= NULL
;
4093 char *backing_file_full
= NULL
;
4094 char *filename_tmp
= NULL
;
4095 int is_protocol
= 0;
4096 BlockDriverState
*curr_bs
= NULL
;
4097 BlockDriverState
*retval
= NULL
;
4099 if (!bs
|| !bs
->drv
|| !backing_file
) {
4103 filename_full
= g_malloc(PATH_MAX
);
4104 backing_file_full
= g_malloc(PATH_MAX
);
4105 filename_tmp
= g_malloc(PATH_MAX
);
4107 is_protocol
= path_has_protocol(backing_file
);
4109 for (curr_bs
= bs
; curr_bs
->backing_hd
; curr_bs
= curr_bs
->backing_hd
) {
4111 /* If either of the filename paths is actually a protocol, then
4112 * compare unmodified paths; otherwise make paths relative */
4113 if (is_protocol
|| path_has_protocol(curr_bs
->backing_file
)) {
4114 if (strcmp(backing_file
, curr_bs
->backing_file
) == 0) {
4115 retval
= curr_bs
->backing_hd
;
4119 /* If not an absolute filename path, make it relative to the current
4120 * image's filename path */
4121 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4124 /* We are going to compare absolute pathnames */
4125 if (!realpath(filename_tmp
, filename_full
)) {
4129 /* We need to make sure the backing filename we are comparing against
4130 * is relative to the current image filename (or absolute) */
4131 path_combine(filename_tmp
, PATH_MAX
, curr_bs
->filename
,
4132 curr_bs
->backing_file
);
4134 if (!realpath(filename_tmp
, backing_file_full
)) {
4138 if (strcmp(backing_file_full
, filename_full
) == 0) {
4139 retval
= curr_bs
->backing_hd
;
4145 g_free(filename_full
);
4146 g_free(backing_file_full
);
4147 g_free(filename_tmp
);
4151 int bdrv_get_backing_file_depth(BlockDriverState
*bs
)
4157 if (!bs
->backing_hd
) {
4161 return 1 + bdrv_get_backing_file_depth(bs
->backing_hd
);
4164 BlockDriverState
*bdrv_find_base(BlockDriverState
*bs
)
4166 BlockDriverState
*curr_bs
= NULL
;
4174 while (curr_bs
->backing_hd
) {
4175 curr_bs
= curr_bs
->backing_hd
;
4180 /**************************************************************/
4183 BlockDriverAIOCB
*bdrv_aio_readv(BlockDriverState
*bs
, int64_t sector_num
,
4184 QEMUIOVector
*qiov
, int nb_sectors
,
4185 BlockDriverCompletionFunc
*cb
, void *opaque
)
4187 trace_bdrv_aio_readv(bs
, sector_num
, nb_sectors
, opaque
);
4189 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4193 BlockDriverAIOCB
*bdrv_aio_writev(BlockDriverState
*bs
, int64_t sector_num
,
4194 QEMUIOVector
*qiov
, int nb_sectors
,
4195 BlockDriverCompletionFunc
*cb
, void *opaque
)
4197 trace_bdrv_aio_writev(bs
, sector_num
, nb_sectors
, opaque
);
4199 return bdrv_co_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, 0,
4203 BlockDriverAIOCB
*bdrv_aio_write_zeroes(BlockDriverState
*bs
,
4204 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
,
4205 BlockDriverCompletionFunc
*cb
, void *opaque
)
4207 trace_bdrv_aio_write_zeroes(bs
, sector_num
, nb_sectors
, flags
, opaque
);
4209 return bdrv_co_aio_rw_vector(bs
, sector_num
, NULL
, nb_sectors
,
4210 BDRV_REQ_ZERO_WRITE
| flags
,
4215 typedef struct MultiwriteCB
{
4220 BlockDriverCompletionFunc
*cb
;
4222 QEMUIOVector
*free_qiov
;
4226 static void multiwrite_user_cb(MultiwriteCB
*mcb
)
4230 for (i
= 0; i
< mcb
->num_callbacks
; i
++) {
4231 mcb
->callbacks
[i
].cb(mcb
->callbacks
[i
].opaque
, mcb
->error
);
4232 if (mcb
->callbacks
[i
].free_qiov
) {
4233 qemu_iovec_destroy(mcb
->callbacks
[i
].free_qiov
);
4235 g_free(mcb
->callbacks
[i
].free_qiov
);
4239 static void multiwrite_cb(void *opaque
, int ret
)
4241 MultiwriteCB
*mcb
= opaque
;
4243 trace_multiwrite_cb(mcb
, ret
);
4245 if (ret
< 0 && !mcb
->error
) {
4249 mcb
->num_requests
--;
4250 if (mcb
->num_requests
== 0) {
4251 multiwrite_user_cb(mcb
);
4256 static int multiwrite_req_compare(const void *a
, const void *b
)
4258 const BlockRequest
*req1
= a
, *req2
= b
;
4261 * Note that we can't simply subtract req2->sector from req1->sector
4262 * here as that could overflow the return value.
4264 if (req1
->sector
> req2
->sector
) {
4266 } else if (req1
->sector
< req2
->sector
) {
4274 * Takes a bunch of requests and tries to merge them. Returns the number of
4275 * requests that remain after merging.
4277 static int multiwrite_merge(BlockDriverState
*bs
, BlockRequest
*reqs
,
4278 int num_reqs
, MultiwriteCB
*mcb
)
4282 // Sort requests by start sector
4283 qsort(reqs
, num_reqs
, sizeof(*reqs
), &multiwrite_req_compare
);
4285 // Check if adjacent requests touch the same clusters. If so, combine them,
4286 // filling up gaps with zero sectors.
4288 for (i
= 1; i
< num_reqs
; i
++) {
4290 int64_t oldreq_last
= reqs
[outidx
].sector
+ reqs
[outidx
].nb_sectors
;
4292 // Handle exactly sequential writes and overlapping writes.
4293 if (reqs
[i
].sector
<= oldreq_last
) {
4297 if (reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1 > IOV_MAX
) {
4303 QEMUIOVector
*qiov
= g_malloc0(sizeof(*qiov
));
4304 qemu_iovec_init(qiov
,
4305 reqs
[outidx
].qiov
->niov
+ reqs
[i
].qiov
->niov
+ 1);
4307 // Add the first request to the merged one. If the requests are
4308 // overlapping, drop the last sectors of the first request.
4309 size
= (reqs
[i
].sector
- reqs
[outidx
].sector
) << 9;
4310 qemu_iovec_concat(qiov
, reqs
[outidx
].qiov
, 0, size
);
4312 // We should need to add any zeros between the two requests
4313 assert (reqs
[i
].sector
<= oldreq_last
);
4315 // Add the second request
4316 qemu_iovec_concat(qiov
, reqs
[i
].qiov
, 0, reqs
[i
].qiov
->size
);
4318 reqs
[outidx
].nb_sectors
= qiov
->size
>> 9;
4319 reqs
[outidx
].qiov
= qiov
;
4321 mcb
->callbacks
[i
].free_qiov
= reqs
[outidx
].qiov
;
4324 reqs
[outidx
].sector
= reqs
[i
].sector
;
4325 reqs
[outidx
].nb_sectors
= reqs
[i
].nb_sectors
;
4326 reqs
[outidx
].qiov
= reqs
[i
].qiov
;
4334 * Submit multiple AIO write requests at once.
4336 * On success, the function returns 0 and all requests in the reqs array have
4337 * been submitted. In error case this function returns -1, and any of the
4338 * requests may or may not be submitted yet. In particular, this means that the
4339 * callback will be called for some of the requests, for others it won't. The
4340 * caller must check the error field of the BlockRequest to wait for the right
4341 * callbacks (if error != 0, no callback will be called).
4343 * The implementation may modify the contents of the reqs array, e.g. to merge
4344 * requests. However, the fields opaque and error are left unmodified as they
4345 * are used to signal failure for a single request to the caller.
4347 int bdrv_aio_multiwrite(BlockDriverState
*bs
, BlockRequest
*reqs
, int num_reqs
)
4352 /* don't submit writes if we don't have a medium */
4353 if (bs
->drv
== NULL
) {
4354 for (i
= 0; i
< num_reqs
; i
++) {
4355 reqs
[i
].error
= -ENOMEDIUM
;
4360 if (num_reqs
== 0) {
4364 // Create MultiwriteCB structure
4365 mcb
= g_malloc0(sizeof(*mcb
) + num_reqs
* sizeof(*mcb
->callbacks
));
4366 mcb
->num_requests
= 0;
4367 mcb
->num_callbacks
= num_reqs
;
4369 for (i
= 0; i
< num_reqs
; i
++) {
4370 mcb
->callbacks
[i
].cb
= reqs
[i
].cb
;
4371 mcb
->callbacks
[i
].opaque
= reqs
[i
].opaque
;
4374 // Check for mergable requests
4375 num_reqs
= multiwrite_merge(bs
, reqs
, num_reqs
, mcb
);
4377 trace_bdrv_aio_multiwrite(mcb
, mcb
->num_callbacks
, num_reqs
);
4379 /* Run the aio requests. */
4380 mcb
->num_requests
= num_reqs
;
4381 for (i
= 0; i
< num_reqs
; i
++) {
4382 bdrv_co_aio_rw_vector(bs
, reqs
[i
].sector
, reqs
[i
].qiov
,
4383 reqs
[i
].nb_sectors
, reqs
[i
].flags
,
4391 void bdrv_aio_cancel(BlockDriverAIOCB
*acb
)
4393 acb
->aiocb_info
->cancel(acb
);
4396 /**************************************************************/
4397 /* async block device emulation */
4399 typedef struct BlockDriverAIOCBSync
{
4400 BlockDriverAIOCB common
;
4403 /* vector translation state */
4407 } BlockDriverAIOCBSync
;
4409 static void bdrv_aio_cancel_em(BlockDriverAIOCB
*blockacb
)
4411 BlockDriverAIOCBSync
*acb
=
4412 container_of(blockacb
, BlockDriverAIOCBSync
, common
);
4413 qemu_bh_delete(acb
->bh
);
4415 qemu_aio_release(acb
);
4418 static const AIOCBInfo bdrv_em_aiocb_info
= {
4419 .aiocb_size
= sizeof(BlockDriverAIOCBSync
),
4420 .cancel
= bdrv_aio_cancel_em
,
4423 static void bdrv_aio_bh_cb(void *opaque
)
4425 BlockDriverAIOCBSync
*acb
= opaque
;
4428 qemu_iovec_from_buf(acb
->qiov
, 0, acb
->bounce
, acb
->qiov
->size
);
4429 qemu_vfree(acb
->bounce
);
4430 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
4431 qemu_bh_delete(acb
->bh
);
4433 qemu_aio_release(acb
);
4436 static BlockDriverAIOCB
*bdrv_aio_rw_vector(BlockDriverState
*bs
,
4440 BlockDriverCompletionFunc
*cb
,
4445 BlockDriverAIOCBSync
*acb
;
4447 acb
= qemu_aio_get(&bdrv_em_aiocb_info
, bs
, cb
, opaque
);
4448 acb
->is_write
= is_write
;
4450 acb
->bounce
= qemu_blockalign(bs
, qiov
->size
);
4451 acb
->bh
= qemu_bh_new(bdrv_aio_bh_cb
, acb
);
4454 qemu_iovec_to_buf(acb
->qiov
, 0, acb
->bounce
, qiov
->size
);
4455 acb
->ret
= bs
->drv
->bdrv_write(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4457 acb
->ret
= bs
->drv
->bdrv_read(bs
, sector_num
, acb
->bounce
, nb_sectors
);
4460 qemu_bh_schedule(acb
->bh
);
4462 return &acb
->common
;
4465 static BlockDriverAIOCB
*bdrv_aio_readv_em(BlockDriverState
*bs
,
4466 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4467 BlockDriverCompletionFunc
*cb
, void *opaque
)
4469 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 0);
4472 static BlockDriverAIOCB
*bdrv_aio_writev_em(BlockDriverState
*bs
,
4473 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
4474 BlockDriverCompletionFunc
*cb
, void *opaque
)
4476 return bdrv_aio_rw_vector(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
, 1);
4480 typedef struct BlockDriverAIOCBCoroutine
{
4481 BlockDriverAIOCB common
;
4486 } BlockDriverAIOCBCoroutine
;
4488 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB
*blockacb
)
4490 BlockDriverAIOCBCoroutine
*acb
=
4491 container_of(blockacb
, BlockDriverAIOCBCoroutine
, common
);
4500 static const AIOCBInfo bdrv_em_co_aiocb_info
= {
4501 .aiocb_size
= sizeof(BlockDriverAIOCBCoroutine
),
4502 .cancel
= bdrv_aio_co_cancel_em
,
4505 static void bdrv_co_em_bh(void *opaque
)
4507 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4509 acb
->common
.cb(acb
->common
.opaque
, acb
->req
.error
);
4515 qemu_bh_delete(acb
->bh
);
4516 qemu_aio_release(acb
);
4519 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4520 static void coroutine_fn
bdrv_co_do_rw(void *opaque
)
4522 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4523 BlockDriverState
*bs
= acb
->common
.bs
;
4525 if (!acb
->is_write
) {
4526 acb
->req
.error
= bdrv_co_do_readv(bs
, acb
->req
.sector
,
4527 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4529 acb
->req
.error
= bdrv_co_do_writev(bs
, acb
->req
.sector
,
4530 acb
->req
.nb_sectors
, acb
->req
.qiov
, acb
->req
.flags
);
4533 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4534 qemu_bh_schedule(acb
->bh
);
4537 static BlockDriverAIOCB
*bdrv_co_aio_rw_vector(BlockDriverState
*bs
,
4541 BdrvRequestFlags flags
,
4542 BlockDriverCompletionFunc
*cb
,
4547 BlockDriverAIOCBCoroutine
*acb
;
4549 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4550 acb
->req
.sector
= sector_num
;
4551 acb
->req
.nb_sectors
= nb_sectors
;
4552 acb
->req
.qiov
= qiov
;
4553 acb
->req
.flags
= flags
;
4554 acb
->is_write
= is_write
;
4557 co
= qemu_coroutine_create(bdrv_co_do_rw
);
4558 qemu_coroutine_enter(co
, acb
);
4560 return &acb
->common
;
4563 static void coroutine_fn
bdrv_aio_flush_co_entry(void *opaque
)
4565 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4566 BlockDriverState
*bs
= acb
->common
.bs
;
4568 acb
->req
.error
= bdrv_co_flush(bs
);
4569 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4570 qemu_bh_schedule(acb
->bh
);
4573 BlockDriverAIOCB
*bdrv_aio_flush(BlockDriverState
*bs
,
4574 BlockDriverCompletionFunc
*cb
, void *opaque
)
4576 trace_bdrv_aio_flush(bs
, opaque
);
4579 BlockDriverAIOCBCoroutine
*acb
;
4581 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4584 co
= qemu_coroutine_create(bdrv_aio_flush_co_entry
);
4585 qemu_coroutine_enter(co
, acb
);
4587 return &acb
->common
;
4590 static void coroutine_fn
bdrv_aio_discard_co_entry(void *opaque
)
4592 BlockDriverAIOCBCoroutine
*acb
= opaque
;
4593 BlockDriverState
*bs
= acb
->common
.bs
;
4595 acb
->req
.error
= bdrv_co_discard(bs
, acb
->req
.sector
, acb
->req
.nb_sectors
);
4596 acb
->bh
= qemu_bh_new(bdrv_co_em_bh
, acb
);
4597 qemu_bh_schedule(acb
->bh
);
4600 BlockDriverAIOCB
*bdrv_aio_discard(BlockDriverState
*bs
,
4601 int64_t sector_num
, int nb_sectors
,
4602 BlockDriverCompletionFunc
*cb
, void *opaque
)
4605 BlockDriverAIOCBCoroutine
*acb
;
4607 trace_bdrv_aio_discard(bs
, sector_num
, nb_sectors
, opaque
);
4609 acb
= qemu_aio_get(&bdrv_em_co_aiocb_info
, bs
, cb
, opaque
);
4610 acb
->req
.sector
= sector_num
;
4611 acb
->req
.nb_sectors
= nb_sectors
;
4613 co
= qemu_coroutine_create(bdrv_aio_discard_co_entry
);
4614 qemu_coroutine_enter(co
, acb
);
4616 return &acb
->common
;
4619 void bdrv_init(void)
4621 module_call_init(MODULE_INIT_BLOCK
);
4624 void bdrv_init_with_whitelist(void)
4626 use_bdrv_whitelist
= 1;
4630 void *qemu_aio_get(const AIOCBInfo
*aiocb_info
, BlockDriverState
*bs
,
4631 BlockDriverCompletionFunc
*cb
, void *opaque
)
4633 BlockDriverAIOCB
*acb
;
4635 acb
= g_slice_alloc(aiocb_info
->aiocb_size
);
4636 acb
->aiocb_info
= aiocb_info
;
4639 acb
->opaque
= opaque
;
4643 void qemu_aio_release(void *p
)
4645 BlockDriverAIOCB
*acb
= p
;
4646 g_slice_free1(acb
->aiocb_info
->aiocb_size
, acb
);
4649 /**************************************************************/
4650 /* Coroutine block device emulation */
4652 typedef struct CoroutineIOCompletion
{
4653 Coroutine
*coroutine
;
4655 } CoroutineIOCompletion
;
4657 static void bdrv_co_io_em_complete(void *opaque
, int ret
)
4659 CoroutineIOCompletion
*co
= opaque
;
4662 qemu_coroutine_enter(co
->coroutine
, NULL
);
4665 static int coroutine_fn
bdrv_co_io_em(BlockDriverState
*bs
, int64_t sector_num
,
4666 int nb_sectors
, QEMUIOVector
*iov
,
4669 CoroutineIOCompletion co
= {
4670 .coroutine
= qemu_coroutine_self(),
4672 BlockDriverAIOCB
*acb
;
4675 acb
= bs
->drv
->bdrv_aio_writev(bs
, sector_num
, iov
, nb_sectors
,
4676 bdrv_co_io_em_complete
, &co
);
4678 acb
= bs
->drv
->bdrv_aio_readv(bs
, sector_num
, iov
, nb_sectors
,
4679 bdrv_co_io_em_complete
, &co
);
4682 trace_bdrv_co_io_em(bs
, sector_num
, nb_sectors
, is_write
, acb
);
4686 qemu_coroutine_yield();
4691 static int coroutine_fn
bdrv_co_readv_em(BlockDriverState
*bs
,
4692 int64_t sector_num
, int nb_sectors
,
4695 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, false);
4698 static int coroutine_fn
bdrv_co_writev_em(BlockDriverState
*bs
,
4699 int64_t sector_num
, int nb_sectors
,
4702 return bdrv_co_io_em(bs
, sector_num
, nb_sectors
, iov
, true);
4705 static void coroutine_fn
bdrv_flush_co_entry(void *opaque
)
4707 RwCo
*rwco
= opaque
;
4709 rwco
->ret
= bdrv_co_flush(rwco
->bs
);
4712 int coroutine_fn
bdrv_co_flush(BlockDriverState
*bs
)
4716 if (!bs
|| !bdrv_is_inserted(bs
) || bdrv_is_read_only(bs
)) {
4720 /* Write back cached data to the OS even with cache=unsafe */
4721 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_OS
);
4722 if (bs
->drv
->bdrv_co_flush_to_os
) {
4723 ret
= bs
->drv
->bdrv_co_flush_to_os(bs
);
4729 /* But don't actually force it to the disk with cache=unsafe */
4730 if (bs
->open_flags
& BDRV_O_NO_FLUSH
) {
4734 BLKDBG_EVENT(bs
->file
, BLKDBG_FLUSH_TO_DISK
);
4735 if (bs
->drv
->bdrv_co_flush_to_disk
) {
4736 ret
= bs
->drv
->bdrv_co_flush_to_disk(bs
);
4737 } else if (bs
->drv
->bdrv_aio_flush
) {
4738 BlockDriverAIOCB
*acb
;
4739 CoroutineIOCompletion co
= {
4740 .coroutine
= qemu_coroutine_self(),
4743 acb
= bs
->drv
->bdrv_aio_flush(bs
, bdrv_co_io_em_complete
, &co
);
4747 qemu_coroutine_yield();
4752 * Some block drivers always operate in either writethrough or unsafe
4753 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4754 * know how the server works (because the behaviour is hardcoded or
4755 * depends on server-side configuration), so we can't ensure that
4756 * everything is safe on disk. Returning an error doesn't work because
4757 * that would break guests even if the server operates in writethrough
4760 * Let's hope the user knows what he's doing.
4768 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4769 * in the case of cache=unsafe, so there are no useless flushes.
4772 return bdrv_co_flush(bs
->file
);
4775 void bdrv_invalidate_cache(BlockDriverState
*bs
)
4777 if (bs
->drv
&& bs
->drv
->bdrv_invalidate_cache
) {
4778 bs
->drv
->bdrv_invalidate_cache(bs
);
4782 void bdrv_invalidate_cache_all(void)
4784 BlockDriverState
*bs
;
4786 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4787 bdrv_invalidate_cache(bs
);
4791 void bdrv_clear_incoming_migration_all(void)
4793 BlockDriverState
*bs
;
4795 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
4796 bs
->open_flags
= bs
->open_flags
& ~(BDRV_O_INCOMING
);
4800 int bdrv_flush(BlockDriverState
*bs
)
4808 if (qemu_in_coroutine()) {
4809 /* Fast-path if already in coroutine context */
4810 bdrv_flush_co_entry(&rwco
);
4812 co
= qemu_coroutine_create(bdrv_flush_co_entry
);
4813 qemu_coroutine_enter(co
, &rwco
);
4814 while (rwco
.ret
== NOT_DONE
) {
4822 typedef struct DiscardCo
{
4823 BlockDriverState
*bs
;
4828 static void coroutine_fn
bdrv_discard_co_entry(void *opaque
)
4830 DiscardCo
*rwco
= opaque
;
4832 rwco
->ret
= bdrv_co_discard(rwco
->bs
, rwco
->sector_num
, rwco
->nb_sectors
);
4835 /* if no limit is specified in the BlockLimits use a default
4836 * of 32768 512-byte sectors (16 MiB) per request.
4838 #define MAX_DISCARD_DEFAULT 32768
4840 int coroutine_fn
bdrv_co_discard(BlockDriverState
*bs
, int64_t sector_num
,
4847 } else if (bdrv_check_request(bs
, sector_num
, nb_sectors
)) {
4849 } else if (bs
->read_only
) {
4853 bdrv_reset_dirty(bs
, sector_num
, nb_sectors
);
4855 /* Do nothing if disabled. */
4856 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
4860 if (!bs
->drv
->bdrv_co_discard
&& !bs
->drv
->bdrv_aio_discard
) {
4864 max_discard
= bs
->bl
.max_discard
? bs
->bl
.max_discard
: MAX_DISCARD_DEFAULT
;
4865 while (nb_sectors
> 0) {
4867 int num
= nb_sectors
;
4870 if (bs
->bl
.discard_alignment
&&
4871 num
>= bs
->bl
.discard_alignment
&&
4872 sector_num
% bs
->bl
.discard_alignment
) {
4873 if (num
> bs
->bl
.discard_alignment
) {
4874 num
= bs
->bl
.discard_alignment
;
4876 num
-= sector_num
% bs
->bl
.discard_alignment
;
4879 /* limit request size */
4880 if (num
> max_discard
) {
4884 if (bs
->drv
->bdrv_co_discard
) {
4885 ret
= bs
->drv
->bdrv_co_discard(bs
, sector_num
, num
);
4887 BlockDriverAIOCB
*acb
;
4888 CoroutineIOCompletion co
= {
4889 .coroutine
= qemu_coroutine_self(),
4892 acb
= bs
->drv
->bdrv_aio_discard(bs
, sector_num
, nb_sectors
,
4893 bdrv_co_io_em_complete
, &co
);
4897 qemu_coroutine_yield();
4901 if (ret
&& ret
!= -ENOTSUP
) {
4911 int bdrv_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
4916 .sector_num
= sector_num
,
4917 .nb_sectors
= nb_sectors
,
4921 if (qemu_in_coroutine()) {
4922 /* Fast-path if already in coroutine context */
4923 bdrv_discard_co_entry(&rwco
);
4925 co
= qemu_coroutine_create(bdrv_discard_co_entry
);
4926 qemu_coroutine_enter(co
, &rwco
);
4927 while (rwco
.ret
== NOT_DONE
) {
4935 /**************************************************************/
4936 /* removable device support */
4939 * Return TRUE if the media is present
4941 int bdrv_is_inserted(BlockDriverState
*bs
)
4943 BlockDriver
*drv
= bs
->drv
;
4947 if (!drv
->bdrv_is_inserted
)
4949 return drv
->bdrv_is_inserted(bs
);
4953 * Return whether the media changed since the last call to this
4954 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4956 int bdrv_media_changed(BlockDriverState
*bs
)
4958 BlockDriver
*drv
= bs
->drv
;
4960 if (drv
&& drv
->bdrv_media_changed
) {
4961 return drv
->bdrv_media_changed(bs
);
4967 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4969 void bdrv_eject(BlockDriverState
*bs
, bool eject_flag
)
4971 BlockDriver
*drv
= bs
->drv
;
4973 if (drv
&& drv
->bdrv_eject
) {
4974 drv
->bdrv_eject(bs
, eject_flag
);
4977 if (bs
->device_name
[0] != '\0') {
4978 bdrv_emit_qmp_eject_event(bs
, eject_flag
);
4983 * Lock or unlock the media (if it is locked, the user won't be able
4984 * to eject it manually).
4986 void bdrv_lock_medium(BlockDriverState
*bs
, bool locked
)
4988 BlockDriver
*drv
= bs
->drv
;
4990 trace_bdrv_lock_medium(bs
, locked
);
4992 if (drv
&& drv
->bdrv_lock_medium
) {
4993 drv
->bdrv_lock_medium(bs
, locked
);
4997 /* needed for generic scsi interface */
4999 int bdrv_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
5001 BlockDriver
*drv
= bs
->drv
;
5003 if (drv
&& drv
->bdrv_ioctl
)
5004 return drv
->bdrv_ioctl(bs
, req
, buf
);
5008 BlockDriverAIOCB
*bdrv_aio_ioctl(BlockDriverState
*bs
,
5009 unsigned long int req
, void *buf
,
5010 BlockDriverCompletionFunc
*cb
, void *opaque
)
5012 BlockDriver
*drv
= bs
->drv
;
5014 if (drv
&& drv
->bdrv_aio_ioctl
)
5015 return drv
->bdrv_aio_ioctl(bs
, req
, buf
, cb
, opaque
);
5019 void bdrv_set_guest_block_size(BlockDriverState
*bs
, int align
)
5021 bs
->guest_block_size
= align
;
5024 void *qemu_blockalign(BlockDriverState
*bs
, size_t size
)
5026 return qemu_memalign(bdrv_opt_mem_align(bs
), size
);
5030 * Check if all memory in this vector is sector aligned.
5032 bool bdrv_qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
5035 size_t alignment
= bdrv_opt_mem_align(bs
);
5037 for (i
= 0; i
< qiov
->niov
; i
++) {
5038 if ((uintptr_t) qiov
->iov
[i
].iov_base
% alignment
) {
5041 if (qiov
->iov
[i
].iov_len
% alignment
) {
5049 BdrvDirtyBitmap
*bdrv_create_dirty_bitmap(BlockDriverState
*bs
, int granularity
)
5051 int64_t bitmap_size
;
5052 BdrvDirtyBitmap
*bitmap
;
5054 assert((granularity
& (granularity
- 1)) == 0);
5056 granularity
>>= BDRV_SECTOR_BITS
;
5057 assert(granularity
);
5058 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
);
5059 bitmap
= g_malloc0(sizeof(BdrvDirtyBitmap
));
5060 bitmap
->bitmap
= hbitmap_alloc(bitmap_size
, ffs(granularity
) - 1);
5061 QLIST_INSERT_HEAD(&bs
->dirty_bitmaps
, bitmap
, list
);
5065 void bdrv_release_dirty_bitmap(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5067 BdrvDirtyBitmap
*bm
, *next
;
5068 QLIST_FOREACH_SAFE(bm
, &bs
->dirty_bitmaps
, list
, next
) {
5070 QLIST_REMOVE(bitmap
, list
);
5071 hbitmap_free(bitmap
->bitmap
);
5078 BlockDirtyInfoList
*bdrv_query_dirty_bitmaps(BlockDriverState
*bs
)
5080 BdrvDirtyBitmap
*bm
;
5081 BlockDirtyInfoList
*list
= NULL
;
5082 BlockDirtyInfoList
**plist
= &list
;
5084 QLIST_FOREACH(bm
, &bs
->dirty_bitmaps
, list
) {
5085 BlockDirtyInfo
*info
= g_malloc0(sizeof(BlockDirtyInfo
));
5086 BlockDirtyInfoList
*entry
= g_malloc0(sizeof(BlockDirtyInfoList
));
5087 info
->count
= bdrv_get_dirty_count(bs
, bm
);
5089 ((int64_t) BDRV_SECTOR_SIZE
<< hbitmap_granularity(bm
->bitmap
));
5090 entry
->value
= info
;
5092 plist
= &entry
->next
;
5098 int bdrv_get_dirty(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
, int64_t sector
)
5101 return hbitmap_get(bitmap
->bitmap
, sector
);
5107 void bdrv_dirty_iter_init(BlockDriverState
*bs
,
5108 BdrvDirtyBitmap
*bitmap
, HBitmapIter
*hbi
)
5110 hbitmap_iter_init(hbi
, bitmap
->bitmap
, 0);
5113 void bdrv_set_dirty(BlockDriverState
*bs
, int64_t cur_sector
,
5116 BdrvDirtyBitmap
*bitmap
;
5117 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5118 hbitmap_set(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5122 void bdrv_reset_dirty(BlockDriverState
*bs
, int64_t cur_sector
, int nr_sectors
)
5124 BdrvDirtyBitmap
*bitmap
;
5125 QLIST_FOREACH(bitmap
, &bs
->dirty_bitmaps
, list
) {
5126 hbitmap_reset(bitmap
->bitmap
, cur_sector
, nr_sectors
);
5130 int64_t bdrv_get_dirty_count(BlockDriverState
*bs
, BdrvDirtyBitmap
*bitmap
)
5132 return hbitmap_count(bitmap
->bitmap
);
5135 /* Get a reference to bs */
5136 void bdrv_ref(BlockDriverState
*bs
)
5141 /* Release a previously grabbed reference to bs.
5142 * If after releasing, reference count is zero, the BlockDriverState is
5144 void bdrv_unref(BlockDriverState
*bs
)
5146 assert(bs
->refcnt
> 0);
5147 if (--bs
->refcnt
== 0) {
5152 void bdrv_set_in_use(BlockDriverState
*bs
, int in_use
)
5154 assert(bs
->in_use
!= in_use
);
5155 bs
->in_use
= in_use
;
5158 int bdrv_in_use(BlockDriverState
*bs
)
5163 void bdrv_iostatus_enable(BlockDriverState
*bs
)
5165 bs
->iostatus_enabled
= true;
5166 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5169 /* The I/O status is only enabled if the drive explicitly
5170 * enables it _and_ the VM is configured to stop on errors */
5171 bool bdrv_iostatus_is_enabled(const BlockDriverState
*bs
)
5173 return (bs
->iostatus_enabled
&&
5174 (bs
->on_write_error
== BLOCKDEV_ON_ERROR_ENOSPC
||
5175 bs
->on_write_error
== BLOCKDEV_ON_ERROR_STOP
||
5176 bs
->on_read_error
== BLOCKDEV_ON_ERROR_STOP
));
5179 void bdrv_iostatus_disable(BlockDriverState
*bs
)
5181 bs
->iostatus_enabled
= false;
5184 void bdrv_iostatus_reset(BlockDriverState
*bs
)
5186 if (bdrv_iostatus_is_enabled(bs
)) {
5187 bs
->iostatus
= BLOCK_DEVICE_IO_STATUS_OK
;
5189 block_job_iostatus_reset(bs
->job
);
5194 void bdrv_iostatus_set_err(BlockDriverState
*bs
, int error
)
5196 assert(bdrv_iostatus_is_enabled(bs
));
5197 if (bs
->iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
5198 bs
->iostatus
= error
== ENOSPC
? BLOCK_DEVICE_IO_STATUS_NOSPACE
:
5199 BLOCK_DEVICE_IO_STATUS_FAILED
;
5204 bdrv_acct_start(BlockDriverState
*bs
, BlockAcctCookie
*cookie
, int64_t bytes
,
5205 enum BlockAcctType type
)
5207 assert(type
< BDRV_MAX_IOTYPE
);
5209 cookie
->bytes
= bytes
;
5210 cookie
->start_time_ns
= get_clock();
5211 cookie
->type
= type
;
5215 bdrv_acct_done(BlockDriverState
*bs
, BlockAcctCookie
*cookie
)
5217 assert(cookie
->type
< BDRV_MAX_IOTYPE
);
5219 bs
->nr_bytes
[cookie
->type
] += cookie
->bytes
;
5220 bs
->nr_ops
[cookie
->type
]++;
5221 bs
->total_time_ns
[cookie
->type
] += get_clock() - cookie
->start_time_ns
;
5224 void bdrv_img_create(const char *filename
, const char *fmt
,
5225 const char *base_filename
, const char *base_fmt
,
5226 char *options
, uint64_t img_size
, int flags
,
5227 Error
**errp
, bool quiet
)
5229 QEMUOptionParameter
*param
= NULL
, *create_options
= NULL
;
5230 QEMUOptionParameter
*backing_fmt
, *backing_file
, *size
;
5231 BlockDriver
*drv
, *proto_drv
;
5232 BlockDriver
*backing_drv
= NULL
;
5233 Error
*local_err
= NULL
;
5236 /* Find driver and parse its options */
5237 drv
= bdrv_find_format(fmt
);
5239 error_setg(errp
, "Unknown file format '%s'", fmt
);
5243 proto_drv
= bdrv_find_protocol(filename
, true);
5245 error_setg(errp
, "Unknown protocol '%s'", filename
);
5249 create_options
= append_option_parameters(create_options
,
5250 drv
->create_options
);
5251 create_options
= append_option_parameters(create_options
,
5252 proto_drv
->create_options
);
5254 /* Create parameter list with default values */
5255 param
= parse_option_parameters("", create_options
, param
);
5257 set_option_parameter_int(param
, BLOCK_OPT_SIZE
, img_size
);
5259 /* Parse -o options */
5261 param
= parse_option_parameters(options
, create_options
, param
);
5262 if (param
== NULL
) {
5263 error_setg(errp
, "Invalid options for file format '%s'.", fmt
);
5268 if (base_filename
) {
5269 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FILE
,
5271 error_setg(errp
, "Backing file not supported for file format '%s'",
5278 if (set_option_parameter(param
, BLOCK_OPT_BACKING_FMT
, base_fmt
)) {
5279 error_setg(errp
, "Backing file format not supported for file "
5280 "format '%s'", fmt
);
5285 backing_file
= get_option_parameter(param
, BLOCK_OPT_BACKING_FILE
);
5286 if (backing_file
&& backing_file
->value
.s
) {
5287 if (!strcmp(filename
, backing_file
->value
.s
)) {
5288 error_setg(errp
, "Error: Trying to create an image with the "
5289 "same filename as the backing file");
5294 backing_fmt
= get_option_parameter(param
, BLOCK_OPT_BACKING_FMT
);
5295 if (backing_fmt
&& backing_fmt
->value
.s
) {
5296 backing_drv
= bdrv_find_format(backing_fmt
->value
.s
);
5298 error_setg(errp
, "Unknown backing file format '%s'",
5299 backing_fmt
->value
.s
);
5304 // The size for the image must always be specified, with one exception:
5305 // If we are using a backing file, we can obtain the size from there
5306 size
= get_option_parameter(param
, BLOCK_OPT_SIZE
);
5307 if (size
&& size
->value
.n
== -1) {
5308 if (backing_file
&& backing_file
->value
.s
) {
5309 BlockDriverState
*bs
;
5314 /* backing files always opened read-only */
5316 flags
& ~(BDRV_O_RDWR
| BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
5319 ret
= bdrv_open(&bs
, backing_file
->value
.s
, NULL
, NULL
, back_flags
,
5320 backing_drv
, &local_err
);
5322 error_setg_errno(errp
, -ret
, "Could not open '%s': %s",
5323 backing_file
->value
.s
,
5324 error_get_pretty(local_err
));
5325 error_free(local_err
);
5329 bdrv_get_geometry(bs
, &size
);
5332 snprintf(buf
, sizeof(buf
), "%" PRId64
, size
);
5333 set_option_parameter(param
, BLOCK_OPT_SIZE
, buf
);
5337 error_setg(errp
, "Image creation needs a size parameter");
5343 printf("Formatting '%s', fmt=%s ", filename
, fmt
);
5344 print_option_parameters(param
);
5347 ret
= bdrv_create(drv
, filename
, param
, &local_err
);
5348 if (ret
== -EFBIG
) {
5349 /* This is generally a better message than whatever the driver would
5350 * deliver (especially because of the cluster_size_hint), since that
5351 * is most probably not much different from "image too large". */
5352 const char *cluster_size_hint
= "";
5353 if (get_option_parameter(create_options
, BLOCK_OPT_CLUSTER_SIZE
)) {
5354 cluster_size_hint
= " (try using a larger cluster size)";
5356 error_setg(errp
, "The image size is too large for file format '%s'"
5357 "%s", fmt
, cluster_size_hint
);
5358 error_free(local_err
);
5363 free_option_parameters(create_options
);
5364 free_option_parameters(param
);
5367 error_propagate(errp
, local_err
);
5371 AioContext
*bdrv_get_aio_context(BlockDriverState
*bs
)
5373 /* Currently BlockDriverState always uses the main loop AioContext */
5374 return qemu_get_aio_context();
5377 void bdrv_add_before_write_notifier(BlockDriverState
*bs
,
5378 NotifierWithReturn
*notifier
)
5380 notifier_with_return_list_add(&bs
->before_write_notifiers
, notifier
);
5383 int bdrv_amend_options(BlockDriverState
*bs
, QEMUOptionParameter
*options
)
5385 if (bs
->drv
->bdrv_amend_options
== NULL
) {
5388 return bs
->drv
->bdrv_amend_options(bs
, options
);
5391 /* Used to recurse on single child block filters.
5392 * Single child block filter will store their child in bs->file.
5394 bool bdrv_generic_is_first_non_filter(BlockDriverState
*bs
,
5395 BlockDriverState
*candidate
)
5401 if (!bs
->drv
->authorizations
[BS_IS_A_FILTER
]) {
5402 if (bs
== candidate
) {
5409 if (!bs
->drv
->authorizations
[BS_FILTER_PASS_DOWN
]) {
5417 return bdrv_recurse_is_first_non_filter(bs
->file
, candidate
);
5420 bool bdrv_recurse_is_first_non_filter(BlockDriverState
*bs
,
5421 BlockDriverState
*candidate
)
5423 if (bs
->drv
&& bs
->drv
->bdrv_recurse_is_first_non_filter
) {
5424 return bs
->drv
->bdrv_recurse_is_first_non_filter(bs
, candidate
);
5427 return bdrv_generic_is_first_non_filter(bs
, candidate
);
5430 /* This function checks if the candidate is the first non filter bs down it's
5431 * bs chain. Since we don't have pointers to parents it explore all bs chains
5432 * from the top. Some filters can choose not to pass down the recursion.
5434 bool bdrv_is_first_non_filter(BlockDriverState
*candidate
)
5436 BlockDriverState
*bs
;
5438 /* walk down the bs forest recursively */
5439 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
5442 perm
= bdrv_recurse_is_first_non_filter(bs
, candidate
);
5444 /* candidate is the first non filter */