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 "block/block_int.h"
28 #include "block/blockjob.h"
29 #include "qemu/module.h"
30 #include "qapi/qmp/qjson.h"
31 #include "sysemu/sysemu.h"
32 #include "qemu/notify.h"
33 #include "block/coroutine.h"
34 #include "block/qapi.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
37 #include "qapi-event.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
,
182 bdrv_get_aio_context(bs
),
184 bdrv_throttle_read_timer_cb
,
185 bdrv_throttle_write_timer_cb
,
187 bs
->io_limits_enabled
= true;
190 /* This function makes an IO wait if needed
192 * @nb_sectors: the number of sectors of the IO
193 * @is_write: is the IO a write
195 static void bdrv_io_limits_intercept(BlockDriverState
*bs
,
199 /* does this io must wait */
200 bool must_wait
= throttle_schedule_timer(&bs
->throttle_state
, is_write
);
202 /* if must wait or any request of this type throttled queue the IO */
204 !qemu_co_queue_empty(&bs
->throttled_reqs
[is_write
])) {
205 qemu_co_queue_wait(&bs
->throttled_reqs
[is_write
]);
208 /* the IO will be executed, do the accounting */
209 throttle_account(&bs
->throttle_state
, is_write
, bytes
);
212 /* if the next request must wait -> do nothing */
213 if (throttle_schedule_timer(&bs
->throttle_state
, is_write
)) {
217 /* else queue next request for execution */
218 qemu_co_queue_next(&bs
->throttled_reqs
[is_write
]);
221 size_t bdrv_opt_mem_align(BlockDriverState
*bs
)
223 if (!bs
|| !bs
->drv
) {
224 /* 4k should be on the safe side */
228 return bs
->bl
.opt_mem_alignment
;
231 /* check if the path starts with "<protocol>:" */
232 static int path_has_protocol(const char *path
)
237 if (is_windows_drive(path
) ||
238 is_windows_drive_prefix(path
)) {
241 p
= path
+ strcspn(path
, ":/\\");
243 p
= path
+ strcspn(path
, ":/");
249 int path_is_absolute(const char *path
)
252 /* specific case for names like: "\\.\d:" */
253 if (is_windows_drive(path
) || is_windows_drive_prefix(path
)) {
256 return (*path
== '/' || *path
== '\\');
258 return (*path
== '/');
262 /* if filename is absolute, just copy it to dest. Otherwise, build a
263 path to it by considering it is relative to base_path. URL are
265 void path_combine(char *dest
, int dest_size
,
266 const char *base_path
,
267 const char *filename
)
274 if (path_is_absolute(filename
)) {
275 pstrcpy(dest
, dest_size
, filename
);
277 p
= strchr(base_path
, ':');
282 p1
= strrchr(base_path
, '/');
286 p2
= strrchr(base_path
, '\\');
298 if (len
> dest_size
- 1)
300 memcpy(dest
, base_path
, len
);
302 pstrcat(dest
, dest_size
, filename
);
306 void bdrv_get_full_backing_filename(BlockDriverState
*bs
, char *dest
, size_t sz
)
308 if (bs
->backing_file
[0] == '\0' || path_has_protocol(bs
->backing_file
)) {
309 pstrcpy(dest
, sz
, bs
->backing_file
);
311 path_combine(dest
, sz
, bs
->filename
, bs
->backing_file
);
315 void bdrv_register(BlockDriver
*bdrv
)
317 /* Block drivers without coroutine functions need emulation */
318 if (!bdrv
->bdrv_co_readv
) {
319 bdrv
->bdrv_co_readv
= bdrv_co_readv_em
;
320 bdrv
->bdrv_co_writev
= bdrv_co_writev_em
;
322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
323 * the block driver lacks aio we need to emulate that too.
325 if (!bdrv
->bdrv_aio_readv
) {
326 /* add AIO emulation layer */
327 bdrv
->bdrv_aio_readv
= bdrv_aio_readv_em
;
328 bdrv
->bdrv_aio_writev
= bdrv_aio_writev_em
;
332 QLIST_INSERT_HEAD(&bdrv_drivers
, bdrv
, list
);
335 /* create a new block device (by default it is empty) */
336 BlockDriverState
*bdrv_new(const char *device_name
, Error
**errp
)
338 BlockDriverState
*bs
;
341 if (bdrv_find(device_name
)) {
342 error_setg(errp
, "Device with id '%s' already exists",
346 if (bdrv_find_node(device_name
)) {
347 error_setg(errp
, "Device with node-name '%s' already exists",
352 bs
= g_malloc0(sizeof(BlockDriverState
));
353 QLIST_INIT(&bs
->dirty_bitmaps
);
354 pstrcpy(bs
->device_name
, sizeof(bs
->device_name
), device_name
);
355 if (device_name
[0] != '\0') {
356 QTAILQ_INSERT_TAIL(&bdrv_states
, bs
, device_list
);
358 for (i
= 0; i
< BLOCK_OP_TYPE_MAX
; i
++) {
359 QLIST_INIT(&bs
->op_blockers
[i
]);
361 bdrv_iostatus_disable(bs
);
362 notifier_list_init(&bs
->close_notifiers
);
363 notifier_with_return_list_init(&bs
->before_write_notifiers
);
364 qemu_co_queue_init(&bs
->throttled_reqs
[0]);
365 qemu_co_queue_init(&bs
->throttled_reqs
[1]);
367 bs
->aio_context
= qemu_get_aio_context();
372 void bdrv_add_close_notifier(BlockDriverState
*bs
, Notifier
*notify
)
374 notifier_list_add(&bs
->close_notifiers
, notify
);
377 BlockDriver
*bdrv_find_format(const char *format_name
)
380 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
381 if (!strcmp(drv1
->format_name
, format_name
)) {
388 static int bdrv_is_whitelisted(BlockDriver
*drv
, bool read_only
)
390 static const char *whitelist_rw
[] = {
391 CONFIG_BDRV_RW_WHITELIST
393 static const char *whitelist_ro
[] = {
394 CONFIG_BDRV_RO_WHITELIST
398 if (!whitelist_rw
[0] && !whitelist_ro
[0]) {
399 return 1; /* no whitelist, anything goes */
402 for (p
= whitelist_rw
; *p
; p
++) {
403 if (!strcmp(drv
->format_name
, *p
)) {
408 for (p
= whitelist_ro
; *p
; p
++) {
409 if (!strcmp(drv
->format_name
, *p
)) {
417 BlockDriver
*bdrv_find_whitelisted_format(const char *format_name
,
420 BlockDriver
*drv
= bdrv_find_format(format_name
);
421 return drv
&& bdrv_is_whitelisted(drv
, read_only
) ? drv
: NULL
;
424 typedef struct CreateCo
{
432 static void coroutine_fn
bdrv_create_co_entry(void *opaque
)
434 Error
*local_err
= NULL
;
437 CreateCo
*cco
= opaque
;
440 ret
= cco
->drv
->bdrv_create(cco
->filename
, cco
->opts
, &local_err
);
442 error_propagate(&cco
->err
, local_err
);
447 int bdrv_create(BlockDriver
*drv
, const char* filename
,
448 QemuOpts
*opts
, Error
**errp
)
455 .filename
= g_strdup(filename
),
461 if (!drv
->bdrv_create
) {
462 error_setg(errp
, "Driver '%s' does not support image creation", drv
->format_name
);
467 if (qemu_in_coroutine()) {
468 /* Fast-path if already in coroutine context */
469 bdrv_create_co_entry(&cco
);
471 co
= qemu_coroutine_create(bdrv_create_co_entry
);
472 qemu_coroutine_enter(co
, &cco
);
473 while (cco
.ret
== NOT_DONE
) {
481 error_propagate(errp
, cco
.err
);
483 error_setg_errno(errp
, -ret
, "Could not create image");
488 g_free(cco
.filename
);
492 int bdrv_create_file(const char *filename
, QemuOpts
*opts
, Error
**errp
)
495 Error
*local_err
= NULL
;
498 drv
= bdrv_find_protocol(filename
, true);
500 error_setg(errp
, "Could not find protocol for file '%s'", filename
);
504 ret
= bdrv_create(drv
, filename
, opts
, &local_err
);
506 error_propagate(errp
, local_err
);
511 int bdrv_refresh_limits(BlockDriverState
*bs
)
513 BlockDriver
*drv
= bs
->drv
;
515 memset(&bs
->bl
, 0, sizeof(bs
->bl
));
521 /* Take some limits from the children as a default */
523 bdrv_refresh_limits(bs
->file
);
524 bs
->bl
.opt_transfer_length
= bs
->file
->bl
.opt_transfer_length
;
525 bs
->bl
.opt_mem_alignment
= bs
->file
->bl
.opt_mem_alignment
;
527 bs
->bl
.opt_mem_alignment
= 512;
530 if (bs
->backing_hd
) {
531 bdrv_refresh_limits(bs
->backing_hd
);
532 bs
->bl
.opt_transfer_length
=
533 MAX(bs
->bl
.opt_transfer_length
,
534 bs
->backing_hd
->bl
.opt_transfer_length
);
535 bs
->bl
.opt_mem_alignment
=
536 MAX(bs
->bl
.opt_mem_alignment
,
537 bs
->backing_hd
->bl
.opt_mem_alignment
);
540 /* Then let the driver override it */
541 if (drv
->bdrv_refresh_limits
) {
542 return drv
->bdrv_refresh_limits(bs
);
549 * Create a uniquely-named empty temporary file.
550 * Return 0 upon success, otherwise a negative errno value.
552 int get_tmp_filename(char *filename
, int size
)
555 char temp_dir
[MAX_PATH
];
556 /* GetTempFileName requires that its output buffer (4th param)
557 have length MAX_PATH or greater. */
558 assert(size
>= MAX_PATH
);
559 return (GetTempPath(MAX_PATH
, temp_dir
)
560 && GetTempFileName(temp_dir
, "qem", 0, filename
)
561 ?
0 : -GetLastError());
565 tmpdir
= getenv("TMPDIR");
569 if (snprintf(filename
, size
, "%s/vl.XXXXXX", tmpdir
) >= size
) {
572 fd
= mkstemp(filename
);
576 if (close(fd
) != 0) {
585 * Detect host devices. By convention, /dev/cdrom[N] is always
586 * recognized as a host CDROM.
588 static BlockDriver
*find_hdev_driver(const char *filename
)
590 int score_max
= 0, score
;
591 BlockDriver
*drv
= NULL
, *d
;
593 QLIST_FOREACH(d
, &bdrv_drivers
, list
) {
594 if (d
->bdrv_probe_device
) {
595 score
= d
->bdrv_probe_device(filename
);
596 if (score
> score_max
) {
606 BlockDriver
*bdrv_find_protocol(const char *filename
,
607 bool allow_protocol_prefix
)
614 /* TODO Drivers without bdrv_file_open must be specified explicitly */
617 * XXX(hch): we really should not let host device detection
618 * override an explicit protocol specification, but moving this
619 * later breaks access to device names with colons in them.
620 * Thanks to the brain-dead persistent naming schemes on udev-
621 * based Linux systems those actually are quite common.
623 drv1
= find_hdev_driver(filename
);
628 if (!path_has_protocol(filename
) || !allow_protocol_prefix
) {
629 return bdrv_find_format("file");
632 p
= strchr(filename
, ':');
635 if (len
> sizeof(protocol
) - 1)
636 len
= sizeof(protocol
) - 1;
637 memcpy(protocol
, filename
, len
);
638 protocol
[len
] = '\0';
639 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
640 if (drv1
->protocol_name
&&
641 !strcmp(drv1
->protocol_name
, protocol
)) {
648 static int find_image_format(BlockDriverState
*bs
, const char *filename
,
649 BlockDriver
**pdrv
, Error
**errp
)
651 int score
, score_max
;
652 BlockDriver
*drv1
, *drv
;
656 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
657 if (bs
->sg
|| !bdrv_is_inserted(bs
) || bdrv_getlength(bs
) == 0) {
658 drv
= bdrv_find_format("raw");
660 error_setg(errp
, "Could not find raw image format");
667 ret
= bdrv_pread(bs
, 0, buf
, sizeof(buf
));
669 error_setg_errno(errp
, -ret
, "Could not read image for determining its "
677 QLIST_FOREACH(drv1
, &bdrv_drivers
, list
) {
678 if (drv1
->bdrv_probe
) {
679 score
= drv1
->bdrv_probe(buf
, ret
, filename
);
680 if (score
> score_max
) {
687 error_setg(errp
, "Could not determine image format: No compatible "
696 * Set the current 'total_sectors' value
698 static int refresh_total_sectors(BlockDriverState
*bs
, int64_t hint
)
700 BlockDriver
*drv
= bs
->drv
;
702 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
706 /* query actual device if possible, otherwise just trust the hint */
707 if (drv
->bdrv_getlength
) {
708 int64_t length
= drv
->bdrv_getlength(bs
);
712 hint
= DIV_ROUND_UP(length
, BDRV_SECTOR_SIZE
);
715 bs
->total_sectors
= hint
;
720 * Set open flags for a given discard mode
722 * Return 0 on success, -1 if the discard mode was invalid.
724 int bdrv_parse_discard_flags(const char *mode
, int *flags
)
726 *flags
&= ~BDRV_O_UNMAP
;
728 if (!strcmp(mode
, "off") || !strcmp(mode
, "ignore")) {
730 } else if (!strcmp(mode
, "on") || !strcmp(mode
, "unmap")) {
731 *flags
|= BDRV_O_UNMAP
;
740 * Set open flags for a given cache mode
742 * Return 0 on success, -1 if the cache mode was invalid.
744 int bdrv_parse_cache_flags(const char *mode
, int *flags
)
746 *flags
&= ~BDRV_O_CACHE_MASK
;
748 if (!strcmp(mode
, "off") || !strcmp(mode
, "none")) {
749 *flags
|= BDRV_O_NOCACHE
| BDRV_O_CACHE_WB
;
750 } else if (!strcmp(mode
, "directsync")) {
751 *flags
|= BDRV_O_NOCACHE
;
752 } else if (!strcmp(mode
, "writeback")) {
753 *flags
|= BDRV_O_CACHE_WB
;
754 } else if (!strcmp(mode
, "unsafe")) {
755 *flags
|= BDRV_O_CACHE_WB
;
756 *flags
|= BDRV_O_NO_FLUSH
;
757 } else if (!strcmp(mode
, "writethrough")) {
758 /* this is the default */
767 * The copy-on-read flag is actually a reference count so multiple users may
768 * use the feature without worrying about clobbering its previous state.
769 * Copy-on-read stays enabled until all users have called to disable it.
771 void bdrv_enable_copy_on_read(BlockDriverState
*bs
)
776 void bdrv_disable_copy_on_read(BlockDriverState
*bs
)
778 assert(bs
->copy_on_read
> 0);
783 * Returns the flags that a temporary snapshot should get, based on the
784 * originally requested flags (the originally requested image will have flags
785 * like a backing file)
787 static int bdrv_temp_snapshot_flags(int flags
)
789 return (flags
& ~BDRV_O_SNAPSHOT
) | BDRV_O_TEMPORARY
;
793 * Returns the flags that bs->file should get, based on the given flags for
796 static int bdrv_inherited_flags(int flags
)
798 /* Enable protocol handling, disable format probing for bs->file */
799 flags
|= BDRV_O_PROTOCOL
;
801 /* Our block drivers take care to send flushes and respect unmap policy,
802 * so we can enable both unconditionally on lower layers. */
803 flags
|= BDRV_O_CACHE_WB
| BDRV_O_UNMAP
;
805 /* Clear flags that only apply to the top layer */
806 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
| BDRV_O_COPY_ON_READ
);
812 * Returns the flags that bs->backing_hd should get, based on the given flags
815 static int bdrv_backing_flags(int flags
)
817 /* backing files always opened read-only */
818 flags
&= ~(BDRV_O_RDWR
| BDRV_O_COPY_ON_READ
);
820 /* snapshot=on is handled on the top layer */
821 flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_TEMPORARY
);
826 static int bdrv_open_flags(BlockDriverState
*bs
, int flags
)
828 int open_flags
= flags
| BDRV_O_CACHE_WB
;
831 * Clear flags that are internal to the block layer before opening the
834 open_flags
&= ~(BDRV_O_SNAPSHOT
| BDRV_O_NO_BACKING
);
837 * Snapshots should be writable.
839 if (flags
& BDRV_O_TEMPORARY
) {
840 open_flags
|= BDRV_O_RDWR
;
846 static void bdrv_assign_node_name(BlockDriverState
*bs
,
847 const char *node_name
,
854 /* empty string node name is invalid */
855 if (node_name
[0] == '\0') {
856 error_setg(errp
, "Empty node name");
860 /* takes care of avoiding namespaces collisions */
861 if (bdrv_find(node_name
)) {
862 error_setg(errp
, "node-name=%s is conflicting with a device id",
867 /* takes care of avoiding duplicates node names */
868 if (bdrv_find_node(node_name
)) {
869 error_setg(errp
, "Duplicate node name");
873 /* copy node name into the bs and insert it into the graph list */
874 pstrcpy(bs
->node_name
, sizeof(bs
->node_name
), node_name
);
875 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs
, node_list
);
879 * Common part for opening disk images and files
881 * Removes all processed options from *options.
883 static int bdrv_open_common(BlockDriverState
*bs
, BlockDriverState
*file
,
884 QDict
*options
, int flags
, BlockDriver
*drv
, Error
**errp
)
887 const char *filename
;
888 const char *node_name
= NULL
;
889 Error
*local_err
= NULL
;
892 assert(bs
->file
== NULL
);
893 assert(options
!= NULL
&& bs
->options
!= options
);
896 filename
= file
->filename
;
898 filename
= qdict_get_try_str(options
, "filename");
901 if (drv
->bdrv_needs_filename
&& !filename
) {
902 error_setg(errp
, "The '%s' block driver requires a file name",
907 trace_bdrv_open_common(bs
, filename ?
: "", flags
, drv
->format_name
);
909 node_name
= qdict_get_try_str(options
, "node-name");
910 bdrv_assign_node_name(bs
, node_name
, &local_err
);
912 error_propagate(errp
, local_err
);
915 qdict_del(options
, "node-name");
917 /* bdrv_open() with directly using a protocol as drv. This layer is already
918 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
919 * and return immediately. */
920 if (file
!= NULL
&& drv
->bdrv_file_open
) {
925 bs
->open_flags
= flags
;
926 bs
->guest_block_size
= 512;
927 bs
->request_alignment
= 512;
928 bs
->zero_beyond_eof
= true;
929 open_flags
= bdrv_open_flags(bs
, flags
);
930 bs
->read_only
= !(open_flags
& BDRV_O_RDWR
);
932 if (use_bdrv_whitelist
&& !bdrv_is_whitelisted(drv
, bs
->read_only
)) {
934 !bs
->read_only
&& bdrv_is_whitelisted(drv
, true)
935 ?
"Driver '%s' can only be used for read-only devices"
936 : "Driver '%s' is not whitelisted",
941 assert(bs
->copy_on_read
== 0); /* bdrv_new() and bdrv_close() make it so */
942 if (flags
& BDRV_O_COPY_ON_READ
) {
943 if (!bs
->read_only
) {
944 bdrv_enable_copy_on_read(bs
);
946 error_setg(errp
, "Can't use copy-on-read on read-only device");
951 if (filename
!= NULL
) {
952 pstrcpy(bs
->filename
, sizeof(bs
->filename
), filename
);
954 bs
->filename
[0] = '\0';
958 bs
->opaque
= g_malloc0(drv
->instance_size
);
960 bs
->enable_write_cache
= !!(flags
& BDRV_O_CACHE_WB
);
962 /* Open the image, either directly or using a protocol */
963 if (drv
->bdrv_file_open
) {
964 assert(file
== NULL
);
965 assert(!drv
->bdrv_needs_filename
|| filename
!= NULL
);
966 ret
= drv
->bdrv_file_open(bs
, options
, open_flags
, &local_err
);
969 error_setg(errp
, "Can't use '%s' as a block driver for the "
970 "protocol level", drv
->format_name
);
975 ret
= drv
->bdrv_open(bs
, options
, open_flags
, &local_err
);
980 error_propagate(errp
, local_err
);
981 } else if (bs
->filename
[0]) {
982 error_setg_errno(errp
, -ret
, "Could not open '%s'", bs
->filename
);
984 error_setg_errno(errp
, -ret
, "Could not open image");
989 ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
991 error_setg_errno(errp
, -ret
, "Could not refresh total sector count");
995 bdrv_refresh_limits(bs
);
996 assert(bdrv_opt_mem_align(bs
) != 0);
997 assert((bs
->request_alignment
!= 0) || bs
->sg
);
1009 * Opens a file using a protocol (file, host_device, nbd, ...)
1011 * options is an indirect pointer to a QDict of options to pass to the block
1012 * drivers, or pointer to NULL for an empty set of options. If this function
1013 * takes ownership of the QDict reference, it will set *options to NULL;
1014 * otherwise, it will contain unused/unrecognized options after this function
1015 * returns. Then, the caller is responsible for freeing it. If it intends to
1016 * reuse the QDict, QINCREF() should be called beforehand.
1018 static int bdrv_file_open(BlockDriverState
*bs
, const char *filename
,
1019 QDict
**options
, int flags
, Error
**errp
)
1022 const char *drvname
;
1023 bool parse_filename
= false;
1024 Error
*local_err
= NULL
;
1027 /* Fetch the file name from the options QDict if necessary */
1029 filename
= qdict_get_try_str(*options
, "filename");
1030 } else if (filename
&& !qdict_haskey(*options
, "filename")) {
1031 qdict_put(*options
, "filename", qstring_from_str(filename
));
1032 parse_filename
= true;
1034 error_setg(errp
, "Can't specify 'file' and 'filename' options at the "
1040 /* Find the right block driver */
1041 drvname
= qdict_get_try_str(*options
, "driver");
1043 drv
= bdrv_find_format(drvname
);
1045 error_setg(errp
, "Unknown driver '%s'", drvname
);
1047 qdict_del(*options
, "driver");
1048 } else if (filename
) {
1049 drv
= bdrv_find_protocol(filename
, parse_filename
);
1051 error_setg(errp
, "Unknown protocol");
1054 error_setg(errp
, "Must specify either driver or file");
1059 /* errp has been set already */
1064 /* Parse the filename and open it */
1065 if (drv
->bdrv_parse_filename
&& parse_filename
) {
1066 drv
->bdrv_parse_filename(filename
, *options
, &local_err
);
1068 error_propagate(errp
, local_err
);
1073 if (!drv
->bdrv_needs_filename
) {
1074 qdict_del(*options
, "filename");
1076 filename
= qdict_get_str(*options
, "filename");
1080 if (!drv
->bdrv_file_open
) {
1081 ret
= bdrv_open(&bs
, filename
, NULL
, *options
, flags
, drv
, &local_err
);
1084 ret
= bdrv_open_common(bs
, NULL
, *options
, flags
, drv
, &local_err
);
1087 error_propagate(errp
, local_err
);
1098 void bdrv_set_backing_hd(BlockDriverState
*bs
, BlockDriverState
*backing_hd
)
1101 if (bs
->backing_hd
) {
1102 assert(bs
->backing_blocker
);
1103 bdrv_op_unblock_all(bs
->backing_hd
, bs
->backing_blocker
);
1104 } else if (backing_hd
) {
1105 error_setg(&bs
->backing_blocker
,
1106 "device is used as backing hd of '%s'",
1110 bs
->backing_hd
= backing_hd
;
1112 error_free(bs
->backing_blocker
);
1113 bs
->backing_blocker
= NULL
;
1116 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1117 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_hd
->filename
);
1118 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
),
1119 backing_hd
->drv ? backing_hd
->drv
->format_name
: "");
1121 bdrv_op_block_all(bs
->backing_hd
, bs
->backing_blocker
);
1122 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1123 bdrv_op_unblock(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
,
1124 bs
->backing_blocker
);
1126 bdrv_refresh_limits(bs
);
1130 * Opens the backing file for a BlockDriverState if not yet open
1132 * options is a QDict of options to pass to the block drivers, or NULL for an
1133 * empty set of options. The reference to the QDict is transferred to this
1134 * function (even on failure), so if the caller intends to reuse the dictionary,
1135 * it needs to use QINCREF() before calling bdrv_file_open.
1137 int bdrv_open_backing_file(BlockDriverState
*bs
, QDict
*options
, Error
**errp
)
1139 char *backing_filename
= g_malloc0(PATH_MAX
);
1141 BlockDriver
*back_drv
= NULL
;
1142 BlockDriverState
*backing_hd
;
1143 Error
*local_err
= NULL
;
1145 if (bs
->backing_hd
!= NULL
) {
1150 /* NULL means an empty set of options */
1151 if (options
== NULL
) {
1152 options
= qdict_new();
1155 bs
->open_flags
&= ~BDRV_O_NO_BACKING
;
1156 if (qdict_haskey(options
, "file.filename")) {
1157 backing_filename
[0] = '\0';
1158 } else if (bs
->backing_file
[0] == '\0' && qdict_size(options
) == 0) {
1162 bdrv_get_full_backing_filename(bs
, backing_filename
, PATH_MAX
);
1165 backing_hd
= bdrv_new("", errp
);
1167 if (bs
->backing_format
[0] != '\0') {
1168 back_drv
= bdrv_find_format(bs
->backing_format
);
1171 assert(bs
->backing_hd
== NULL
);
1172 ret
= bdrv_open(&backing_hd
,
1173 *backing_filename ? backing_filename
: NULL
, NULL
, options
,
1174 bdrv_backing_flags(bs
->open_flags
), back_drv
, &local_err
);
1176 bdrv_unref(backing_hd
);
1178 bs
->open_flags
|= BDRV_O_NO_BACKING
;
1179 error_setg(errp
, "Could not open backing file: %s",
1180 error_get_pretty(local_err
));
1181 error_free(local_err
);
1184 bdrv_set_backing_hd(bs
, backing_hd
);
1187 g_free(backing_filename
);
1192 * Opens a disk image whose options are given as BlockdevRef in another block
1195 * If allow_none is true, no image will be opened if filename is false and no
1196 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1198 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1199 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1200 * itself, all options starting with "${bdref_key}." are considered part of the
1203 * The BlockdevRef will be removed from the options QDict.
1205 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1207 int bdrv_open_image(BlockDriverState
**pbs
, const char *filename
,
1208 QDict
*options
, const char *bdref_key
, int flags
,
1209 bool allow_none
, Error
**errp
)
1211 QDict
*image_options
;
1213 char *bdref_key_dot
;
1214 const char *reference
;
1217 assert(*pbs
== NULL
);
1219 bdref_key_dot
= g_strdup_printf("%s.", bdref_key
);
1220 qdict_extract_subqdict(options
, &image_options
, bdref_key_dot
);
1221 g_free(bdref_key_dot
);
1223 reference
= qdict_get_try_str(options
, bdref_key
);
1224 if (!filename
&& !reference
&& !qdict_size(image_options
)) {
1228 error_setg(errp
, "A block device must be specified for \"%s\"",
1232 QDECREF(image_options
);
1236 ret
= bdrv_open(pbs
, filename
, reference
, image_options
, flags
, NULL
, errp
);
1239 qdict_del(options
, bdref_key
);
1243 void bdrv_append_temp_snapshot(BlockDriverState
*bs
, int flags
, Error
**errp
)
1245 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1246 char *tmp_filename
= g_malloc0(PATH_MAX
+ 1);
1248 BlockDriver
*bdrv_qcow2
;
1249 QemuOpts
*opts
= NULL
;
1250 QDict
*snapshot_options
;
1251 BlockDriverState
*bs_snapshot
;
1255 /* if snapshot, we create a temporary backing file and open it
1256 instead of opening 'filename' directly */
1258 /* Get the required size from the image */
1259 total_size
= bdrv_getlength(bs
);
1260 if (total_size
< 0) {
1261 error_setg_errno(errp
, -total_size
, "Could not get image size");
1264 total_size
&= BDRV_SECTOR_MASK
;
1266 /* Create the temporary image */
1267 ret
= get_tmp_filename(tmp_filename
, PATH_MAX
+ 1);
1269 error_setg_errno(errp
, -ret
, "Could not get temporary filename");
1273 bdrv_qcow2
= bdrv_find_format("qcow2");
1274 opts
= qemu_opts_create(bdrv_qcow2
->create_opts
, NULL
, 0,
1276 qemu_opt_set_number(opts
, BLOCK_OPT_SIZE
, total_size
);
1277 ret
= bdrv_create(bdrv_qcow2
, tmp_filename
, opts
, &local_err
);
1278 qemu_opts_del(opts
);
1280 error_setg_errno(errp
, -ret
, "Could not create temporary overlay "
1281 "'%s': %s", tmp_filename
,
1282 error_get_pretty(local_err
));
1283 error_free(local_err
);
1287 /* Prepare a new options QDict for the temporary file */
1288 snapshot_options
= qdict_new();
1289 qdict_put(snapshot_options
, "file.driver",
1290 qstring_from_str("file"));
1291 qdict_put(snapshot_options
, "file.filename",
1292 qstring_from_str(tmp_filename
));
1294 bs_snapshot
= bdrv_new("", &error_abort
);
1296 ret
= bdrv_open(&bs_snapshot
, NULL
, NULL
, snapshot_options
,
1297 flags
, bdrv_qcow2
, &local_err
);
1299 error_propagate(errp
, local_err
);
1303 bdrv_append(bs_snapshot
, bs
);
1306 g_free(tmp_filename
);
1309 static QDict
*parse_json_filename(const char *filename
, Error
**errp
)
1311 QObject
*options_obj
;
1315 ret
= strstart(filename
, "json:", &filename
);
1318 options_obj
= qobject_from_json(filename
);
1320 error_setg(errp
, "Could not parse the JSON options");
1324 if (qobject_type(options_obj
) != QTYPE_QDICT
) {
1325 qobject_decref(options_obj
);
1326 error_setg(errp
, "Invalid JSON object given");
1330 options
= qobject_to_qdict(options_obj
);
1331 qdict_flatten(options
);
1337 * Opens a disk image (raw, qcow2, vmdk, ...)
1339 * options is a QDict of options to pass to the block drivers, or NULL for an
1340 * empty set of options. The reference to the QDict belongs to the block layer
1341 * after the call (even on failure), so if the caller intends to reuse the
1342 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1344 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1345 * If it is not NULL, the referenced BDS will be reused.
1347 * The reference parameter may be used to specify an existing block device which
1348 * should be opened. If specified, neither options nor a filename may be given,
1349 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1351 int bdrv_open(BlockDriverState
**pbs
, const char *filename
,
1352 const char *reference
, QDict
*options
, int flags
,
1353 BlockDriver
*drv
, Error
**errp
)
1356 BlockDriverState
*file
= NULL
, *bs
;
1357 const char *drvname
;
1358 Error
*local_err
= NULL
;
1359 int snapshot_flags
= 0;
1364 bool options_non_empty
= options ?
qdict_size(options
) : false;
1368 error_setg(errp
, "Cannot reuse an existing BDS when referencing "
1369 "another block device");
1373 if (filename
|| options_non_empty
) {
1374 error_setg(errp
, "Cannot reference an existing block device with "
1375 "additional options or a new filename");
1379 bs
= bdrv_lookup_bs(reference
, reference
, errp
);
1391 bs
= bdrv_new("", &error_abort
);
1394 /* NULL means an empty set of options */
1395 if (options
== NULL
) {
1396 options
= qdict_new();
1399 if (filename
&& g_str_has_prefix(filename
, "json:")) {
1400 QDict
*json_options
= parse_json_filename(filename
, &local_err
);
1406 /* Options given in the filename have lower priority than options
1407 * specified directly */
1408 qdict_join(options
, json_options
, false);
1409 QDECREF(json_options
);
1413 bs
->options
= options
;
1414 options
= qdict_clone_shallow(options
);
1416 if (flags
& BDRV_O_PROTOCOL
) {
1418 ret
= bdrv_file_open(bs
, filename
, &options
, flags
& ~BDRV_O_PROTOCOL
,
1423 } else if (bs
->drv
) {
1424 goto close_and_fail
;
1430 /* Open image file without format layer */
1431 if (flags
& BDRV_O_RDWR
) {
1432 flags
|= BDRV_O_ALLOW_RDWR
;
1434 if (flags
& BDRV_O_SNAPSHOT
) {
1435 snapshot_flags
= bdrv_temp_snapshot_flags(flags
);
1436 flags
= bdrv_backing_flags(flags
);
1439 assert(file
== NULL
);
1440 ret
= bdrv_open_image(&file
, filename
, options
, "file",
1441 bdrv_inherited_flags(flags
),
1447 /* Find the right image format driver */
1448 drvname
= qdict_get_try_str(options
, "driver");
1450 drv
= bdrv_find_format(drvname
);
1451 qdict_del(options
, "driver");
1453 error_setg(errp
, "Invalid driver: '%s'", drvname
);
1461 ret
= find_image_format(file
, filename
, &drv
, &local_err
);
1463 error_setg(errp
, "Must specify either driver or file");
1473 /* Open the image */
1474 ret
= bdrv_open_common(bs
, file
, options
, flags
, drv
, &local_err
);
1479 if (file
&& (bs
->file
!= file
)) {
1484 /* If there is a backing file, use it */
1485 if ((flags
& BDRV_O_NO_BACKING
) == 0) {
1486 QDict
*backing_options
;
1488 qdict_extract_subqdict(options
, &backing_options
, "backing.");
1489 ret
= bdrv_open_backing_file(bs
, backing_options
, &local_err
);
1491 goto close_and_fail
;
1495 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1496 * temporary snapshot afterwards. */
1497 if (snapshot_flags
) {
1498 bdrv_append_temp_snapshot(bs
, snapshot_flags
, &local_err
);
1500 error_propagate(errp
, local_err
);
1501 goto close_and_fail
;
1507 /* Check if any unknown options were used */
1508 if (options
&& (qdict_size(options
) != 0)) {
1509 const QDictEntry
*entry
= qdict_first(options
);
1510 if (flags
& BDRV_O_PROTOCOL
) {
1511 error_setg(errp
, "Block protocol '%s' doesn't support the option "
1512 "'%s'", drv
->format_name
, entry
->key
);
1514 error_setg(errp
, "Block format '%s' used by device '%s' doesn't "
1515 "support the option '%s'", drv
->format_name
,
1516 bs
->device_name
, entry
->key
);
1520 goto close_and_fail
;
1523 if (!bdrv_key_required(bs
)) {
1524 bdrv_dev_change_media_cb(bs
, true);
1525 } else if (!runstate_check(RUN_STATE_PRELAUNCH
)
1526 && !runstate_check(RUN_STATE_INMIGRATE
)
1527 && !runstate_check(RUN_STATE_PAUSED
)) { /* HACK */
1529 "Guest must be stopped for opening of encrypted image");
1531 goto close_and_fail
;
1542 QDECREF(bs
->options
);
1546 /* If *pbs is NULL, a new BDS has been created in this function and
1547 needs to be freed now. Otherwise, it does not need to be closed,
1548 since it has not really been opened yet. */
1552 error_propagate(errp
, local_err
);
1557 /* See fail path, but now the BDS has to be always closed */
1565 error_propagate(errp
, local_err
);
1570 typedef struct BlockReopenQueueEntry
{
1572 BDRVReopenState state
;
1573 QSIMPLEQ_ENTRY(BlockReopenQueueEntry
) entry
;
1574 } BlockReopenQueueEntry
;
1577 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1578 * reopen of multiple devices.
1580 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1581 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1582 * be created and initialized. This newly created BlockReopenQueue should be
1583 * passed back in for subsequent calls that are intended to be of the same
1586 * bs is the BlockDriverState to add to the reopen queue.
1588 * flags contains the open flags for the associated bs
1590 * returns a pointer to bs_queue, which is either the newly allocated
1591 * bs_queue, or the existing bs_queue being used.
1594 BlockReopenQueue
*bdrv_reopen_queue(BlockReopenQueue
*bs_queue
,
1595 BlockDriverState
*bs
, int flags
)
1599 BlockReopenQueueEntry
*bs_entry
;
1600 if (bs_queue
== NULL
) {
1601 bs_queue
= g_new0(BlockReopenQueue
, 1);
1602 QSIMPLEQ_INIT(bs_queue
);
1605 /* bdrv_open() masks this flag out */
1606 flags
&= ~BDRV_O_PROTOCOL
;
1609 bdrv_reopen_queue(bs_queue
, bs
->file
, bdrv_inherited_flags(flags
));
1612 bs_entry
= g_new0(BlockReopenQueueEntry
, 1);
1613 QSIMPLEQ_INSERT_TAIL(bs_queue
, bs_entry
, entry
);
1615 bs_entry
->state
.bs
= bs
;
1616 bs_entry
->state
.flags
= flags
;
1622 * Reopen multiple BlockDriverStates atomically & transactionally.
1624 * The queue passed in (bs_queue) must have been built up previous
1625 * via bdrv_reopen_queue().
1627 * Reopens all BDS specified in the queue, with the appropriate
1628 * flags. All devices are prepared for reopen, and failure of any
1629 * device will cause all device changes to be abandonded, and intermediate
1632 * If all devices prepare successfully, then the changes are committed
1636 int bdrv_reopen_multiple(BlockReopenQueue
*bs_queue
, Error
**errp
)
1639 BlockReopenQueueEntry
*bs_entry
, *next
;
1640 Error
*local_err
= NULL
;
1642 assert(bs_queue
!= NULL
);
1646 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1647 if (bdrv_reopen_prepare(&bs_entry
->state
, bs_queue
, &local_err
)) {
1648 error_propagate(errp
, local_err
);
1651 bs_entry
->prepared
= true;
1654 /* If we reach this point, we have success and just need to apply the
1657 QSIMPLEQ_FOREACH(bs_entry
, bs_queue
, entry
) {
1658 bdrv_reopen_commit(&bs_entry
->state
);
1664 QSIMPLEQ_FOREACH_SAFE(bs_entry
, bs_queue
, entry
, next
) {
1665 if (ret
&& bs_entry
->prepared
) {
1666 bdrv_reopen_abort(&bs_entry
->state
);
1675 /* Reopen a single BlockDriverState with the specified flags. */
1676 int bdrv_reopen(BlockDriverState
*bs
, int bdrv_flags
, Error
**errp
)
1679 Error
*local_err
= NULL
;
1680 BlockReopenQueue
*queue
= bdrv_reopen_queue(NULL
, bs
, bdrv_flags
);
1682 ret
= bdrv_reopen_multiple(queue
, &local_err
);
1683 if (local_err
!= NULL
) {
1684 error_propagate(errp
, local_err
);
1691 * Prepares a BlockDriverState for reopen. All changes are staged in the
1692 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1693 * the block driver layer .bdrv_reopen_prepare()
1695 * bs is the BlockDriverState to reopen
1696 * flags are the new open flags
1697 * queue is the reopen queue
1699 * Returns 0 on success, non-zero on error. On error errp will be set
1702 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1703 * It is the responsibility of the caller to then call the abort() or
1704 * commit() for any other BDS that have been left in a prepare() state
1707 int bdrv_reopen_prepare(BDRVReopenState
*reopen_state
, BlockReopenQueue
*queue
,
1711 Error
*local_err
= NULL
;
1714 assert(reopen_state
!= NULL
);
1715 assert(reopen_state
->bs
->drv
!= NULL
);
1716 drv
= reopen_state
->bs
->drv
;
1718 /* if we are to stay read-only, do not allow permission change
1720 if (!(reopen_state
->bs
->open_flags
& BDRV_O_ALLOW_RDWR
) &&
1721 reopen_state
->flags
& BDRV_O_RDWR
) {
1722 error_set(errp
, QERR_DEVICE_IS_READ_ONLY
,
1723 reopen_state
->bs
->device_name
);
1728 ret
= bdrv_flush(reopen_state
->bs
);
1730 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
, "Error (%s) flushing drive",
1735 if (drv
->bdrv_reopen_prepare
) {
1736 ret
= drv
->bdrv_reopen_prepare(reopen_state
, queue
, &local_err
);
1738 if (local_err
!= NULL
) {
1739 error_propagate(errp
, local_err
);
1741 error_setg(errp
, "failed while preparing to reopen image '%s'",
1742 reopen_state
->bs
->filename
);
1747 /* It is currently mandatory to have a bdrv_reopen_prepare()
1748 * handler for each supported drv. */
1749 error_set(errp
, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED
,
1750 drv
->format_name
, reopen_state
->bs
->device_name
,
1751 "reopening of file");
1763 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1764 * makes them final by swapping the staging BlockDriverState contents into
1765 * the active BlockDriverState contents.
1767 void bdrv_reopen_commit(BDRVReopenState
*reopen_state
)
1771 assert(reopen_state
!= NULL
);
1772 drv
= reopen_state
->bs
->drv
;
1773 assert(drv
!= NULL
);
1775 /* If there are any driver level actions to take */
1776 if (drv
->bdrv_reopen_commit
) {
1777 drv
->bdrv_reopen_commit(reopen_state
);
1780 /* set BDS specific flags now */
1781 reopen_state
->bs
->open_flags
= reopen_state
->flags
;
1782 reopen_state
->bs
->enable_write_cache
= !!(reopen_state
->flags
&
1784 reopen_state
->bs
->read_only
= !(reopen_state
->flags
& BDRV_O_RDWR
);
1786 bdrv_refresh_limits(reopen_state
->bs
);
1790 * Abort the reopen, and delete and free the staged changes in
1793 void bdrv_reopen_abort(BDRVReopenState
*reopen_state
)
1797 assert(reopen_state
!= NULL
);
1798 drv
= reopen_state
->bs
->drv
;
1799 assert(drv
!= NULL
);
1801 if (drv
->bdrv_reopen_abort
) {
1802 drv
->bdrv_reopen_abort(reopen_state
);
1807 void bdrv_close(BlockDriverState
*bs
)
1810 block_job_cancel_sync(bs
->job
);
1812 bdrv_drain_all(); /* complete I/O */
1814 bdrv_drain_all(); /* in case flush left pending I/O */
1815 notifier_list_notify(&bs
->close_notifiers
, bs
);
1818 if (bs
->backing_hd
) {
1819 BlockDriverState
*backing_hd
= bs
->backing_hd
;
1820 bdrv_set_backing_hd(bs
, NULL
);
1821 bdrv_unref(backing_hd
);
1823 bs
->drv
->bdrv_close(bs
);
1827 bs
->copy_on_read
= 0;
1828 bs
->backing_file
[0] = '\0';
1829 bs
->backing_format
[0] = '\0';
1830 bs
->total_sectors
= 0;
1835 bs
->zero_beyond_eof
= false;
1836 QDECREF(bs
->options
);
1839 if (bs
->file
!= NULL
) {
1840 bdrv_unref(bs
->file
);
1845 bdrv_dev_change_media_cb(bs
, false);
1847 /*throttling disk I/O limits*/
1848 if (bs
->io_limits_enabled
) {
1849 bdrv_io_limits_disable(bs
);
1853 void bdrv_close_all(void)
1855 BlockDriverState
*bs
;
1857 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1858 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1860 aio_context_acquire(aio_context
);
1862 aio_context_release(aio_context
);
1866 /* Check if any requests are in-flight (including throttled requests) */
1867 static bool bdrv_requests_pending(BlockDriverState
*bs
)
1869 if (!QLIST_EMPTY(&bs
->tracked_requests
)) {
1872 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[0])) {
1875 if (!qemu_co_queue_empty(&bs
->throttled_reqs
[1])) {
1878 if (bs
->file
&& bdrv_requests_pending(bs
->file
)) {
1881 if (bs
->backing_hd
&& bdrv_requests_pending(bs
->backing_hd
)) {
1888 * Wait for pending requests to complete across all BlockDriverStates
1890 * This function does not flush data to disk, use bdrv_flush_all() for that
1891 * after calling this function.
1893 * Note that completion of an asynchronous I/O operation can trigger any
1894 * number of other I/O operations on other devices---for example a coroutine
1895 * can be arbitrarily complex and a constant flow of I/O can come until the
1896 * coroutine is complete. Because of this, it is not possible to have a
1897 * function to drain a single device's I/O queue.
1899 void bdrv_drain_all(void)
1901 /* Always run first iteration so any pending completion BHs run */
1903 BlockDriverState
*bs
;
1908 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
1909 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
1912 aio_context_acquire(aio_context
);
1913 bdrv_start_throttled_reqs(bs
);
1914 bs_busy
= bdrv_requests_pending(bs
);
1915 bs_busy
|= aio_poll(aio_context
, bs_busy
);
1916 aio_context_release(aio_context
);
1923 /* make a BlockDriverState anonymous by removing from bdrv_state and
1924 * graph_bdrv_state list.
1925 Also, NULL terminate the device_name to prevent double remove */
1926 void bdrv_make_anon(BlockDriverState
*bs
)
1928 if (bs
->device_name
[0] != '\0') {
1929 QTAILQ_REMOVE(&bdrv_states
, bs
, device_list
);
1931 bs
->device_name
[0] = '\0';
1932 if (bs
->node_name
[0] != '\0') {
1933 QTAILQ_REMOVE(&graph_bdrv_states
, bs
, node_list
);
1935 bs
->node_name
[0] = '\0';
1938 static void bdrv_rebind(BlockDriverState
*bs
)
1940 if (bs
->drv
&& bs
->drv
->bdrv_rebind
) {
1941 bs
->drv
->bdrv_rebind(bs
);
1945 static void bdrv_move_feature_fields(BlockDriverState
*bs_dest
,
1946 BlockDriverState
*bs_src
)
1948 /* move some fields that need to stay attached to the device */
1951 bs_dest
->dev_ops
= bs_src
->dev_ops
;
1952 bs_dest
->dev_opaque
= bs_src
->dev_opaque
;
1953 bs_dest
->dev
= bs_src
->dev
;
1954 bs_dest
->guest_block_size
= bs_src
->guest_block_size
;
1955 bs_dest
->copy_on_read
= bs_src
->copy_on_read
;
1957 bs_dest
->enable_write_cache
= bs_src
->enable_write_cache
;
1959 /* i/o throttled req */
1960 memcpy(&bs_dest
->throttle_state
,
1961 &bs_src
->throttle_state
,
1962 sizeof(ThrottleState
));
1963 bs_dest
->throttled_reqs
[0] = bs_src
->throttled_reqs
[0];
1964 bs_dest
->throttled_reqs
[1] = bs_src
->throttled_reqs
[1];
1965 bs_dest
->io_limits_enabled
= bs_src
->io_limits_enabled
;
1968 bs_dest
->on_read_error
= bs_src
->on_read_error
;
1969 bs_dest
->on_write_error
= bs_src
->on_write_error
;
1972 bs_dest
->iostatus_enabled
= bs_src
->iostatus_enabled
;
1973 bs_dest
->iostatus
= bs_src
->iostatus
;
1976 bs_dest
->dirty_bitmaps
= bs_src
->dirty_bitmaps
;
1978 /* reference count */
1979 bs_dest
->refcnt
= bs_src
->refcnt
;
1982 bs_dest
->job
= bs_src
->job
;
1984 /* keep the same entry in bdrv_states */
1985 pstrcpy(bs_dest
->device_name
, sizeof(bs_dest
->device_name
),
1986 bs_src
->device_name
);
1987 bs_dest
->device_list
= bs_src
->device_list
;
1988 memcpy(bs_dest
->op_blockers
, bs_src
->op_blockers
,
1989 sizeof(bs_dest
->op_blockers
));
1993 * Swap bs contents for two image chains while they are live,
1994 * while keeping required fields on the BlockDriverState that is
1995 * actually attached to a device.
1997 * This will modify the BlockDriverState fields, and swap contents
1998 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2000 * bs_new is required to be anonymous.
2002 * This function does not create any image files.
2004 void bdrv_swap(BlockDriverState
*bs_new
, BlockDriverState
*bs_old
)
2006 BlockDriverState tmp
;
2008 /* The code needs to swap the node_name but simply swapping node_list won't
2009 * work so first remove the nodes from the graph list, do the swap then
2010 * insert them back if needed.
2012 if (bs_new
->node_name
[0] != '\0') {
2013 QTAILQ_REMOVE(&graph_bdrv_states
, bs_new
, node_list
);
2015 if (bs_old
->node_name
[0] != '\0') {
2016 QTAILQ_REMOVE(&graph_bdrv_states
, bs_old
, node_list
);
2019 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2020 assert(bs_new
->device_name
[0] == '\0');
2021 assert(QLIST_EMPTY(&bs_new
->dirty_bitmaps
));
2022 assert(bs_new
->job
== NULL
);
2023 assert(bs_new
->dev
== NULL
);
2024 assert(bs_new
->io_limits_enabled
== false);
2025 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2031 /* there are some fields that should not be swapped, move them back */
2032 bdrv_move_feature_fields(&tmp
, bs_old
);
2033 bdrv_move_feature_fields(bs_old
, bs_new
);
2034 bdrv_move_feature_fields(bs_new
, &tmp
);
2036 /* bs_new shouldn't be in bdrv_states even after the swap! */
2037 assert(bs_new
->device_name
[0] == '\0');
2039 /* Check a few fields that should remain attached to the device */
2040 assert(bs_new
->dev
== NULL
);
2041 assert(bs_new
->job
== NULL
);
2042 assert(bs_new
->io_limits_enabled
== false);
2043 assert(!throttle_have_timer(&bs_new
->throttle_state
));
2045 /* insert the nodes back into the graph node list if needed */
2046 if (bs_new
->node_name
[0] != '\0') {
2047 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_new
, node_list
);
2049 if (bs_old
->node_name
[0] != '\0') {
2050 QTAILQ_INSERT_TAIL(&graph_bdrv_states
, bs_old
, node_list
);
2053 bdrv_rebind(bs_new
);
2054 bdrv_rebind(bs_old
);
2058 * Add new bs contents at the top of an image chain while the chain is
2059 * live, while keeping required fields on the top layer.
2061 * This will modify the BlockDriverState fields, and swap contents
2062 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2064 * bs_new is required to be anonymous.
2066 * This function does not create any image files.
2068 void bdrv_append(BlockDriverState
*bs_new
, BlockDriverState
*bs_top
)
2070 bdrv_swap(bs_new
, bs_top
);
2072 /* The contents of 'tmp' will become bs_top, as we are
2073 * swapping bs_new and bs_top contents. */
2074 bdrv_set_backing_hd(bs_top
, bs_new
);
2077 static void bdrv_delete(BlockDriverState
*bs
)
2081 assert(bdrv_op_blocker_is_empty(bs
));
2082 assert(!bs
->refcnt
);
2083 assert(QLIST_EMPTY(&bs
->dirty_bitmaps
));
2087 /* remove from list, if necessary */
2093 int bdrv_attach_dev(BlockDriverState
*bs
, void *dev
)
2094 /* TODO change to DeviceState *dev when all users are qdevified */
2100 bdrv_iostatus_reset(bs
);
2104 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2105 void bdrv_attach_dev_nofail(BlockDriverState
*bs
, void *dev
)
2107 if (bdrv_attach_dev(bs
, dev
) < 0) {
2112 void bdrv_detach_dev(BlockDriverState
*bs
, void *dev
)
2113 /* TODO change to DeviceState *dev when all users are qdevified */
2115 assert(bs
->dev
== dev
);
2118 bs
->dev_opaque
= NULL
;
2119 bs
->guest_block_size
= 512;
2122 /* TODO change to return DeviceState * when all users are qdevified */
2123 void *bdrv_get_attached_dev(BlockDriverState
*bs
)
2128 void bdrv_set_dev_ops(BlockDriverState
*bs
, const BlockDevOps
*ops
,
2132 bs
->dev_opaque
= opaque
;
2135 static void bdrv_dev_change_media_cb(BlockDriverState
*bs
, bool load
)
2137 if (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
) {
2138 bool tray_was_closed
= !bdrv_dev_is_tray_open(bs
);
2139 bs
->dev_ops
->change_media_cb(bs
->dev_opaque
, load
);
2140 if (tray_was_closed
) {
2142 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2143 true, &error_abort
);
2147 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs
),
2148 false, &error_abort
);
2153 bool bdrv_dev_has_removable_media(BlockDriverState
*bs
)
2155 return !bs
->dev
|| (bs
->dev_ops
&& bs
->dev_ops
->change_media_cb
);
2158 void bdrv_dev_eject_request(BlockDriverState
*bs
, bool force
)
2160 if (bs
->dev_ops
&& bs
->dev_ops
->eject_request_cb
) {
2161 bs
->dev_ops
->eject_request_cb(bs
->dev_opaque
, force
);
2165 bool bdrv_dev_is_tray_open(BlockDriverState
*bs
)
2167 if (bs
->dev_ops
&& bs
->dev_ops
->is_tray_open
) {
2168 return bs
->dev_ops
->is_tray_open(bs
->dev_opaque
);
2173 static void bdrv_dev_resize_cb(BlockDriverState
*bs
)
2175 if (bs
->dev_ops
&& bs
->dev_ops
->resize_cb
) {
2176 bs
->dev_ops
->resize_cb(bs
->dev_opaque
);
2180 bool bdrv_dev_is_medium_locked(BlockDriverState
*bs
)
2182 if (bs
->dev_ops
&& bs
->dev_ops
->is_medium_locked
) {
2183 return bs
->dev_ops
->is_medium_locked(bs
->dev_opaque
);
2189 * Run consistency checks on an image
2191 * Returns 0 if the check could be completed (it doesn't mean that the image is
2192 * free of errors) or -errno when an internal error occurred. The results of the
2193 * check are stored in res.
2195 int bdrv_check(BlockDriverState
*bs
, BdrvCheckResult
*res
, BdrvCheckMode fix
)
2197 if (bs
->drv
->bdrv_check
== NULL
) {
2201 memset(res
, 0, sizeof(*res
));
2202 return bs
->drv
->bdrv_check(bs
, res
, fix
);
2205 #define COMMIT_BUF_SECTORS 2048
2207 /* commit COW file into the raw image */
2208 int bdrv_commit(BlockDriverState
*bs
)
2210 BlockDriver
*drv
= bs
->drv
;
2211 int64_t sector
, total_sectors
, length
, backing_length
;
2212 int n
, ro
, open_flags
;
2214 uint8_t *buf
= NULL
;
2215 char filename
[PATH_MAX
];
2220 if (!bs
->backing_hd
) {
2224 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_COMMIT
, NULL
) ||
2225 bdrv_op_is_blocked(bs
->backing_hd
, BLOCK_OP_TYPE_COMMIT
, NULL
)) {
2229 ro
= bs
->backing_hd
->read_only
;
2230 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2231 pstrcpy(filename
, sizeof(filename
), bs
->backing_hd
->filename
);
2232 open_flags
= bs
->backing_hd
->open_flags
;
2235 if (bdrv_reopen(bs
->backing_hd
, open_flags
| BDRV_O_RDWR
, NULL
)) {
2240 length
= bdrv_getlength(bs
);
2246 backing_length
= bdrv_getlength(bs
->backing_hd
);
2247 if (backing_length
< 0) {
2248 ret
= backing_length
;
2252 /* If our top snapshot is larger than the backing file image,
2253 * grow the backing file image if possible. If not possible,
2254 * we must return an error */
2255 if (length
> backing_length
) {
2256 ret
= bdrv_truncate(bs
->backing_hd
, length
);
2262 total_sectors
= length
>> BDRV_SECTOR_BITS
;
2263 buf
= g_malloc(COMMIT_BUF_SECTORS
* BDRV_SECTOR_SIZE
);
2265 for (sector
= 0; sector
< total_sectors
; sector
+= n
) {
2266 ret
= bdrv_is_allocated(bs
, sector
, COMMIT_BUF_SECTORS
, &n
);
2271 ret
= bdrv_read(bs
, sector
, buf
, n
);
2276 ret
= bdrv_write(bs
->backing_hd
, sector
, buf
, n
);
2283 if (drv
->bdrv_make_empty
) {
2284 ret
= drv
->bdrv_make_empty(bs
);
2292 * Make sure all data we wrote to the backing device is actually
2295 if (bs
->backing_hd
) {
2296 bdrv_flush(bs
->backing_hd
);
2304 /* ignoring error return here */
2305 bdrv_reopen(bs
->backing_hd
, open_flags
& ~BDRV_O_RDWR
, NULL
);
2311 int bdrv_commit_all(void)
2313 BlockDriverState
*bs
;
2315 QTAILQ_FOREACH(bs
, &bdrv_states
, device_list
) {
2316 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2318 aio_context_acquire(aio_context
);
2319 if (bs
->drv
&& bs
->backing_hd
) {
2320 int ret
= bdrv_commit(bs
);
2322 aio_context_release(aio_context
);
2326 aio_context_release(aio_context
);
2332 * Remove an active request from the tracked requests list
2334 * This function should be called when a tracked request is completing.
2336 static void tracked_request_end(BdrvTrackedRequest
*req
)
2338 if (req
->serialising
) {
2339 req
->bs
->serialising_in_flight
--;
2342 QLIST_REMOVE(req
, list
);
2343 qemu_co_queue_restart_all(&req
->wait_queue
);
2347 * Add an active request to the tracked requests list
2349 static void tracked_request_begin(BdrvTrackedRequest
*req
,
2350 BlockDriverState
*bs
,
2352 unsigned int bytes
, bool is_write
)
2354 *req
= (BdrvTrackedRequest
){
2358 .is_write
= is_write
,
2359 .co
= qemu_coroutine_self(),
2360 .serialising
= false,
2361 .overlap_offset
= offset
,
2362 .overlap_bytes
= bytes
,
2365 qemu_co_queue_init(&req
->wait_queue
);
2367 QLIST_INSERT_HEAD(&bs
->tracked_requests
, req
, list
);
2370 static void mark_request_serialising(BdrvTrackedRequest
*req
, uint64_t align
)
2372 int64_t overlap_offset
= req
->offset
& ~(align
- 1);
2373 unsigned int overlap_bytes
= ROUND_UP(req
->offset
+ req
->bytes
, align
)
2376 if (!req
->serialising
) {
2377 req
->bs
->serialising_in_flight
++;
2378 req
->serialising
= true;
2381 req
->overlap_offset
= MIN(req
->overlap_offset
, overlap_offset
);
2382 req
->overlap_bytes
= MAX(req
->overlap_bytes
, overlap_bytes
);
2386 * Round a region to cluster boundaries
2388 void bdrv_round_to_clusters(BlockDriverState
*bs
,
2389 int64_t sector_num
, int nb_sectors
,
2390 int64_t *cluster_sector_num
,
2391 int *cluster_nb_sectors
)
2393 BlockDriverInfo bdi
;
2395 if (bdrv_get_info(bs
, &bdi
) < 0 || bdi
.cluster_size
== 0) {
2396 *cluster_sector_num
= sector_num
;
2397 *cluster_nb_sectors
= nb_sectors
;
2399 int64_t c
= bdi
.cluster_size
/ BDRV_SECTOR_SIZE
;
2400 *cluster_sector_num
= QEMU_ALIGN_DOWN(sector_num
, c
);
2401 *cluster_nb_sectors
= QEMU_ALIGN_UP(sector_num
- *cluster_sector_num
+
2406 static int bdrv_get_cluster_size(BlockDriverState
*bs
)
2408 BlockDriverInfo bdi
;
2411 ret
= bdrv_get_info(bs
, &bdi
);
2412 if (ret
< 0 || bdi
.cluster_size
== 0) {
2413 return bs
->request_alignment
;
2415 return bdi
.cluster_size
;
2419 static bool tracked_request_overlaps(BdrvTrackedRequest
*req
,
2420 int64_t offset
, unsigned int bytes
)
2423 if (offset
>= req
->overlap_offset
+ req
->overlap_bytes
) {
2427 if (req
->overlap_offset
>= offset
+ bytes
) {
2433 static bool coroutine_fn
wait_serialising_requests(BdrvTrackedRequest
*self
)
2435 BlockDriverState
*bs
= self
->bs
;
2436 BdrvTrackedRequest
*req
;
2438 bool waited
= false;
2440 if (!bs
->serialising_in_flight
) {
2446 QLIST_FOREACH(req
, &bs
->tracked_requests
, list
) {
2447 if (req
== self
|| (!req
->serialising
&& !self
->serialising
)) {
2450 if (tracked_request_overlaps(req
, self
->overlap_offset
,
2451 self
->overlap_bytes
))
2453 /* Hitting this means there was a reentrant request, for
2454 * example, a block driver issuing nested requests. This must
2455 * never happen since it means deadlock.
2457 assert(qemu_coroutine_self() != req
->co
);
2459 /* If the request is already (indirectly) waiting for us, or
2460 * will wait for us as soon as it wakes up, then just go on
2461 * (instead of producing a deadlock in the former case). */
2462 if (!req
->waiting_for
) {
2463 self
->waiting_for
= req
;
2464 qemu_co_queue_wait(&req
->wait_queue
);
2465 self
->waiting_for
= NULL
;
2480 * -EINVAL - backing format specified, but no file
2481 * -ENOSPC - can't update the backing file because no space is left in the
2483 * -ENOTSUP - format driver doesn't support changing the backing file
2485 int bdrv_change_backing_file(BlockDriverState
*bs
,
2486 const char *backing_file
, const char *backing_fmt
)
2488 BlockDriver
*drv
= bs
->drv
;
2491 /* Backing file format doesn't make sense without a backing file */
2492 if (backing_fmt
&& !backing_file
) {
2496 if (drv
->bdrv_change_backing_file
!= NULL
) {
2497 ret
= drv
->bdrv_change_backing_file(bs
, backing_file
, backing_fmt
);
2503 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
), backing_file ?
: "");
2504 pstrcpy(bs
->backing_format
, sizeof(bs
->backing_format
), backing_fmt ?
: "");
2510 * Finds the image layer in the chain that has 'bs' as its backing file.
2512 * active is the current topmost image.
2514 * Returns NULL if bs is not found in active's image chain,
2515 * or if active == bs.
2517 BlockDriverState
*bdrv_find_overlay(BlockDriverState
*active
,
2518 BlockDriverState
*bs
)
2520 BlockDriverState
*overlay
= NULL
;
2521 BlockDriverState
*intermediate
;
2523 assert(active
!= NULL
);
2526 /* if bs is the same as active, then by definition it has no overlay
2532 intermediate
= active
;
2533 while (intermediate
->backing_hd
) {
2534 if (intermediate
->backing_hd
== bs
) {
2535 overlay
= intermediate
;
2538 intermediate
= intermediate
->backing_hd
;
2544 typedef struct BlkIntermediateStates
{
2545 BlockDriverState
*bs
;
2546 QSIMPLEQ_ENTRY(BlkIntermediateStates
) entry
;
2547 } BlkIntermediateStates
;
2551 * Drops images above 'base' up to and including 'top', and sets the image
2552 * above 'top' to have base as its backing file.
2554 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2555 * information in 'bs' can be properly updated.
2557 * E.g., this will convert the following chain:
2558 * bottom <- base <- intermediate <- top <- active
2562 * bottom <- base <- active
2564 * It is allowed for bottom==base, in which case it converts:
2566 * base <- intermediate <- top <- active
2573 * if active == top, that is considered an error
2576 int bdrv_drop_intermediate(BlockDriverState
*active
, BlockDriverState
*top
,
2577 BlockDriverState
*base
)
2579 BlockDriverState
*intermediate
;
2580 BlockDriverState
*base_bs
= NULL
;
2581 BlockDriverState
*new_top_bs
= NULL
;
2582 BlkIntermediateStates
*intermediate_state
, *next
;
2585 QSIMPLEQ_HEAD(states_to_delete
, BlkIntermediateStates
) states_to_delete
;
2586 QSIMPLEQ_INIT(&states_to_delete
);
2588 if (!top
->drv
|| !base
->drv
) {
2592 new_top_bs
= bdrv_find_overlay(active
, top
);
2594 if (new_top_bs
== NULL
) {
2595 /* we could not find the image above 'top', this is an error */
2599 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2600 * to do, no intermediate images */
2601 if (new_top_bs
->backing_hd
== base
) {
2608 /* now we will go down through the list, and add each BDS we find
2609 * into our deletion queue, until we hit the 'base'
2611 while (intermediate
) {
2612 intermediate_state
= g_malloc0(sizeof(BlkIntermediateStates
));
2613 intermediate_state
->bs
= intermediate
;
2614 QSIMPLEQ_INSERT_TAIL(&states_to_delete
, intermediate_state
, entry
);
2616 if (intermediate
->backing_hd
== base
) {
2617 base_bs
= intermediate
->backing_hd
;
2620 intermediate
= intermediate
->backing_hd
;
2622 if (base_bs
== NULL
) {
2623 /* something went wrong, we did not end at the base. safely
2624 * unravel everything, and exit with error */
2628 /* success - we can delete the intermediate states, and link top->base */
2629 ret
= bdrv_change_backing_file(new_top_bs
, base_bs
->filename
,
2630 base_bs
->drv ? base_bs
->drv
->format_name
: "");
2634 bdrv_set_backing_hd(new_top_bs
, base_bs
);
2636 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2637 /* so that bdrv_close() does not recursively close the chain */
2638 bdrv_set_backing_hd(intermediate_state
->bs
, NULL
);
2639 bdrv_unref(intermediate_state
->bs
);
2644 QSIMPLEQ_FOREACH_SAFE(intermediate_state
, &states_to_delete
, entry
, next
) {
2645 g_free(intermediate_state
);
2651 static int bdrv_check_byte_request(BlockDriverState
*bs
, int64_t offset
,
2656 if (size
> INT_MAX
) {
2660 if (!bdrv_is_inserted(bs
))
2666 len
= bdrv_getlength(bs
);
2671 if ((offset
> len
) || (len
- offset
< size
))
2677 static int bdrv_check_request(BlockDriverState
*bs
, int64_t sector_num
,
2680 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2684 return bdrv_check_byte_request(bs
, sector_num
* BDRV_SECTOR_SIZE
,
2685 nb_sectors
* BDRV_SECTOR_SIZE
);
2688 typedef struct RwCo
{
2689 BlockDriverState
*bs
;
2694 BdrvRequestFlags flags
;
2697 static void coroutine_fn
bdrv_rw_co_entry(void *opaque
)
2699 RwCo
*rwco
= opaque
;
2701 if (!rwco
->is_write
) {
2702 rwco
->ret
= bdrv_co_do_preadv(rwco
->bs
, rwco
->offset
,
2703 rwco
->qiov
->size
, rwco
->qiov
,
2706 rwco
->ret
= bdrv_co_do_pwritev(rwco
->bs
, rwco
->offset
,
2707 rwco
->qiov
->size
, rwco
->qiov
,
2713 * Process a vectored synchronous request using coroutines
2715 static int bdrv_prwv_co(BlockDriverState
*bs
, int64_t offset
,
2716 QEMUIOVector
*qiov
, bool is_write
,
2717 BdrvRequestFlags flags
)
2724 .is_write
= is_write
,
2730 * In sync call context, when the vcpu is blocked, this throttling timer
2731 * will not fire; so the I/O throttling function has to be disabled here
2732 * if it has been enabled.
2734 if (bs
->io_limits_enabled
) {
2735 fprintf(stderr
, "Disabling I/O throttling on '%s' due "
2736 "to synchronous I/O.\n", bdrv_get_device_name(bs
));
2737 bdrv_io_limits_disable(bs
);
2740 if (qemu_in_coroutine()) {
2741 /* Fast-path if already in coroutine context */
2742 bdrv_rw_co_entry(&rwco
);
2744 AioContext
*aio_context
= bdrv_get_aio_context(bs
);
2746 co
= qemu_coroutine_create(bdrv_rw_co_entry
);
2747 qemu_coroutine_enter(co
, &rwco
);
2748 while (rwco
.ret
== NOT_DONE
) {
2749 aio_poll(aio_context
, true);
2756 * Process a synchronous request using coroutines
2758 static int bdrv_rw_co(BlockDriverState
*bs
, int64_t sector_num
, uint8_t *buf
,
2759 int nb_sectors
, bool is_write
, BdrvRequestFlags flags
)
2762 struct iovec iov
= {
2763 .iov_base
= (void *)buf
,
2764 .iov_len
= nb_sectors
* BDRV_SECTOR_SIZE
,
2767 if (nb_sectors
< 0 || nb_sectors
> INT_MAX
/ BDRV_SECTOR_SIZE
) {
2771 qemu_iovec_init_external(&qiov
, &iov
, 1);
2772 return bdrv_prwv_co(bs
, sector_num
<< BDRV_SECTOR_BITS
,
2773 &qiov
, is_write
, flags
);
2776 /* return < 0 if error. See bdrv_write() for the return codes */
2777 int bdrv_read(BlockDriverState
*bs
, int64_t sector_num
,
2778 uint8_t *buf
, int nb_sectors
)
2780 return bdrv_rw_co(bs
, sector_num
, buf
, nb_sectors
, false, 0);
2783 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2784 int bdrv_read_unthrottled(BlockDriverState
*bs
, int64_t sector_num
,
2785 uint8_t *buf
, int nb_sectors
)
2790 enabled
= bs
->io_limits_enabled
;
2791 bs
->io_limits_enabled
= false;
2792 ret
= bdrv_read(bs
, sector_num
, buf
, nb_sectors
);
2793 bs
->io_limits_enabled
= enabled
;
2797 /* Return < 0 if error. Important errors are:
2798 -EIO generic I/O error (may happen for all errors)
2799 -ENOMEDIUM No media inserted.
2800 -EINVAL Invalid sector number or nb_sectors
2801 -EACCES Trying to write a read-only device
2803 int bdrv_write(BlockDriverState
*bs
, int64_t sector_num
,
2804 const uint8_t *buf
, int nb_sectors
)
2806 return bdrv_rw_co(bs
, sector_num
, (uint8_t *)buf
, nb_sectors
, true, 0);
2809 int bdrv_write_zeroes(BlockDriverState
*bs
, int64_t sector_num
,
2810 int nb_sectors
, BdrvRequestFlags flags
)
2812 return bdrv_rw_co(bs
, sector_num
, NULL
, nb_sectors
, true,
2813 BDRV_REQ_ZERO_WRITE
| flags
);
2817 * Completely zero out a block device with the help of bdrv_write_zeroes.
2818 * The operation is sped up by checking the block status and only writing
2819 * zeroes to the device if they currently do not return zeroes. Optional
2820 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2822 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2824 int bdrv_make_zero(BlockDriverState
*bs
, BdrvRequestFlags flags
)
2826 int64_t target_size
;
2827 int64_t ret
, nb_sectors
, sector_num
= 0;
2830 target_size
= bdrv_getlength(bs
);
2831 if (target_size
< 0) {
2834 target_size
/= BDRV_SECTOR_SIZE
;
2837 nb_sectors
= target_size
- sector_num
;
2838 if (nb_sectors
<= 0) {
2841 if (nb_sectors
> INT_MAX
) {
2842 nb_sectors
= INT_MAX
;
2844 ret
= bdrv_get_block_status(bs
, sector_num
, nb_sectors
, &n
);
2846 error_report("error getting block status at sector %" PRId64
": %s",
2847 sector_num
, strerror(-ret
));
2850 if (ret
& BDRV_BLOCK_ZERO
) {
2854 ret
= bdrv_write_zeroes(bs
, sector_num
, n
, flags
);
2856 error_report("error writing zeroes at sector %" PRId64
": %s",
2857 sector_num
, strerror(-ret
));
2864 int bdrv_pread(BlockDriverState
*bs
, int64_t offset
, void *buf
, int bytes
)
2867 struct iovec iov
= {
2868 .iov_base
= (void *)buf
,
2877 qemu_iovec_init_external(&qiov
, &iov
, 1);
2878 ret
= bdrv_prwv_co(bs
, offset
, &qiov
, false, 0);
2886 int bdrv_pwritev(BlockDriverState
*bs
, int64_t offset
, QEMUIOVector
*qiov
)
2890 ret
= bdrv_prwv_co(bs
, offset
, qiov
, true, 0);
2898 int bdrv_pwrite(BlockDriverState
*bs
, int64_t offset
,
2899 const void *buf
, int bytes
)
2902 struct iovec iov
= {
2903 .iov_base
= (void *) buf
,
2911 qemu_iovec_init_external(&qiov
, &iov
, 1);
2912 return bdrv_pwritev(bs
, offset
, &qiov
);
2916 * Writes to the file and ensures that no writes are reordered across this
2917 * request (acts as a barrier)
2919 * Returns 0 on success, -errno in error cases.
2921 int bdrv_pwrite_sync(BlockDriverState
*bs
, int64_t offset
,
2922 const void *buf
, int count
)
2926 ret
= bdrv_pwrite(bs
, offset
, buf
, count
);
2931 /* No flush needed for cache modes that already do it */
2932 if (bs
->enable_write_cache
) {
2939 static int coroutine_fn
bdrv_co_do_copy_on_readv(BlockDriverState
*bs
,
2940 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
2942 /* Perform I/O through a temporary buffer so that users who scribble over
2943 * their read buffer while the operation is in progress do not end up
2944 * modifying the image file. This is critical for zero-copy guest I/O
2945 * where anything might happen inside guest memory.
2947 void *bounce_buffer
;
2949 BlockDriver
*drv
= bs
->drv
;
2951 QEMUIOVector bounce_qiov
;
2952 int64_t cluster_sector_num
;
2953 int cluster_nb_sectors
;
2957 /* Cover entire cluster so no additional backing file I/O is required when
2958 * allocating cluster in the image file.
2960 bdrv_round_to_clusters(bs
, sector_num
, nb_sectors
,
2961 &cluster_sector_num
, &cluster_nb_sectors
);
2963 trace_bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
,
2964 cluster_sector_num
, cluster_nb_sectors
);
2966 iov
.iov_len
= cluster_nb_sectors
* BDRV_SECTOR_SIZE
;
2967 iov
.iov_base
= bounce_buffer
= qemu_blockalign(bs
, iov
.iov_len
);
2968 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
2970 ret
= drv
->bdrv_co_readv(bs
, cluster_sector_num
, cluster_nb_sectors
,
2976 if (drv
->bdrv_co_write_zeroes
&&
2977 buffer_is_zero(bounce_buffer
, iov
.iov_len
)) {
2978 ret
= bdrv_co_do_write_zeroes(bs
, cluster_sector_num
,
2979 cluster_nb_sectors
, 0);
2981 /* This does not change the data on the disk, it is not necessary
2982 * to flush even in cache=writethrough mode.
2984 ret
= drv
->bdrv_co_writev(bs
, cluster_sector_num
, cluster_nb_sectors
,
2989 /* It might be okay to ignore write errors for guest requests. If this
2990 * is a deliberate copy-on-read then we don't want to ignore the error.
2991 * Simply report it in all cases.
2996 skip_bytes
= (sector_num
- cluster_sector_num
) * BDRV_SECTOR_SIZE
;
2997 qemu_iovec_from_buf(qiov
, 0, bounce_buffer
+ skip_bytes
,
2998 nb_sectors
* BDRV_SECTOR_SIZE
);
3001 qemu_vfree(bounce_buffer
);
3006 * Forwards an already correctly aligned request to the BlockDriver. This
3007 * handles copy on read and zeroing after EOF; any other features must be
3008 * implemented by the caller.
3010 static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState
*bs
,
3011 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3012 int64_t align
, QEMUIOVector
*qiov
, int flags
)
3014 BlockDriver
*drv
= bs
->drv
;
3017 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3018 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3020 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3021 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3023 /* Handle Copy on Read and associated serialisation */
3024 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3025 /* If we touch the same cluster it counts as an overlap. This
3026 * guarantees that allocating writes will be serialized and not race
3027 * with each other for the same cluster. For example, in copy-on-read
3028 * it ensures that the CoR read and write operations are atomic and
3029 * guest writes cannot interleave between them. */
3030 mark_request_serialising(req
, bdrv_get_cluster_size(bs
));
3033 wait_serialising_requests(req
);
3035 if (flags
& BDRV_REQ_COPY_ON_READ
) {
3038 ret
= bdrv_is_allocated(bs
, sector_num
, nb_sectors
, &pnum
);
3043 if (!ret
|| pnum
!= nb_sectors
) {
3044 ret
= bdrv_co_do_copy_on_readv(bs
, sector_num
, nb_sectors
, qiov
);
3049 /* Forward the request to the BlockDriver */
3050 if (!(bs
->zero_beyond_eof
&& bs
->growable
)) {
3051 ret
= drv
->bdrv_co_readv(bs
, sector_num
, nb_sectors
, qiov
);
3053 /* Read zeros after EOF of growable BDSes */
3054 int64_t len
, total_sectors
, max_nb_sectors
;
3056 len
= bdrv_getlength(bs
);
3062 total_sectors
= DIV_ROUND_UP(len
, BDRV_SECTOR_SIZE
);
3063 max_nb_sectors
= ROUND_UP(MAX(0, total_sectors
- sector_num
),
3064 align
>> BDRV_SECTOR_BITS
);
3065 if (max_nb_sectors
> 0) {
3066 ret
= drv
->bdrv_co_readv(bs
, sector_num
,
3067 MIN(nb_sectors
, max_nb_sectors
), qiov
);
3072 /* Reading beyond end of file is supposed to produce zeroes */
3073 if (ret
== 0 && total_sectors
< sector_num
+ nb_sectors
) {
3074 uint64_t offset
= MAX(0, total_sectors
- sector_num
);
3075 uint64_t bytes
= (sector_num
+ nb_sectors
- offset
) *
3077 qemu_iovec_memset(qiov
, offset
* BDRV_SECTOR_SIZE
, 0, bytes
);
3086 * Handle a read request in coroutine context
3088 static int coroutine_fn
bdrv_co_do_preadv(BlockDriverState
*bs
,
3089 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3090 BdrvRequestFlags flags
)
3092 BlockDriver
*drv
= bs
->drv
;
3093 BdrvTrackedRequest req
;
3095 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3096 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3097 uint8_t *head_buf
= NULL
;
3098 uint8_t *tail_buf
= NULL
;
3099 QEMUIOVector local_qiov
;
3100 bool use_local_qiov
= false;
3106 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3110 if (bs
->copy_on_read
) {
3111 flags
|= BDRV_REQ_COPY_ON_READ
;
3114 /* throttling disk I/O */
3115 if (bs
->io_limits_enabled
) {
3116 bdrv_io_limits_intercept(bs
, bytes
, false);
3119 /* Align read if necessary by padding qiov */
3120 if (offset
& (align
- 1)) {
3121 head_buf
= qemu_blockalign(bs
, align
);
3122 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3123 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3124 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3125 use_local_qiov
= true;
3127 bytes
+= offset
& (align
- 1);
3128 offset
= offset
& ~(align
- 1);
3131 if ((offset
+ bytes
) & (align
- 1)) {
3132 if (!use_local_qiov
) {
3133 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3134 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3135 use_local_qiov
= true;
3137 tail_buf
= qemu_blockalign(bs
, align
);
3138 qemu_iovec_add(&local_qiov
, tail_buf
,
3139 align
- ((offset
+ bytes
) & (align
- 1)));
3141 bytes
= ROUND_UP(bytes
, align
);
3144 tracked_request_begin(&req
, bs
, offset
, bytes
, false);
3145 ret
= bdrv_aligned_preadv(bs
, &req
, offset
, bytes
, align
,
3146 use_local_qiov ?
&local_qiov
: qiov
,
3148 tracked_request_end(&req
);
3150 if (use_local_qiov
) {
3151 qemu_iovec_destroy(&local_qiov
);
3152 qemu_vfree(head_buf
);
3153 qemu_vfree(tail_buf
);
3159 static int coroutine_fn
bdrv_co_do_readv(BlockDriverState
*bs
,
3160 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3161 BdrvRequestFlags flags
)
3163 if (nb_sectors
< 0 || nb_sectors
> (UINT_MAX
>> BDRV_SECTOR_BITS
)) {
3167 return bdrv_co_do_preadv(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3168 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3171 int coroutine_fn
bdrv_co_readv(BlockDriverState
*bs
, int64_t sector_num
,
3172 int nb_sectors
, QEMUIOVector
*qiov
)
3174 trace_bdrv_co_readv(bs
, sector_num
, nb_sectors
);
3176 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
, 0);
3179 int coroutine_fn
bdrv_co_copy_on_readv(BlockDriverState
*bs
,
3180 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
)
3182 trace_bdrv_co_copy_on_readv(bs
, sector_num
, nb_sectors
);
3184 return bdrv_co_do_readv(bs
, sector_num
, nb_sectors
, qiov
,
3185 BDRV_REQ_COPY_ON_READ
);
3188 /* if no limit is specified in the BlockLimits use a default
3189 * of 32768 512-byte sectors (16 MiB) per request.
3191 #define MAX_WRITE_ZEROES_DEFAULT 32768
3193 static int coroutine_fn
bdrv_co_do_write_zeroes(BlockDriverState
*bs
,
3194 int64_t sector_num
, int nb_sectors
, BdrvRequestFlags flags
)
3196 BlockDriver
*drv
= bs
->drv
;
3198 struct iovec iov
= {0};
3201 int max_write_zeroes
= bs
->bl
.max_write_zeroes ?
3202 bs
->bl
.max_write_zeroes
: MAX_WRITE_ZEROES_DEFAULT
;
3204 while (nb_sectors
> 0 && !ret
) {
3205 int num
= nb_sectors
;
3207 /* Align request. Block drivers can expect the "bulk" of the request
3210 if (bs
->bl
.write_zeroes_alignment
3211 && num
> bs
->bl
.write_zeroes_alignment
) {
3212 if (sector_num
% bs
->bl
.write_zeroes_alignment
!= 0) {
3213 /* Make a small request up to the first aligned sector. */
3214 num
= bs
->bl
.write_zeroes_alignment
;
3215 num
-= sector_num
% bs
->bl
.write_zeroes_alignment
;
3216 } else if ((sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
!= 0) {
3217 /* Shorten the request to the last aligned sector. num cannot
3218 * underflow because num > bs->bl.write_zeroes_alignment.
3220 num
-= (sector_num
+ num
) % bs
->bl
.write_zeroes_alignment
;
3224 /* limit request size */
3225 if (num
> max_write_zeroes
) {
3226 num
= max_write_zeroes
;
3230 /* First try the efficient write zeroes operation */
3231 if (drv
->bdrv_co_write_zeroes
) {
3232 ret
= drv
->bdrv_co_write_zeroes(bs
, sector_num
, num
, flags
);
3235 if (ret
== -ENOTSUP
) {
3236 /* Fall back to bounce buffer if write zeroes is unsupported */
3237 iov
.iov_len
= num
* BDRV_SECTOR_SIZE
;
3238 if (iov
.iov_base
== NULL
) {
3239 iov
.iov_base
= qemu_blockalign(bs
, num
* BDRV_SECTOR_SIZE
);
3240 memset(iov
.iov_base
, 0, num
* BDRV_SECTOR_SIZE
);
3242 qemu_iovec_init_external(&qiov
, &iov
, 1);
3244 ret
= drv
->bdrv_co_writev(bs
, sector_num
, num
, &qiov
);
3246 /* Keep bounce buffer around if it is big enough for all
3247 * all future requests.
3249 if (num
< max_write_zeroes
) {
3250 qemu_vfree(iov
.iov_base
);
3251 iov
.iov_base
= NULL
;
3259 qemu_vfree(iov
.iov_base
);
3264 * Forwards an already correctly aligned write request to the BlockDriver.
3266 static int coroutine_fn
bdrv_aligned_pwritev(BlockDriverState
*bs
,
3267 BdrvTrackedRequest
*req
, int64_t offset
, unsigned int bytes
,
3268 QEMUIOVector
*qiov
, int flags
)
3270 BlockDriver
*drv
= bs
->drv
;
3274 int64_t sector_num
= offset
>> BDRV_SECTOR_BITS
;
3275 unsigned int nb_sectors
= bytes
>> BDRV_SECTOR_BITS
;
3277 assert((offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3278 assert((bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
3280 waited
= wait_serialising_requests(req
);
3281 assert(!waited
|| !req
->serialising
);
3282 assert(req
->overlap_offset
<= offset
);
3283 assert(offset
+ bytes
<= req
->overlap_offset
+ req
->overlap_bytes
);
3285 ret
= notifier_with_return_list_notify(&bs
->before_write_notifiers
, req
);
3287 if (!ret
&& bs
->detect_zeroes
!= BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF
&&
3288 !(flags
& BDRV_REQ_ZERO_WRITE
) && drv
->bdrv_co_write_zeroes
&&
3289 qemu_iovec_is_zero(qiov
)) {
3290 flags
|= BDRV_REQ_ZERO_WRITE
;
3291 if (bs
->detect_zeroes
== BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP
) {
3292 flags
|= BDRV_REQ_MAY_UNMAP
;
3297 /* Do nothing, write notifier decided to fail this request */
3298 } else if (flags
& BDRV_REQ_ZERO_WRITE
) {
3299 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_ZERO
);
3300 ret
= bdrv_co_do_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3302 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV
);
3303 ret
= drv
->bdrv_co_writev(bs
, sector_num
, nb_sectors
, qiov
);
3305 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_DONE
);
3307 if (ret
== 0 && !bs
->enable_write_cache
) {
3308 ret
= bdrv_co_flush(bs
);
3311 bdrv_set_dirty(bs
, sector_num
, nb_sectors
);
3313 if (bs
->wr_highest_sector
< sector_num
+ nb_sectors
- 1) {
3314 bs
->wr_highest_sector
= sector_num
+ nb_sectors
- 1;
3316 if (bs
->growable
&& ret
>= 0) {
3317 bs
->total_sectors
= MAX(bs
->total_sectors
, sector_num
+ nb_sectors
);
3324 * Handle a write request in coroutine context
3326 static int coroutine_fn
bdrv_co_do_pwritev(BlockDriverState
*bs
,
3327 int64_t offset
, unsigned int bytes
, QEMUIOVector
*qiov
,
3328 BdrvRequestFlags flags
)
3330 BdrvTrackedRequest req
;
3331 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3332 uint64_t align
= MAX(BDRV_SECTOR_SIZE
, bs
->request_alignment
);
3333 uint8_t *head_buf
= NULL
;
3334 uint8_t *tail_buf
= NULL
;
3335 QEMUIOVector local_qiov
;
3336 bool use_local_qiov
= false;
3342 if (bs
->read_only
) {
3345 if (bdrv_check_byte_request(bs
, offset
, bytes
)) {
3349 /* throttling disk I/O */
3350 if (bs
->io_limits_enabled
) {
3351 bdrv_io_limits_intercept(bs
, bytes
, true);
3355 * Align write if necessary by performing a read-modify-write cycle.
3356 * Pad qiov with the read parts and be sure to have a tracked request not
3357 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3359 tracked_request_begin(&req
, bs
, offset
, bytes
, true);
3361 if (offset
& (align
- 1)) {
3362 QEMUIOVector head_qiov
;
3363 struct iovec head_iov
;
3365 mark_request_serialising(&req
, align
);
3366 wait_serialising_requests(&req
);
3368 head_buf
= qemu_blockalign(bs
, align
);
3369 head_iov
= (struct iovec
) {
3370 .iov_base
= head_buf
,
3373 qemu_iovec_init_external(&head_qiov
, &head_iov
, 1);
3375 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_HEAD
);
3376 ret
= bdrv_aligned_preadv(bs
, &req
, offset
& ~(align
- 1), align
,
3377 align
, &head_qiov
, 0);
3381 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_HEAD
);
3383 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 2);
3384 qemu_iovec_add(&local_qiov
, head_buf
, offset
& (align
- 1));
3385 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3386 use_local_qiov
= true;
3388 bytes
+= offset
& (align
- 1);
3389 offset
= offset
& ~(align
- 1);
3392 if ((offset
+ bytes
) & (align
- 1)) {
3393 QEMUIOVector tail_qiov
;
3394 struct iovec tail_iov
;
3398 mark_request_serialising(&req
, align
);
3399 waited
= wait_serialising_requests(&req
);
3400 assert(!waited
|| !use_local_qiov
);
3402 tail_buf
= qemu_blockalign(bs
, align
);
3403 tail_iov
= (struct iovec
) {
3404 .iov_base
= tail_buf
,
3407 qemu_iovec_init_external(&tail_qiov
, &tail_iov
, 1);
3409 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_TAIL
);
3410 ret
= bdrv_aligned_preadv(bs
, &req
, (offset
+ bytes
) & ~(align
- 1), align
,
3411 align
, &tail_qiov
, 0);
3415 BLKDBG_EVENT(bs
, BLKDBG_PWRITEV_RMW_AFTER_TAIL
);
3417 if (!use_local_qiov
) {
3418 qemu_iovec_init(&local_qiov
, qiov
->niov
+ 1);
3419 qemu_iovec_concat(&local_qiov
, qiov
, 0, qiov
->size
);
3420 use_local_qiov
= true;
3423 tail_bytes
= (offset
+ bytes
) & (align
- 1);
3424 qemu_iovec_add(&local_qiov
, tail_buf
+ tail_bytes
, align
- tail_bytes
);
3426 bytes
= ROUND_UP(bytes
, align
);
3429 ret
= bdrv_aligned_pwritev(bs
, &req
, offset
, bytes
,
3430 use_local_qiov ?
&local_qiov
: qiov
,
3434 tracked_request_end(&req
);
3436 if (use_local_qiov
) {
3437 qemu_iovec_destroy(&local_qiov
);
3439 qemu_vfree(head_buf
);
3440 qemu_vfree(tail_buf
);
3445 static int coroutine_fn
bdrv_co_do_writev(BlockDriverState
*bs
,
3446 int64_t sector_num
, int nb_sectors
, QEMUIOVector
*qiov
,
3447 BdrvRequestFlags flags
)
3449 if (nb_sectors
< 0 || nb_sectors
> (INT_MAX
>> BDRV_SECTOR_BITS
)) {
3453 return bdrv_co_do_pwritev(bs
, sector_num
<< BDRV_SECTOR_BITS
,
3454 nb_sectors
<< BDRV_SECTOR_BITS
, qiov
, flags
);
3457 int coroutine_fn
bdrv_co_writev(BlockDriverState
*bs
, int64_t sector_num
,
3458 int nb_sectors
, QEMUIOVector
*qiov
)
3460 trace_bdrv_co_writev(bs
, sector_num
, nb_sectors
);
3462 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, qiov
, 0);
3465 int coroutine_fn
bdrv_co_write_zeroes(BlockDriverState
*bs
,
3466 int64_t sector_num
, int nb_sectors
,
3467 BdrvRequestFlags flags
)
3469 trace_bdrv_co_write_zeroes(bs
, sector_num
, nb_sectors
, flags
);
3471 if (!(bs
->open_flags
& BDRV_O_UNMAP
)) {
3472 flags
&= ~BDRV_REQ_MAY_UNMAP
;
3475 return bdrv_co_do_writev(bs
, sector_num
, nb_sectors
, NULL
,
3476 BDRV_REQ_ZERO_WRITE
| flags
);
3480 * Truncate file to 'offset' bytes (needed only for file protocols)
3482 int bdrv_truncate(BlockDriverState
*bs
, int64_t offset
)
3484 BlockDriver
*drv
= bs
->drv
;
3488 if (!drv
->bdrv_truncate
)
3492 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_RESIZE
, NULL
)) {
3495 ret
= drv
->bdrv_truncate(bs
, offset
);
3497 ret
= refresh_total_sectors(bs
, offset
>> BDRV_SECTOR_BITS
);
3498 bdrv_dev_resize_cb(bs
);
3504 * Length of a allocated file in bytes. Sparse files are counted by actual
3505 * allocated space. Return < 0 if error or unknown.
3507 int64_t bdrv_get_allocated_file_size(BlockDriverState
*bs
)
3509 BlockDriver
*drv
= bs
->drv
;
3513 if (drv
->bdrv_get_allocated_file_size
) {
3514 return drv
->bdrv_get_allocated_file_size(bs
);
3517 return bdrv_get_allocated_file_size(bs
->file
);
3523 * Length of a file in bytes. Return < 0 if error or unknown.
3525 int64_t bdrv_getlength(BlockDriverState
*bs
)
3527 BlockDriver
*drv
= bs
->drv
;
3531 if (drv
->has_variable_length
) {
3532 int ret
= refresh_total_sectors(bs
, bs
->total_sectors
);
3537 return bs
->total_sectors
* BDRV_SECTOR_SIZE
;
3540 /* return 0 as number of sectors if no device present or error */
3541 void bdrv_get_geometry(BlockDriverState
*bs
, uint64_t *nb_sectors_ptr
)
3544 length
= bdrv_getlength(bs
);
3548 length
= length
>> BDRV_SECTOR_BITS
;
3549 *nb_sectors_ptr
= length
;
3552 void bdrv_set_on_error(BlockDriverState
*bs
, BlockdevOnError on_read_error
,
3553 BlockdevOnError on_write_error
)
3555 bs
->on_read_error
= on_read_error
;
3556 bs
->on_write_error
= on_write_error
;
3559 BlockdevOnError
bdrv_get_on_error(BlockDriverState
*bs
, bool is_read
)