intel-iommu: add Intel IOMMU emulation to q35 and add a machine option "iommu" as...
[qemu/rayw.git] / block.c
blob6fa020107466b12e3ccb41299e4d88f75b6b0d1a
1 /*
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
22 * THE SOFTWARE.
24 #include "config-host.h"
25 #include "qemu-common.h"
26 #include "trace.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"
39 #ifdef CONFIG_BSD
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <sys/ioctl.h>
43 #include <sys/queue.h>
44 #ifndef __DragonFly__
45 #include <sys/disk.h>
46 #endif
47 #endif
49 #ifdef _WIN32
50 #include <windows.h>
51 #endif
53 struct BdrvDirtyBitmap {
54 HBitmap *bitmap;
55 QLIST_ENTRY(BdrvDirtyBitmap) list;
58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
60 #define COROUTINE_POOL_RESERVATION 64 /* number of coroutines to reserve */
62 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
63 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
64 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
65 BlockDriverCompletionFunc *cb, void *opaque);
66 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
67 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
68 BlockDriverCompletionFunc *cb, void *opaque);
69 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors,
71 QEMUIOVector *iov);
72 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
73 int64_t sector_num, int nb_sectors,
74 QEMUIOVector *iov);
75 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
76 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
77 BdrvRequestFlags flags);
78 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
79 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
80 BdrvRequestFlags flags);
81 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
82 int64_t sector_num,
83 QEMUIOVector *qiov,
84 int nb_sectors,
85 BdrvRequestFlags flags,
86 BlockDriverCompletionFunc *cb,
87 void *opaque,
88 bool is_write);
89 static void coroutine_fn bdrv_co_do_rw(void *opaque);
90 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
91 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
93 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
94 QTAILQ_HEAD_INITIALIZER(bdrv_states);
96 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states =
97 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states);
99 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
100 QLIST_HEAD_INITIALIZER(bdrv_drivers);
102 /* If non-zero, use only whitelisted block drivers */
103 static int use_bdrv_whitelist;
105 #ifdef _WIN32
106 static int is_windows_drive_prefix(const char *filename)
108 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
109 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
110 filename[1] == ':');
113 int is_windows_drive(const char *filename)
115 if (is_windows_drive_prefix(filename) &&
116 filename[2] == '\0')
117 return 1;
118 if (strstart(filename, "\\\\.\\", NULL) ||
119 strstart(filename, "//./", NULL))
120 return 1;
121 return 0;
123 #endif
125 /* throttling disk I/O limits */
126 void bdrv_set_io_limits(BlockDriverState *bs,
127 ThrottleConfig *cfg)
129 int i;
131 throttle_config(&bs->throttle_state, cfg);
133 for (i = 0; i < 2; i++) {
134 qemu_co_enter_next(&bs->throttled_reqs[i]);
138 /* this function drain all the throttled IOs */
139 static bool bdrv_start_throttled_reqs(BlockDriverState *bs)
141 bool drained = false;
142 bool enabled = bs->io_limits_enabled;
143 int i;
145 bs->io_limits_enabled = false;
147 for (i = 0; i < 2; i++) {
148 while (qemu_co_enter_next(&bs->throttled_reqs[i])) {
149 drained = true;
153 bs->io_limits_enabled = enabled;
155 return drained;
158 void bdrv_io_limits_disable(BlockDriverState *bs)
160 bs->io_limits_enabled = false;
162 bdrv_start_throttled_reqs(bs);
164 throttle_destroy(&bs->throttle_state);
167 static void bdrv_throttle_read_timer_cb(void *opaque)
169 BlockDriverState *bs = opaque;
170 qemu_co_enter_next(&bs->throttled_reqs[0]);
173 static void bdrv_throttle_write_timer_cb(void *opaque)
175 BlockDriverState *bs = opaque;
176 qemu_co_enter_next(&bs->throttled_reqs[1]);
179 /* should be called before bdrv_set_io_limits if a limit is set */
180 void bdrv_io_limits_enable(BlockDriverState *bs)
182 assert(!bs->io_limits_enabled);
183 throttle_init(&bs->throttle_state,
184 bdrv_get_aio_context(bs),
185 QEMU_CLOCK_VIRTUAL,
186 bdrv_throttle_read_timer_cb,
187 bdrv_throttle_write_timer_cb,
188 bs);
189 bs->io_limits_enabled = true;
192 /* This function makes an IO wait if needed
194 * @nb_sectors: the number of sectors of the IO
195 * @is_write: is the IO a write
197 static void bdrv_io_limits_intercept(BlockDriverState *bs,
198 unsigned int bytes,
199 bool is_write)
201 /* does this io must wait */
202 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write);
204 /* if must wait or any request of this type throttled queue the IO */
205 if (must_wait ||
206 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) {
207 qemu_co_queue_wait(&bs->throttled_reqs[is_write]);
210 /* the IO will be executed, do the accounting */
211 throttle_account(&bs->throttle_state, is_write, bytes);
214 /* if the next request must wait -> do nothing */
215 if (throttle_schedule_timer(&bs->throttle_state, is_write)) {
216 return;
219 /* else queue next request for execution */
220 qemu_co_queue_next(&bs->throttled_reqs[is_write]);
223 size_t bdrv_opt_mem_align(BlockDriverState *bs)
225 if (!bs || !bs->drv) {
226 /* 4k should be on the safe side */
227 return 4096;
230 return bs->bl.opt_mem_alignment;
233 /* check if the path starts with "<protocol>:" */
234 static int path_has_protocol(const char *path)
236 const char *p;
238 #ifdef _WIN32
239 if (is_windows_drive(path) ||
240 is_windows_drive_prefix(path)) {
241 return 0;
243 p = path + strcspn(path, ":/\\");
244 #else
245 p = path + strcspn(path, ":/");
246 #endif
248 return *p == ':';
251 int path_is_absolute(const char *path)
253 #ifdef _WIN32
254 /* specific case for names like: "\\.\d:" */
255 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
256 return 1;
258 return (*path == '/' || *path == '\\');
259 #else
260 return (*path == '/');
261 #endif
264 /* if filename is absolute, just copy it to dest. Otherwise, build a
265 path to it by considering it is relative to base_path. URL are
266 supported. */
267 void path_combine(char *dest, int dest_size,
268 const char *base_path,
269 const char *filename)
271 const char *p, *p1;
272 int len;
274 if (dest_size <= 0)
275 return;
276 if (path_is_absolute(filename)) {
277 pstrcpy(dest, dest_size, filename);
278 } else {
279 p = strchr(base_path, ':');
280 if (p)
281 p++;
282 else
283 p = base_path;
284 p1 = strrchr(base_path, '/');
285 #ifdef _WIN32
287 const char *p2;
288 p2 = strrchr(base_path, '\\');
289 if (!p1 || p2 > p1)
290 p1 = p2;
292 #endif
293 if (p1)
294 p1++;
295 else
296 p1 = base_path;
297 if (p1 > p)
298 p = p1;
299 len = p - base_path;
300 if (len > dest_size - 1)
301 len = dest_size - 1;
302 memcpy(dest, base_path, len);
303 dest[len] = '\0';
304 pstrcat(dest, dest_size, filename);
308 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
310 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
311 pstrcpy(dest, sz, bs->backing_file);
312 } else {
313 path_combine(dest, sz, bs->filename, bs->backing_file);
317 void bdrv_register(BlockDriver *bdrv)
319 /* Block drivers without coroutine functions need emulation */
320 if (!bdrv->bdrv_co_readv) {
321 bdrv->bdrv_co_readv = bdrv_co_readv_em;
322 bdrv->bdrv_co_writev = bdrv_co_writev_em;
324 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
325 * the block driver lacks aio we need to emulate that too.
327 if (!bdrv->bdrv_aio_readv) {
328 /* add AIO emulation layer */
329 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
330 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
334 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
337 /* create a new block device (by default it is empty) */
338 BlockDriverState *bdrv_new(const char *device_name, Error **errp)
340 BlockDriverState *bs;
341 int i;
343 if (bdrv_find(device_name)) {
344 error_setg(errp, "Device with id '%s' already exists",
345 device_name);
346 return NULL;
348 if (bdrv_find_node(device_name)) {
349 error_setg(errp, "Device with node-name '%s' already exists",
350 device_name);
351 return NULL;
354 bs = g_malloc0(sizeof(BlockDriverState));
355 QLIST_INIT(&bs->dirty_bitmaps);
356 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
357 if (device_name[0] != '\0') {
358 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list);
360 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
361 QLIST_INIT(&bs->op_blockers[i]);
363 bdrv_iostatus_disable(bs);
364 notifier_list_init(&bs->close_notifiers);
365 notifier_with_return_list_init(&bs->before_write_notifiers);
366 qemu_co_queue_init(&bs->throttled_reqs[0]);
367 qemu_co_queue_init(&bs->throttled_reqs[1]);
368 bs->refcnt = 1;
369 bs->aio_context = qemu_get_aio_context();
371 return bs;
374 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
376 notifier_list_add(&bs->close_notifiers, notify);
379 BlockDriver *bdrv_find_format(const char *format_name)
381 BlockDriver *drv1;
382 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
383 if (!strcmp(drv1->format_name, format_name)) {
384 return drv1;
387 return NULL;
390 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only)
392 static const char *whitelist_rw[] = {
393 CONFIG_BDRV_RW_WHITELIST
395 static const char *whitelist_ro[] = {
396 CONFIG_BDRV_RO_WHITELIST
398 const char **p;
400 if (!whitelist_rw[0] && !whitelist_ro[0]) {
401 return 1; /* no whitelist, anything goes */
404 for (p = whitelist_rw; *p; p++) {
405 if (!strcmp(drv->format_name, *p)) {
406 return 1;
409 if (read_only) {
410 for (p = whitelist_ro; *p; p++) {
411 if (!strcmp(drv->format_name, *p)) {
412 return 1;
416 return 0;
419 BlockDriver *bdrv_find_whitelisted_format(const char *format_name,
420 bool read_only)
422 BlockDriver *drv = bdrv_find_format(format_name);
423 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL;
426 typedef struct CreateCo {
427 BlockDriver *drv;
428 char *filename;
429 QemuOpts *opts;
430 int ret;
431 Error *err;
432 } CreateCo;
434 static void coroutine_fn bdrv_create_co_entry(void *opaque)
436 Error *local_err = NULL;
437 int ret;
439 CreateCo *cco = opaque;
440 assert(cco->drv);
442 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);
443 if (local_err) {
444 error_propagate(&cco->err, local_err);
446 cco->ret = ret;
449 int bdrv_create(BlockDriver *drv, const char* filename,
450 QemuOpts *opts, Error **errp)
452 int ret;
454 Coroutine *co;
455 CreateCo cco = {
456 .drv = drv,
457 .filename = g_strdup(filename),
458 .opts = opts,
459 .ret = NOT_DONE,
460 .err = NULL,
463 if (!drv->bdrv_create) {
464 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);
465 ret = -ENOTSUP;
466 goto out;
469 if (qemu_in_coroutine()) {
470 /* Fast-path if already in coroutine context */
471 bdrv_create_co_entry(&cco);
472 } else {
473 co = qemu_coroutine_create(bdrv_create_co_entry);
474 qemu_coroutine_enter(co, &cco);
475 while (cco.ret == NOT_DONE) {
476 aio_poll(qemu_get_aio_context(), true);
480 ret = cco.ret;
481 if (ret < 0) {
482 if (cco.err) {
483 error_propagate(errp, cco.err);
484 } else {
485 error_setg_errno(errp, -ret, "Could not create image");
489 out:
490 g_free(cco.filename);
491 return ret;
494 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
496 BlockDriver *drv;
497 Error *local_err = NULL;
498 int ret;
500 drv = bdrv_find_protocol(filename, true);
501 if (drv == NULL) {
502 error_setg(errp, "Could not find protocol for file '%s'", filename);
503 return -ENOENT;
506 ret = bdrv_create(drv, filename, opts, &local_err);
507 if (local_err) {
508 error_propagate(errp, local_err);
510 return ret;
513 void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
515 BlockDriver *drv = bs->drv;
516 Error *local_err = NULL;
518 memset(&bs->bl, 0, sizeof(bs->bl));
520 if (!drv) {
521 return;
524 /* Take some limits from the children as a default */
525 if (bs->file) {
526 bdrv_refresh_limits(bs->file, &local_err);
527 if (local_err) {
528 error_propagate(errp, local_err);
529 return;
531 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;
532 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;
533 } else {
534 bs->bl.opt_mem_alignment = 512;
537 if (bs->backing_hd) {
538 bdrv_refresh_limits(bs->backing_hd, &local_err);
539 if (local_err) {
540 error_propagate(errp, local_err);
541 return;
543 bs->bl.opt_transfer_length =
544 MAX(bs->bl.opt_transfer_length,
545 bs->backing_hd->bl.opt_transfer_length);
546 bs->bl.opt_mem_alignment =
547 MAX(bs->bl.opt_mem_alignment,
548 bs->backing_hd->bl.opt_mem_alignment);
551 /* Then let the driver override it */
552 if (drv->bdrv_refresh_limits) {
553 drv->bdrv_refresh_limits(bs, errp);
558 * Create a uniquely-named empty temporary file.
559 * Return 0 upon success, otherwise a negative errno value.
561 int get_tmp_filename(char *filename, int size)
563 #ifdef _WIN32
564 char temp_dir[MAX_PATH];
565 /* GetTempFileName requires that its output buffer (4th param)
566 have length MAX_PATH or greater. */
567 assert(size >= MAX_PATH);
568 return (GetTempPath(MAX_PATH, temp_dir)
569 && GetTempFileName(temp_dir, "qem", 0, filename)
570 ? 0 : -GetLastError());
571 #else
572 int fd;
573 const char *tmpdir;
574 tmpdir = getenv("TMPDIR");
575 if (!tmpdir) {
576 tmpdir = "/var/tmp";
578 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
579 return -EOVERFLOW;
581 fd = mkstemp(filename);
582 if (fd < 0) {
583 return -errno;
585 if (close(fd) != 0) {
586 unlink(filename);
587 return -errno;
589 return 0;
590 #endif
594 * Detect host devices. By convention, /dev/cdrom[N] is always
595 * recognized as a host CDROM.
597 static BlockDriver *find_hdev_driver(const char *filename)
599 int score_max = 0, score;
600 BlockDriver *drv = NULL, *d;
602 QLIST_FOREACH(d, &bdrv_drivers, list) {
603 if (d->bdrv_probe_device) {
604 score = d->bdrv_probe_device(filename);
605 if (score > score_max) {
606 score_max = score;
607 drv = d;
612 return drv;
615 BlockDriver *bdrv_find_protocol(const char *filename,
616 bool allow_protocol_prefix)
618 BlockDriver *drv1;
619 char protocol[128];
620 int len;
621 const char *p;
623 /* TODO Drivers without bdrv_file_open must be specified explicitly */
626 * XXX(hch): we really should not let host device detection
627 * override an explicit protocol specification, but moving this
628 * later breaks access to device names with colons in them.
629 * Thanks to the brain-dead persistent naming schemes on udev-
630 * based Linux systems those actually are quite common.
632 drv1 = find_hdev_driver(filename);
633 if (drv1) {
634 return drv1;
637 if (!path_has_protocol(filename) || !allow_protocol_prefix) {
638 return bdrv_find_format("file");
641 p = strchr(filename, ':');
642 assert(p != NULL);
643 len = p - filename;
644 if (len > sizeof(protocol) - 1)
645 len = sizeof(protocol) - 1;
646 memcpy(protocol, filename, len);
647 protocol[len] = '\0';
648 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
649 if (drv1->protocol_name &&
650 !strcmp(drv1->protocol_name, protocol)) {
651 return drv1;
654 return NULL;
657 static int find_image_format(BlockDriverState *bs, const char *filename,
658 BlockDriver **pdrv, Error **errp)
660 int score, score_max;
661 BlockDriver *drv1, *drv;
662 uint8_t buf[2048];
663 int ret = 0;
665 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
666 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
667 drv = bdrv_find_format("raw");
668 if (!drv) {
669 error_setg(errp, "Could not find raw image format");
670 ret = -ENOENT;
672 *pdrv = drv;
673 return ret;
676 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
677 if (ret < 0) {
678 error_setg_errno(errp, -ret, "Could not read image for determining its "
679 "format");
680 *pdrv = NULL;
681 return ret;
684 score_max = 0;
685 drv = NULL;
686 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
687 if (drv1->bdrv_probe) {
688 score = drv1->bdrv_probe(buf, ret, filename);
689 if (score > score_max) {
690 score_max = score;
691 drv = drv1;
695 if (!drv) {
696 error_setg(errp, "Could not determine image format: No compatible "
697 "driver found");
698 ret = -ENOENT;
700 *pdrv = drv;
701 return ret;
705 * Set the current 'total_sectors' value
706 * Return 0 on success, -errno on error.
708 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
710 BlockDriver *drv = bs->drv;
712 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
713 if (bs->sg)
714 return 0;
716 /* query actual device if possible, otherwise just trust the hint */
717 if (drv->bdrv_getlength) {
718 int64_t length = drv->bdrv_getlength(bs);
719 if (length < 0) {
720 return length;
722 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE);
725 bs->total_sectors = hint;
726 return 0;
730 * Set open flags for a given discard mode
732 * Return 0 on success, -1 if the discard mode was invalid.
734 int bdrv_parse_discard_flags(const char *mode, int *flags)
736 *flags &= ~BDRV_O_UNMAP;
738 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {
739 /* do nothing */
740 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {
741 *flags |= BDRV_O_UNMAP;
742 } else {
743 return -1;
746 return 0;
750 * Set open flags for a given cache mode
752 * Return 0 on success, -1 if the cache mode was invalid.
754 int bdrv_parse_cache_flags(const char *mode, int *flags)
756 *flags &= ~BDRV_O_CACHE_MASK;
758 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
759 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
760 } else if (!strcmp(mode, "directsync")) {
761 *flags |= BDRV_O_NOCACHE;
762 } else if (!strcmp(mode, "writeback")) {
763 *flags |= BDRV_O_CACHE_WB;
764 } else if (!strcmp(mode, "unsafe")) {
765 *flags |= BDRV_O_CACHE_WB;
766 *flags |= BDRV_O_NO_FLUSH;
767 } else if (!strcmp(mode, "writethrough")) {
768 /* this is the default */
769 } else {
770 return -1;
773 return 0;
777 * The copy-on-read flag is actually a reference count so multiple users may
778 * use the feature without worrying about clobbering its previous state.
779 * Copy-on-read stays enabled until all users have called to disable it.
781 void bdrv_enable_copy_on_read(BlockDriverState *bs)
783 bs->copy_on_read++;
786 void bdrv_disable_copy_on_read(BlockDriverState *bs)
788 assert(bs->copy_on_read > 0);
789 bs->copy_on_read--;
793 * Returns the flags that a temporary snapshot should get, based on the
794 * originally requested flags (the originally requested image will have flags
795 * like a backing file)
797 static int bdrv_temp_snapshot_flags(int flags)
799 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY;
803 * Returns the flags that bs->file should get, based on the given flags for
804 * the parent BDS
806 static int bdrv_inherited_flags(int flags)
808 /* Enable protocol handling, disable format probing for bs->file */
809 flags |= BDRV_O_PROTOCOL;
811 /* Our block drivers take care to send flushes and respect unmap policy,
812 * so we can enable both unconditionally on lower layers. */
813 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP;
815 /* Clear flags that only apply to the top layer */
816 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);
818 return flags;
822 * Returns the flags that bs->backing_hd should get, based on the given flags
823 * for the parent BDS
825 static int bdrv_backing_flags(int flags)
827 /* backing files always opened read-only */
828 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ);
830 /* snapshot=on is handled on the top layer */
831 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY);
833 return flags;
836 static int bdrv_open_flags(BlockDriverState *bs, int flags)
838 int open_flags = flags | BDRV_O_CACHE_WB;
841 * Clear flags that are internal to the block layer before opening the
842 * image.
844 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);
847 * Snapshots should be writable.
849 if (flags & BDRV_O_TEMPORARY) {
850 open_flags |= BDRV_O_RDWR;
853 return open_flags;
856 static void bdrv_assign_node_name(BlockDriverState *bs,
857 const char *node_name,
858 Error **errp)
860 if (!node_name) {
861 return;
864 /* empty string node name is invalid */
865 if (node_name[0] == '\0') {
866 error_setg(errp, "Empty node name");
867 return;
870 /* takes care of avoiding namespaces collisions */
871 if (bdrv_find(node_name)) {
872 error_setg(errp, "node-name=%s is conflicting with a device id",
873 node_name);
874 return;
877 /* takes care of avoiding duplicates node names */
878 if (bdrv_find_node(node_name)) {
879 error_setg(errp, "Duplicate node name");
880 return;
883 /* copy node name into the bs and insert it into the graph list */
884 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
885 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
889 * Common part for opening disk images and files
891 * Removes all processed options from *options.
893 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
894 QDict *options, int flags, BlockDriver *drv, Error **errp)
896 int ret, open_flags;
897 const char *filename;
898 const char *node_name = NULL;
899 Error *local_err = NULL;
901 assert(drv != NULL);
902 assert(bs->file == NULL);
903 assert(options != NULL && bs->options != options);
905 if (file != NULL) {
906 filename = file->filename;
907 } else {
908 filename = qdict_get_try_str(options, "filename");
911 if (drv->bdrv_needs_filename && !filename) {
912 error_setg(errp, "The '%s' block driver requires a file name",
913 drv->format_name);
914 return -EINVAL;
917 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name);
919 node_name = qdict_get_try_str(options, "node-name");
920 bdrv_assign_node_name(bs, node_name, &local_err);
921 if (local_err) {
922 error_propagate(errp, local_err);
923 return -EINVAL;
925 qdict_del(options, "node-name");
927 /* bdrv_open() with directly using a protocol as drv. This layer is already
928 * opened, so assign it to bs (while file becomes a closed BlockDriverState)
929 * and return immediately. */
930 if (file != NULL && drv->bdrv_file_open) {
931 bdrv_swap(file, bs);
932 return 0;
935 bs->open_flags = flags;
936 bs->guest_block_size = 512;
937 bs->request_alignment = 512;
938 bs->zero_beyond_eof = true;
939 open_flags = bdrv_open_flags(bs, flags);
940 bs->read_only = !(open_flags & BDRV_O_RDWR);
941 bs->growable = !!(flags & BDRV_O_PROTOCOL);
943 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
944 error_setg(errp,
945 !bs->read_only && bdrv_is_whitelisted(drv, true)
946 ? "Driver '%s' can only be used for read-only devices"
947 : "Driver '%s' is not whitelisted",
948 drv->format_name);
949 return -ENOTSUP;
952 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
953 if (flags & BDRV_O_COPY_ON_READ) {
954 if (!bs->read_only) {
955 bdrv_enable_copy_on_read(bs);
956 } else {
957 error_setg(errp, "Can't use copy-on-read on read-only device");
958 return -EINVAL;
962 if (filename != NULL) {
963 pstrcpy(bs->filename, sizeof(bs->filename), filename);
964 } else {
965 bs->filename[0] = '\0';
968 bs->drv = drv;
969 bs->opaque = g_malloc0(drv->instance_size);
971 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
973 /* Open the image, either directly or using a protocol */
974 if (drv->bdrv_file_open) {
975 assert(file == NULL);
976 assert(!drv->bdrv_needs_filename || filename != NULL);
977 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
978 } else {
979 if (file == NULL) {
980 error_setg(errp, "Can't use '%s' as a block driver for the "
981 "protocol level", drv->format_name);
982 ret = -EINVAL;
983 goto free_and_fail;
985 bs->file = file;
986 ret = drv->bdrv_open(bs, options, open_flags, &local_err);
989 if (ret < 0) {
990 if (local_err) {
991 error_propagate(errp, local_err);
992 } else if (bs->filename[0]) {
993 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
994 } else {
995 error_setg_errno(errp, -ret, "Could not open image");
997 goto free_and_fail;
1000 ret = refresh_total_sectors(bs, bs->total_sectors);
1001 if (ret < 0) {
1002 error_setg_errno(errp, -ret, "Could not refresh total sector count");
1003 goto free_and_fail;
1006 bdrv_refresh_limits(bs, &local_err);
1007 if (local_err) {
1008 error_propagate(errp, local_err);
1009 ret = -EINVAL;
1010 goto free_and_fail;
1013 assert(bdrv_opt_mem_align(bs) != 0);
1014 assert((bs->request_alignment != 0) || bs->sg);
1015 return 0;
1017 free_and_fail:
1018 bs->file = NULL;
1019 g_free(bs->opaque);
1020 bs->opaque = NULL;
1021 bs->drv = NULL;
1022 return ret;
1025 static QDict *parse_json_filename(const char *filename, Error **errp)
1027 QObject *options_obj;
1028 QDict *options;
1029 int ret;
1031 ret = strstart(filename, "json:", &filename);
1032 assert(ret);
1034 options_obj = qobject_from_json(filename);
1035 if (!options_obj) {
1036 error_setg(errp, "Could not parse the JSON options");
1037 return NULL;
1040 if (qobject_type(options_obj) != QTYPE_QDICT) {
1041 qobject_decref(options_obj);
1042 error_setg(errp, "Invalid JSON object given");
1043 return NULL;
1046 options = qobject_to_qdict(options_obj);
1047 qdict_flatten(options);
1049 return options;
1053 * Fills in default options for opening images and converts the legacy
1054 * filename/flags pair to option QDict entries.
1056 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,
1057 BlockDriver *drv, Error **errp)
1059 const char *filename = *pfilename;
1060 const char *drvname;
1061 bool protocol = flags & BDRV_O_PROTOCOL;
1062 bool parse_filename = false;
1063 Error *local_err = NULL;
1065 /* Parse json: pseudo-protocol */
1066 if (filename && g_str_has_prefix(filename, "json:")) {
1067 QDict *json_options = parse_json_filename(filename, &local_err);
1068 if (local_err) {
1069 error_propagate(errp, local_err);
1070 return -EINVAL;
1073 /* Options given in the filename have lower priority than options
1074 * specified directly */
1075 qdict_join(*options, json_options, false);
1076 QDECREF(json_options);
1077 *pfilename = filename = NULL;
1080 /* Fetch the file name from the options QDict if necessary */
1081 if (protocol && filename) {
1082 if (!qdict_haskey(*options, "filename")) {
1083 qdict_put(*options, "filename", qstring_from_str(filename));
1084 parse_filename = true;
1085 } else {
1086 error_setg(errp, "Can't specify 'file' and 'filename' options at "
1087 "the same time");
1088 return -EINVAL;
1092 /* Find the right block driver */
1093 filename = qdict_get_try_str(*options, "filename");
1094 drvname = qdict_get_try_str(*options, "driver");
1096 if (drv) {
1097 if (drvname) {
1098 error_setg(errp, "Driver specified twice");
1099 return -EINVAL;
1101 drvname = drv->format_name;
1102 qdict_put(*options, "driver", qstring_from_str(drvname));
1103 } else {
1104 if (!drvname && protocol) {
1105 if (filename) {
1106 drv = bdrv_find_protocol(filename, parse_filename);
1107 if (!drv) {
1108 error_setg(errp, "Unknown protocol");
1109 return -EINVAL;
1112 drvname = drv->format_name;
1113 qdict_put(*options, "driver", qstring_from_str(drvname));
1114 } else {
1115 error_setg(errp, "Must specify either driver or file");
1116 return -EINVAL;
1118 } else if (drvname) {
1119 drv = bdrv_find_format(drvname);
1120 if (!drv) {
1121 error_setg(errp, "Unknown driver '%s'", drvname);
1122 return -ENOENT;
1127 assert(drv || !protocol);
1129 /* Driver-specific filename parsing */
1130 if (drv && drv->bdrv_parse_filename && parse_filename) {
1131 drv->bdrv_parse_filename(filename, *options, &local_err);
1132 if (local_err) {
1133 error_propagate(errp, local_err);
1134 return -EINVAL;
1137 if (!drv->bdrv_needs_filename) {
1138 qdict_del(*options, "filename");
1142 return 0;
1145 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
1148 if (bs->backing_hd) {
1149 assert(bs->backing_blocker);
1150 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker);
1151 } else if (backing_hd) {
1152 error_setg(&bs->backing_blocker,
1153 "device is used as backing hd of '%s'",
1154 bs->device_name);
1157 bs->backing_hd = backing_hd;
1158 if (!backing_hd) {
1159 error_free(bs->backing_blocker);
1160 bs->backing_blocker = NULL;
1161 goto out;
1163 bs->open_flags &= ~BDRV_O_NO_BACKING;
1164 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename);
1165 pstrcpy(bs->backing_format, sizeof(bs->backing_format),
1166 backing_hd->drv ? backing_hd->drv->format_name : "");
1168 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker);
1169 /* Otherwise we won't be able to commit due to check in bdrv_commit */
1170 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT,
1171 bs->backing_blocker);
1172 out:
1173 bdrv_refresh_limits(bs, NULL);
1177 * Opens the backing file for a BlockDriverState if not yet open
1179 * options is a QDict of options to pass to the block drivers, or NULL for an
1180 * empty set of options. The reference to the QDict is transferred to this
1181 * function (even on failure), so if the caller intends to reuse the dictionary,
1182 * it needs to use QINCREF() before calling bdrv_file_open.
1184 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp)
1186 char *backing_filename = g_malloc0(PATH_MAX);
1187 int ret = 0;
1188 BlockDriver *back_drv = NULL;
1189 BlockDriverState *backing_hd;
1190 Error *local_err = NULL;
1192 if (bs->backing_hd != NULL) {
1193 QDECREF(options);
1194 goto free_exit;
1197 /* NULL means an empty set of options */
1198 if (options == NULL) {
1199 options = qdict_new();
1202 bs->open_flags &= ~BDRV_O_NO_BACKING;
1203 if (qdict_haskey(options, "file.filename")) {
1204 backing_filename[0] = '\0';
1205 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
1206 QDECREF(options);
1207 goto free_exit;
1208 } else {
1209 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);
1212 if (!bs->drv || !bs->drv->supports_backing) {
1213 ret = -EINVAL;
1214 error_setg(errp, "Driver doesn't support backing files");
1215 QDECREF(options);
1216 goto free_exit;
1219 backing_hd = bdrv_new("", errp);
1221 if (bs->backing_format[0] != '\0') {
1222 back_drv = bdrv_find_format(bs->backing_format);
1225 assert(bs->backing_hd == NULL);
1226 ret = bdrv_open(&backing_hd,
1227 *backing_filename ? backing_filename : NULL, NULL, options,
1228 bdrv_backing_flags(bs->open_flags), back_drv, &local_err);
1229 if (ret < 0) {
1230 bdrv_unref(backing_hd);
1231 backing_hd = NULL;
1232 bs->open_flags |= BDRV_O_NO_BACKING;
1233 error_setg(errp, "Could not open backing file: %s",
1234 error_get_pretty(local_err));
1235 error_free(local_err);
1236 goto free_exit;
1238 bdrv_set_backing_hd(bs, backing_hd);
1240 free_exit:
1241 g_free(backing_filename);
1242 return ret;
1246 * Opens a disk image whose options are given as BlockdevRef in another block
1247 * device's options.
1249 * If allow_none is true, no image will be opened if filename is false and no
1250 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
1252 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
1253 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
1254 * itself, all options starting with "${bdref_key}." are considered part of the
1255 * BlockdevRef.
1257 * The BlockdevRef will be removed from the options QDict.
1259 * To conform with the behavior of bdrv_open(), *pbs has to be NULL.
1261 int bdrv_open_image(BlockDriverState **pbs, const char *filename,
1262 QDict *options, const char *bdref_key, int flags,
1263 bool allow_none, Error **errp)
1265 QDict *image_options;
1266 int ret;
1267 char *bdref_key_dot;
1268 const char *reference;
1270 assert(pbs);
1271 assert(*pbs == NULL);
1273 bdref_key_dot = g_strdup_printf("%s.", bdref_key);
1274 qdict_extract_subqdict(options, &image_options, bdref_key_dot);
1275 g_free(bdref_key_dot);
1277 reference = qdict_get_try_str(options, bdref_key);
1278 if (!filename && !reference && !qdict_size(image_options)) {
1279 if (allow_none) {
1280 ret = 0;
1281 } else {
1282 error_setg(errp, "A block device must be specified for \"%s\"",
1283 bdref_key);
1284 ret = -EINVAL;
1286 QDECREF(image_options);
1287 goto done;
1290 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);
1292 done:
1293 qdict_del(options, bdref_key);
1294 return ret;
1297 int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)
1299 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
1300 char *tmp_filename = g_malloc0(PATH_MAX + 1);
1301 int64_t total_size;
1302 BlockDriver *bdrv_qcow2;
1303 QemuOpts *opts = NULL;
1304 QDict *snapshot_options;
1305 BlockDriverState *bs_snapshot;
1306 Error *local_err;
1307 int ret;
1309 /* if snapshot, we create a temporary backing file and open it
1310 instead of opening 'filename' directly */
1312 /* Get the required size from the image */
1313 total_size = bdrv_getlength(bs);
1314 if (total_size < 0) {
1315 ret = total_size;
1316 error_setg_errno(errp, -total_size, "Could not get image size");
1317 goto out;
1320 /* Create the temporary image */
1321 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1);
1322 if (ret < 0) {
1323 error_setg_errno(errp, -ret, "Could not get temporary filename");
1324 goto out;
1327 bdrv_qcow2 = bdrv_find_format("qcow2");
1328 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,
1329 &error_abort);
1330 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);
1331 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);
1332 qemu_opts_del(opts);
1333 if (ret < 0) {
1334 error_setg_errno(errp, -ret, "Could not create temporary overlay "
1335 "'%s': %s", tmp_filename,
1336 error_get_pretty(local_err));
1337 error_free(local_err);
1338 goto out;
1341 /* Prepare a new options QDict for the temporary file */
1342 snapshot_options = qdict_new();
1343 qdict_put(snapshot_options, "file.driver",
1344 qstring_from_str("file"));
1345 qdict_put(snapshot_options, "file.filename",
1346 qstring_from_str(tmp_filename));
1348 bs_snapshot = bdrv_new("", &error_abort);
1350 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options,
1351 flags, bdrv_qcow2, &local_err);
1352 if (ret < 0) {
1353 error_propagate(errp, local_err);
1354 goto out;
1357 bdrv_append(bs_snapshot, bs);
1359 out:
1360 g_free(tmp_filename);
1361 return ret;
1365 * Opens a disk image (raw, qcow2, vmdk, ...)
1367 * options is a QDict of options to pass to the block drivers, or NULL for an
1368 * empty set of options. The reference to the QDict belongs to the block layer
1369 * after the call (even on failure), so if the caller intends to reuse the
1370 * dictionary, it needs to use QINCREF() before calling bdrv_open.
1372 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
1373 * If it is not NULL, the referenced BDS will be reused.
1375 * The reference parameter may be used to specify an existing block device which
1376 * should be opened. If specified, neither options nor a filename may be given,
1377 * nor can an existing BDS be reused (that is, *pbs has to be NULL).
1379 int bdrv_open(BlockDriverState **pbs, const char *filename,
1380 const char *reference, QDict *options, int flags,
1381 BlockDriver *drv, Error **errp)
1383 int ret;
1384 BlockDriverState *file = NULL, *bs;
1385 const char *drvname;
1386 Error *local_err = NULL;
1387 int snapshot_flags = 0;
1389 assert(pbs);
1391 if (reference) {
1392 bool options_non_empty = options ? qdict_size(options) : false;
1393 QDECREF(options);
1395 if (*pbs) {
1396 error_setg(errp, "Cannot reuse an existing BDS when referencing "
1397 "another block device");
1398 return -EINVAL;
1401 if (filename || options_non_empty) {
1402 error_setg(errp, "Cannot reference an existing block device with "
1403 "additional options or a new filename");
1404 return -EINVAL;
1407 bs = bdrv_lookup_bs(reference, reference, errp);
1408 if (!bs) {
1409 return -ENODEV;
1411 bdrv_ref(bs);
1412 *pbs = bs;
1413 return 0;
1416 if (*pbs) {
1417 bs = *pbs;
1418 } else {
1419 bs = bdrv_new("", &error_abort);
1422 /* NULL means an empty set of options */
1423 if (options == NULL) {
1424 options = qdict_new();
1427 ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);
1428 if (local_err) {
1429 goto fail;
1432 /* Find the right image format driver */
1433 drv = NULL;
1434 drvname = qdict_get_try_str(options, "driver");
1435 if (drvname) {
1436 drv = bdrv_find_format(drvname);
1437 qdict_del(options, "driver");
1438 if (!drv) {
1439 error_setg(errp, "Unknown driver: '%s'", drvname);
1440 ret = -EINVAL;
1441 goto fail;
1445 assert(drvname || !(flags & BDRV_O_PROTOCOL));
1446 if (drv && !drv->bdrv_file_open) {
1447 /* If the user explicitly wants a format driver here, we'll need to add
1448 * another layer for the protocol in bs->file */
1449 flags &= ~BDRV_O_PROTOCOL;
1452 bs->options = options;
1453 options = qdict_clone_shallow(options);
1455 /* Open image file without format layer */
1456 if ((flags & BDRV_O_PROTOCOL) == 0) {
1457 if (flags & BDRV_O_RDWR) {
1458 flags |= BDRV_O_ALLOW_RDWR;
1460 if (flags & BDRV_O_SNAPSHOT) {
1461 snapshot_flags = bdrv_temp_snapshot_flags(flags);
1462 flags = bdrv_backing_flags(flags);
1465 assert(file == NULL);
1466 ret = bdrv_open_image(&file, filename, options, "file",
1467 bdrv_inherited_flags(flags),
1468 true, &local_err);
1469 if (ret < 0) {
1470 goto fail;
1474 /* Image format probing */
1475 if (!drv && file) {
1476 ret = find_image_format(file, filename, &drv, &local_err);
1477 if (ret < 0) {
1478 goto fail;
1480 } else if (!drv) {
1481 error_setg(errp, "Must specify either driver or file");
1482 ret = -EINVAL;
1483 goto fail;
1486 /* Open the image */
1487 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err);
1488 if (ret < 0) {
1489 goto fail;
1492 if (file && (bs->file != file)) {
1493 bdrv_unref(file);
1494 file = NULL;
1497 /* If there is a backing file, use it */
1498 if ((flags & BDRV_O_NO_BACKING) == 0) {
1499 QDict *backing_options;
1501 qdict_extract_subqdict(options, &backing_options, "backing.");
1502 ret = bdrv_open_backing_file(bs, backing_options, &local_err);
1503 if (ret < 0) {
1504 goto close_and_fail;
1508 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
1509 * temporary snapshot afterwards. */
1510 if (snapshot_flags) {
1511 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);
1512 if (local_err) {
1513 goto close_and_fail;
1517 /* Check if any unknown options were used */
1518 if (options && (qdict_size(options) != 0)) {
1519 const QDictEntry *entry = qdict_first(options);
1520 if (flags & BDRV_O_PROTOCOL) {
1521 error_setg(errp, "Block protocol '%s' doesn't support the option "
1522 "'%s'", drv->format_name, entry->key);
1523 } else {
1524 error_setg(errp, "Block format '%s' used by device '%s' doesn't "
1525 "support the option '%s'", drv->format_name,
1526 bs->device_name, entry->key);
1529 ret = -EINVAL;
1530 goto close_and_fail;
1533 if (!bdrv_key_required(bs)) {
1534 bdrv_dev_change_media_cb(bs, true);
1535 } else if (!runstate_check(RUN_STATE_PRELAUNCH)
1536 && !runstate_check(RUN_STATE_INMIGRATE)
1537 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */
1538 error_setg(errp,
1539 "Guest must be stopped for opening of encrypted image");
1540 ret = -EBUSY;
1541 goto close_and_fail;
1544 QDECREF(options);
1545 *pbs = bs;
1546 return 0;
1548 fail:
1549 if (file != NULL) {
1550 bdrv_unref(file);
1552 QDECREF(bs->options);
1553 QDECREF(options);
1554 bs->options = NULL;
1555 if (!*pbs) {
1556 /* If *pbs is NULL, a new BDS has been created in this function and
1557 needs to be freed now. Otherwise, it does not need to be closed,
1558 since it has not really been opened yet. */
1559 bdrv_unref(bs);
1561 if (local_err) {
1562 error_propagate(errp, local_err);
1564 return ret;
1566 close_and_fail:
1567 /* See fail path, but now the BDS has to be always closed */
1568 if (*pbs) {
1569 bdrv_close(bs);
1570 } else {
1571 bdrv_unref(bs);
1573 QDECREF(options);
1574 if (local_err) {
1575 error_propagate(errp, local_err);
1577 return ret;
1580 typedef struct BlockReopenQueueEntry {
1581 bool prepared;
1582 BDRVReopenState state;
1583 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
1584 } BlockReopenQueueEntry;
1587 * Adds a BlockDriverState to a simple queue for an atomic, transactional
1588 * reopen of multiple devices.
1590 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
1591 * already performed, or alternatively may be NULL a new BlockReopenQueue will
1592 * be created and initialized. This newly created BlockReopenQueue should be
1593 * passed back in for subsequent calls that are intended to be of the same
1594 * atomic 'set'.
1596 * bs is the BlockDriverState to add to the reopen queue.
1598 * flags contains the open flags for the associated bs
1600 * returns a pointer to bs_queue, which is either the newly allocated
1601 * bs_queue, or the existing bs_queue being used.
1604 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
1605 BlockDriverState *bs, int flags)
1607 assert(bs != NULL);
1609 BlockReopenQueueEntry *bs_entry;
1610 if (bs_queue == NULL) {
1611 bs_queue = g_new0(BlockReopenQueue, 1);
1612 QSIMPLEQ_INIT(bs_queue);
1615 /* bdrv_open() masks this flag out */
1616 flags &= ~BDRV_O_PROTOCOL;
1618 if (bs->file) {
1619 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags));
1622 bs_entry = g_new0(BlockReopenQueueEntry, 1);
1623 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
1625 bs_entry->state.bs = bs;
1626 bs_entry->state.flags = flags;
1628 return bs_queue;
1632 * Reopen multiple BlockDriverStates atomically & transactionally.
1634 * The queue passed in (bs_queue) must have been built up previous
1635 * via bdrv_reopen_queue().
1637 * Reopens all BDS specified in the queue, with the appropriate
1638 * flags. All devices are prepared for reopen, and failure of any
1639 * device will cause all device changes to be abandonded, and intermediate
1640 * data cleaned up.
1642 * If all devices prepare successfully, then the changes are committed
1643 * to all devices.
1646 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
1648 int ret = -1;
1649 BlockReopenQueueEntry *bs_entry, *next;
1650 Error *local_err = NULL;
1652 assert(bs_queue != NULL);
1654 bdrv_drain_all();
1656 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1657 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
1658 error_propagate(errp, local_err);
1659 goto cleanup;
1661 bs_entry->prepared = true;
1664 /* If we reach this point, we have success and just need to apply the
1665 * changes
1667 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
1668 bdrv_reopen_commit(&bs_entry->state);
1671 ret = 0;
1673 cleanup:
1674 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1675 if (ret && bs_entry->prepared) {
1676 bdrv_reopen_abort(&bs_entry->state);
1678 g_free(bs_entry);
1680 g_free(bs_queue);
1681 return ret;
1685 /* Reopen a single BlockDriverState with the specified flags. */
1686 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1688 int ret = -1;
1689 Error *local_err = NULL;
1690 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1692 ret = bdrv_reopen_multiple(queue, &local_err);
1693 if (local_err != NULL) {
1694 error_propagate(errp, local_err);
1696 return ret;
1701 * Prepares a BlockDriverState for reopen. All changes are staged in the
1702 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1703 * the block driver layer .bdrv_reopen_prepare()
1705 * bs is the BlockDriverState to reopen
1706 * flags are the new open flags
1707 * queue is the reopen queue
1709 * Returns 0 on success, non-zero on error. On error errp will be set
1710 * as well.
1712 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1713 * It is the responsibility of the caller to then call the abort() or
1714 * commit() for any other BDS that have been left in a prepare() state
1717 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1718 Error **errp)
1720 int ret = -1;
1721 Error *local_err = NULL;
1722 BlockDriver *drv;
1724 assert(reopen_state != NULL);
1725 assert(reopen_state->bs->drv != NULL);
1726 drv = reopen_state->bs->drv;
1728 /* if we are to stay read-only, do not allow permission change
1729 * to r/w */
1730 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1731 reopen_state->flags & BDRV_O_RDWR) {
1732 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1733 reopen_state->bs->device_name);
1734 goto error;
1738 ret = bdrv_flush(reopen_state->bs);
1739 if (ret) {
1740 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1741 strerror(-ret));
1742 goto error;
1745 if (drv->bdrv_reopen_prepare) {
1746 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1747 if (ret) {
1748 if (local_err != NULL) {
1749 error_propagate(errp, local_err);
1750 } else {
1751 error_setg(errp, "failed while preparing to reopen image '%s'",
1752 reopen_state->bs->filename);
1754 goto error;
1756 } else {
1757 /* It is currently mandatory to have a bdrv_reopen_prepare()
1758 * handler for each supported drv. */
1759 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1760 drv->format_name, reopen_state->bs->device_name,
1761 "reopening of file");
1762 ret = -1;
1763 goto error;
1766 ret = 0;
1768 error:
1769 return ret;
1773 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1774 * makes them final by swapping the staging BlockDriverState contents into
1775 * the active BlockDriverState contents.
1777 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1779 BlockDriver *drv;
1781 assert(reopen_state != NULL);
1782 drv = reopen_state->bs->drv;
1783 assert(drv != NULL);
1785 /* If there are any driver level actions to take */
1786 if (drv->bdrv_reopen_commit) {
1787 drv->bdrv_reopen_commit(reopen_state);
1790 /* set BDS specific flags now */
1791 reopen_state->bs->open_flags = reopen_state->flags;
1792 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1793 BDRV_O_CACHE_WB);
1794 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1796 bdrv_refresh_limits(reopen_state->bs, NULL);
1800 * Abort the reopen, and delete and free the staged changes in
1801 * reopen_state
1803 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1805 BlockDriver *drv;
1807 assert(reopen_state != NULL);
1808 drv = reopen_state->bs->drv;
1809 assert(drv != NULL);
1811 if (drv->bdrv_reopen_abort) {
1812 drv->bdrv_reopen_abort(reopen_state);
1817 void bdrv_close(BlockDriverState *bs)
1819 if (bs->job) {
1820 block_job_cancel_sync(bs->job);
1822 bdrv_drain_all(); /* complete I/O */
1823 bdrv_flush(bs);
1824 bdrv_drain_all(); /* in case flush left pending I/O */
1825 notifier_list_notify(&bs->close_notifiers, bs);
1827 if (bs->drv) {
1828 if (bs->backing_hd) {
1829 BlockDriverState *backing_hd = bs->backing_hd;
1830 bdrv_set_backing_hd(bs, NULL);
1831 bdrv_unref(backing_hd);
1833 bs->drv->bdrv_close(bs);
1834 g_free(bs->opaque);
1835 bs->opaque = NULL;
1836 bs->drv = NULL;
1837 bs->copy_on_read = 0;
1838 bs->backing_file[0] = '\0';
1839 bs->backing_format[0] = '\0';
1840 bs->total_sectors = 0;
1841 bs->encrypted = 0;
1842 bs->valid_key = 0;
1843 bs->sg = 0;
1844 bs->growable = 0;
1845 bs->zero_beyond_eof = false;
1846 QDECREF(bs->options);
1847 bs->options = NULL;
1849 if (bs->file != NULL) {
1850 bdrv_unref(bs->file);
1851 bs->file = NULL;
1855 bdrv_dev_change_media_cb(bs, false);
1857 /*throttling disk I/O limits*/
1858 if (bs->io_limits_enabled) {
1859 bdrv_io_limits_disable(bs);
1863 void bdrv_close_all(void)
1865 BlockDriverState *bs;
1867 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1868 AioContext *aio_context = bdrv_get_aio_context(bs);
1870 aio_context_acquire(aio_context);
1871 bdrv_close(bs);
1872 aio_context_release(aio_context);
1876 /* Check if any requests are in-flight (including throttled requests) */
1877 static bool bdrv_requests_pending(BlockDriverState *bs)
1879 if (!QLIST_EMPTY(&bs->tracked_requests)) {
1880 return true;
1882 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) {
1883 return true;
1885 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) {
1886 return true;
1888 if (bs->file && bdrv_requests_pending(bs->file)) {
1889 return true;
1891 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) {
1892 return true;
1894 return false;
1898 * Wait for pending requests to complete across all BlockDriverStates
1900 * This function does not flush data to disk, use bdrv_flush_all() for that
1901 * after calling this function.
1903 * Note that completion of an asynchronous I/O operation can trigger any
1904 * number of other I/O operations on other devices---for example a coroutine
1905 * can be arbitrarily complex and a constant flow of I/O can come until the
1906 * coroutine is complete. Because of this, it is not possible to have a
1907 * function to drain a single device's I/O queue.
1909 void bdrv_drain_all(void)
1911 /* Always run first iteration so any pending completion BHs run */
1912 bool busy = true;
1913 BlockDriverState *bs;
1915 while (busy) {
1916 busy = false;
1918 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
1919 AioContext *aio_context = bdrv_get_aio_context(bs);
1920 bool bs_busy;
1922 aio_context_acquire(aio_context);
1923 bdrv_flush_io_queue(bs);
1924 bdrv_start_throttled_reqs(bs);
1925 bs_busy = bdrv_requests_pending(bs);
1926 bs_busy |= aio_poll(aio_context, bs_busy);
1927 aio_context_release(aio_context);
1929 busy |= bs_busy;
1934 /* make a BlockDriverState anonymous by removing from bdrv_state and
1935 * graph_bdrv_state list.
1936 Also, NULL terminate the device_name to prevent double remove */
1937 void bdrv_make_anon(BlockDriverState *bs)
1939 if (bs->device_name[0] != '\0') {
1940 QTAILQ_REMOVE(&bdrv_states, bs, device_list);
1942 bs->device_name[0] = '\0';
1943 if (bs->node_name[0] != '\0') {
1944 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list);
1946 bs->node_name[0] = '\0';
1949 static void bdrv_rebind(BlockDriverState *bs)
1951 if (bs->drv && bs->drv->bdrv_rebind) {
1952 bs->drv->bdrv_rebind(bs);
1956 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1957 BlockDriverState *bs_src)
1959 /* move some fields that need to stay attached to the device */
1961 /* dev info */
1962 bs_dest->dev_ops = bs_src->dev_ops;
1963 bs_dest->dev_opaque = bs_src->dev_opaque;
1964 bs_dest->dev = bs_src->dev;
1965 bs_dest->guest_block_size = bs_src->guest_block_size;
1966 bs_dest->copy_on_read = bs_src->copy_on_read;
1968 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1970 /* i/o throttled req */
1971 memcpy(&bs_dest->throttle_state,
1972 &bs_src->throttle_state,
1973 sizeof(ThrottleState));
1974 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0];
1975 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1];
1976 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1978 /* r/w error */
1979 bs_dest->on_read_error = bs_src->on_read_error;
1980 bs_dest->on_write_error = bs_src->on_write_error;
1982 /* i/o status */
1983 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1984 bs_dest->iostatus = bs_src->iostatus;
1986 /* dirty bitmap */
1987 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps;
1989 /* reference count */
1990 bs_dest->refcnt = bs_src->refcnt;
1992 /* job */
1993 bs_dest->job = bs_src->job;
1995 /* keep the same entry in bdrv_states */
1996 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1997 bs_src->device_name);
1998 bs_dest->device_list = bs_src->device_list;
1999 memcpy(bs_dest->op_blockers, bs_src->op_blockers,
2000 sizeof(bs_dest->op_blockers));
2004 * Swap bs contents for two image chains while they are live,
2005 * while keeping required fields on the BlockDriverState that is
2006 * actually attached to a device.
2008 * This will modify the BlockDriverState fields, and swap contents
2009 * between bs_new and bs_old. Both bs_new and bs_old are modified.
2011 * bs_new is required to be anonymous.
2013 * This function does not create any image files.
2015 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
2017 BlockDriverState tmp;
2019 /* The code needs to swap the node_name but simply swapping node_list won't
2020 * work so first remove the nodes from the graph list, do the swap then
2021 * insert them back if needed.
2023 if (bs_new->node_name[0] != '\0') {
2024 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list);
2026 if (bs_old->node_name[0] != '\0') {
2027 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list);
2030 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
2031 assert(bs_new->device_name[0] == '\0');
2032 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps));
2033 assert(bs_new->job == NULL);
2034 assert(bs_new->dev == NULL);
2035 assert(bs_new->io_limits_enabled == false);
2036 assert(!throttle_have_timer(&bs_new->throttle_state));
2038 tmp = *bs_new;
2039 *bs_new = *bs_old;
2040 *bs_old = tmp;
2042 /* there are some fields that should not be swapped, move them back */
2043 bdrv_move_feature_fields(&tmp, bs_old);
2044 bdrv_move_feature_fields(bs_old, bs_new);
2045 bdrv_move_feature_fields(bs_new, &tmp);
2047 /* bs_new shouldn't be in bdrv_states even after the swap! */
2048 assert(bs_new->device_name[0] == '\0');
2050 /* Check a few fields that should remain attached to the device */
2051 assert(bs_new->dev == NULL);
2052 assert(bs_new->job == NULL);
2053 assert(bs_new->io_limits_enabled == false);
2054 assert(!throttle_have_timer(&bs_new->throttle_state));
2056 /* insert the nodes back into the graph node list if needed */
2057 if (bs_new->node_name[0] != '\0') {
2058 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list);
2060 if (bs_old->node_name[0] != '\0') {
2061 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list);
2064 bdrv_rebind(bs_new);
2065 bdrv_rebind(bs_old);
2069 * Add new bs contents at the top of an image chain while the chain is
2070 * live, while keeping required fields on the top layer.
2072 * This will modify the BlockDriverState fields, and swap contents
2073 * between bs_new and bs_top. Both bs_new and bs_top are modified.
2075 * bs_new is required to be anonymous.
2077 * This function does not create any image files.
2079 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
2081 bdrv_swap(bs_new, bs_top);
2083 /* The contents of 'tmp' will become bs_top, as we are
2084 * swapping bs_new and bs_top contents. */
2085 bdrv_set_backing_hd(bs_top, bs_new);
2088 static void bdrv_delete(BlockDriverState *bs)
2090 assert(!bs->dev);
2091 assert(!bs->job);
2092 assert(bdrv_op_blocker_is_empty(bs));
2093 assert(!bs->refcnt);
2094 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
2096 bdrv_close(bs);
2098 /* remove from list, if necessary */
2099 bdrv_make_anon(bs);
2101 g_free(bs);
2104 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
2105 /* TODO change to DeviceState *dev when all users are qdevified */
2107 if (bs->dev) {
2108 return -EBUSY;
2110 bs->dev = dev;
2111 bdrv_iostatus_reset(bs);
2113 /* We're expecting I/O from the device so bump up coroutine pool size */
2114 qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION);
2115 return 0;
2118 /* TODO qdevified devices don't use this, remove when devices are qdevified */
2119 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
2121 if (bdrv_attach_dev(bs, dev) < 0) {
2122 abort();
2126 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
2127 /* TODO change to DeviceState *dev when all users are qdevified */
2129 assert(bs->dev == dev);
2130 bs->dev = NULL;
2131 bs->dev_ops = NULL;
2132 bs->dev_opaque = NULL;
2133 bs->guest_block_size = 512;
2134 qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION);
2137 /* TODO change to return DeviceState * when all users are qdevified */
2138 void *bdrv_get_attached_dev(BlockDriverState *bs)
2140 return bs->dev;
2143 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
2144 void *opaque)
2146 bs->dev_ops = ops;
2147 bs->dev_opaque = opaque;
2150 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
2152 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
2153 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
2154 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
2155 if (tray_was_closed) {
2156 /* tray open */
2157 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2158 true, &error_abort);
2160 if (load) {
2161 /* tray close */
2162 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
2163 false, &error_abort);
2168 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
2170 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
2173 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
2175 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
2176 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
2180 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
2182 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
2183 return bs->dev_ops->is_tray_open(bs->dev_opaque);
2185 return false;
2188 static void bdrv_dev_resize_cb(BlockDriverState *bs)
2190 if (bs->dev_ops && bs->dev_ops->resize_cb) {
2191 bs->dev_ops->resize_cb(bs->dev_opaque);
2195 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
2197 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
2198 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
2200 return false;
2204 * Run consistency checks on an image
2206 * Returns 0 if the check could be completed (it doesn't mean that the image is
2207 * free of errors) or -errno when an internal error occurred. The results of the
2208 * check are stored in res.
2210 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
2212 if (bs->drv == NULL) {
2213 return -ENOMEDIUM;
2215 if (bs->drv->bdrv_check == NULL) {
2216 return -ENOTSUP;
2219 memset(res, 0, sizeof(*res));
2220 return bs->drv->bdrv_check(bs, res, fix);
2223 #define COMMIT_BUF_SECTORS 2048
2225 /* commit COW file into the raw image */
2226 int bdrv_commit(BlockDriverState *bs)
2228 BlockDriver *drv = bs->drv;
2229 int64_t sector, total_sectors, length, backing_length;
2230 int n, ro, open_flags;
2231 int ret = 0;
2232 uint8_t *buf = NULL;
2233 char filename[PATH_MAX];
2235 if (!drv)
2236 return -ENOMEDIUM;
2238 if (!bs->backing_hd) {
2239 return -ENOTSUP;
2242 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) ||
2243 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) {
2244 return -EBUSY;
2247 ro = bs->backing_hd->read_only;
2248 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
2249 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
2250 open_flags = bs->backing_hd->open_flags;
2252 if (ro) {
2253 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
2254 return -EACCES;
2258 length = bdrv_getlength(bs);
2259 if (length < 0) {
2260 ret = length;
2261 goto ro_cleanup;
2264 backing_length = bdrv_getlength(bs->backing_hd);
2265 if (backing_length < 0) {
2266 ret = backing_length;
2267 goto ro_cleanup;
2270 /* If our top snapshot is larger than the backing file image,
2271 * grow the backing file image if possible. If not possible,
2272 * we must return an error */
2273 if (length > backing_length) {
2274 ret = bdrv_truncate(bs->backing_hd, length);
2275 if (ret < 0) {
2276 goto ro_cleanup;
2280 total_sectors = length >> BDRV_SECTOR_BITS;
2282 /* qemu_try_blockalign() for bs will choose an alignment that works for
2283 * bs->backing_hd as well, so no need to compare the alignment manually. */
2284 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
2285 if (buf == NULL) {
2286 ret = -ENOMEM;
2287 goto ro_cleanup;
2290 for (sector = 0; sector < total_sectors; sector += n) {
2291 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
2292 if (ret < 0) {
2293 goto ro_cleanup;
2295 if (ret) {
2296 ret = bdrv_read(bs, sector, buf, n);
2297 if (ret < 0) {
2298 goto ro_cleanup;
2301 ret = bdrv_write(bs->backing_hd, sector, buf, n);
2302 if (ret < 0) {
2303 goto ro_cleanup;
2308 if (drv->bdrv_make_empty) {
2309 ret = drv->bdrv_make_empty(bs);
2310 if (ret < 0) {
2311 goto ro_cleanup;
2313 bdrv_flush(bs);
2317 * Make sure all data we wrote to the backing device is actually
2318 * stable on disk.
2320 if (bs->backing_hd) {
2321 bdrv_flush(bs->backing_hd);
2324 ret = 0;
2325 ro_cleanup:
2326 qemu_vfree(buf);
2328 if (ro) {
2329 /* ignoring error return here */
2330 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
2333 return ret;
2336 int bdrv_commit_all(void)
2338 BlockDriverState *bs;
2340 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
2341 AioContext *aio_context = bdrv_get_aio_context(bs);
2343 aio_context_acquire(aio_context);
2344 if (bs->drv && bs->backing_hd) {
2345 int ret = bdrv_commit(bs);
2346 if (ret < 0) {
2347 aio_context_release(aio_context);
2348 return ret;
2351 aio_context_release(aio_context);
2353 return 0;
2357 * Remove an active request from the tracked requests list
2359 * This function should be called when a tracked request is completing.
2361 static void tracked_request_end(BdrvTrackedRequest *req)
2363 if (req->serialising) {
2364 req->bs->serialising_in_flight--;
2367 QLIST_REMOVE(req, list);
2368 qemu_co_queue_restart_all(&req->wait_queue);
2372 * Add an active request to the tracked requests list
2374 static void tracked_request_begin(BdrvTrackedRequest *req,
2375 BlockDriverState *bs,
2376 int64_t offset,
2377 unsigned int bytes, bool is_write)
2379 *req = (BdrvTrackedRequest){
2380 .bs = bs,
2381 .offset = offset,
2382 .bytes = bytes,
2383 .is_write = is_write,
2384 .co = qemu_coroutine_self(),
2385 .serialising = false,
2386 .overlap_offset = offset,
2387 .overlap_bytes = bytes,
2390 qemu_co_queue_init(&req->wait_queue);
2392 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
2395 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
2397 int64_t overlap_offset = req->offset & ~(align - 1);
2398 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
2399 - overlap_offset;
2401 if (!req->serialising) {
2402 req->bs->serialising_in_flight++;
2403 req->serialising = true;
2406 req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
2407 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
2411 * Round a region to cluster boundaries
2413 void bdrv_round_to_clusters(BlockDriverState *bs,
2414 int64_t sector_num, int nb_sectors,
2415 int64_t *cluster_sector_num,
2416 int *cluster_nb_sectors)
2418 BlockDriverInfo bdi;
2420 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
2421 *cluster_sector_num = sector_num;
2422 *cluster_nb_sectors = nb_sectors;
2423 } else {
2424 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
2425 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
2426 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
2427 nb_sectors, c);
2431 static int bdrv_get_cluster_size(BlockDriverState *bs)
2433 BlockDriverInfo bdi;
2434 int ret;
2436 ret = bdrv_get_info(bs, &bdi);
2437 if (ret < 0 || bdi.cluster_size == 0) {
2438 return bs->request_alignment;
2439 } else {
2440 return bdi.cluster_size;
2444 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
2445 int64_t offset, unsigned int bytes)
2447 /* aaaa bbbb */
2448 if (offset >= req->overlap_offset + req->overlap_bytes) {
2449 return false;
2451 /* bbbb aaaa */
2452 if (req->overlap_offset >= offset + bytes) {
2453 return false;
2455 return true;
2458 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
2460 BlockDriverState *bs = self->bs;
2461 BdrvTrackedRequest *req;
2462 bool retry;
2463 bool waited = false;
2465 if (!bs->serialising_in_flight) {
2466 return false;
2469 do {
2470 retry = false;
2471 QLIST_FOREACH(req, &bs->tracked_requests, list) {
2472 if (req == self || (!req->serialising && !self->serialising)) {
2473 continue;
2475 if (tracked_request_overlaps(req, self->overlap_offset,
2476 self->overlap_bytes))
2478 /* Hitting this means there was a reentrant request, for
2479 * example, a block driver issuing nested requests. This must
2480 * never happen since it means deadlock.
2482 assert(qemu_coroutine_self() != req->co);
2484 /* If the request is already (indirectly) waiting for us, or
2485 * will wait for us as soon as it wakes up, then just go on
2486 * (instead of producing a deadlock in the former case). */
2487 if (!req->waiting_for) {
2488 self->waiting_for = req;
2489 qemu_co_queue_wait(&req->wait_queue);
2490 self->waiting_for = NULL;
2491 retry = true;
2492 waited = true;
2493 break;
2497 } while (retry);
2499 return waited;
2503 * Return values:
2504 * 0 - success
2505 * -EINVAL - backing format specified, but no file
2506 * -ENOSPC - can't update the backing file because no space is left in the
2507 * image file header
2508 * -ENOTSUP - format driver doesn't support changing the backing file
2510 int bdrv_change_backing_file(BlockDriverState *bs,
2511 const char *backing_file, const char *backing_fmt)
2513 BlockDriver *drv = bs->drv;
2514 int ret;
2516 /* Backing file format doesn't make sense without a backing file */
2517 if (backing_fmt && !backing_file) {
2518 return -EINVAL;
2521 if (drv->bdrv_change_backing_file != NULL) {
2522 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
2523 } else {
2524 ret = -ENOTSUP;
2527 if (ret == 0) {
2528 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
2529 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
2531 return ret;
2535 * Finds the image layer in the chain that has 'bs' as its backing file.
2537 * active is the current topmost image.
2539 * Returns NULL if bs is not found in active's image chain,
2540 * or if active == bs.
2542 * Returns the bottommost base image if bs == NULL.
2544 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
2545 BlockDriverState *bs)
2547 while (active && bs != active->backing_hd) {
2548 active = active->backing_hd;
2551 return active;
2554 /* Given a BDS, searches for the base layer. */
2555 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
2557 return bdrv_find_overlay(bs, NULL);
2560 typedef struct BlkIntermediateStates {
2561 BlockDriverState *bs;
2562 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
2563 } BlkIntermediateStates;
2567 * Drops images above 'base' up to and including 'top', and sets the image
2568 * above 'top' to have base as its backing file.
2570 * Requires that the overlay to 'top' is opened r/w, so that the backing file
2571 * information in 'bs' can be properly updated.
2573 * E.g., this will convert the following chain:
2574 * bottom <- base <- intermediate <- top <- active
2576 * to
2578 * bottom <- base <- active
2580 * It is allowed for bottom==base, in which case it converts:
2582 * base <- intermediate <- top <- active
2584 * to
2586 * base <- active
2588 * If backing_file_str is non-NULL, it will be used when modifying top's
2589 * overlay image metadata.
2591 * Error conditions:
2592 * if active == top, that is considered an error
2595 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
2596 BlockDriverState *base, const char *backing_file_str)
2598 BlockDriverState *intermediate;
2599 BlockDriverState *base_bs = NULL;
2600 BlockDriverState *new_top_bs = NULL;
2601 BlkIntermediateStates *intermediate_state, *next;
2602 int ret = -EIO;
2604 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
2605 QSIMPLEQ_INIT(&states_to_delete);
2607 if (!top->drv || !base->drv) {
2608 goto exit;
2611 new_top_bs = bdrv_find_overlay(active, top);
2613 if (new_top_bs == NULL) {
2614 /* we could not find the image above 'top', this is an error */
2615 goto exit;
2618 /* special case of new_top_bs->backing_hd already pointing to base - nothing
2619 * to do, no intermediate images */
2620 if (new_top_bs->backing_hd == base) {
2621 ret = 0;
2622 goto exit;
2625 intermediate = top;
2627 /* now we will go down through the list, and add each BDS we find
2628 * into our deletion queue, until we hit the 'base'
2630 while (intermediate) {
2631 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
2632 intermediate_state->bs = intermediate;
2633 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
2635 if (intermediate->backing_hd == base) {
2636 base_bs = intermediate->backing_hd;
2637 break;
2639 intermediate = intermediate->backing_hd;
2641 if (base_bs == NULL) {
2642 /* something went wrong, we did not end at the base. safely
2643 * unravel everything, and exit with error */
2644 goto exit;
2647 /* success - we can delete the intermediate states, and link top->base */
2648 backing_file_str = backing_file_str ? backing_file_str : base_bs->filename;
2649 ret = bdrv_change_backing_file(new_top_bs, backing_file_str,
2650 base_bs->drv ? base_bs->drv->format_name : "");
2651 if (ret) {
2652 goto exit;
2654 bdrv_set_backing_hd(new_top_bs, base_bs);
2656 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2657 /* so that bdrv_close() does not recursively close the chain */
2658 bdrv_set_backing_hd(intermediate_state->bs, NULL);
2659 bdrv_unref(intermediate_state->bs);
2661 ret = 0;
2663 exit:
2664 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
2665 g_free(intermediate_state);
2667 return ret;
2671 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
2672 size_t size)
2674 int64_t len;
2676 if (size > INT_MAX) {
2677 return -EIO;
2680 if (!bdrv_is_inserted(bs))
2681 return -ENOMEDIUM;
2683 if (bs->growable)
2684 return 0;
2686 len = bdrv_getlength(bs);
2688 if (offset < 0)
2689 return -EIO;
2691 if ((offset > len) || (len - offset < size))
2692 return -EIO;
2694 return 0;
2697 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
2698 int nb_sectors)
2700 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2701 return -EIO;
2704 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
2705 nb_sectors * BDRV_SECTOR_SIZE);
2708 typedef struct RwCo {
2709 BlockDriverState *bs;
2710 int64_t offset;
2711 QEMUIOVector *qiov;
2712 bool is_write;
2713 int ret;
2714 BdrvRequestFlags flags;
2715 } RwCo;
2717 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
2719 RwCo *rwco = opaque;
2721 if (!rwco->is_write) {
2722 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset,
2723 rwco->qiov->size, rwco->qiov,
2724 rwco->flags);
2725 } else {
2726 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset,
2727 rwco->qiov->size, rwco->qiov,
2728 rwco->flags);
2733 * Process a vectored synchronous request using coroutines
2735 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset,
2736 QEMUIOVector *qiov, bool is_write,
2737 BdrvRequestFlags flags)
2739 Coroutine *co;
2740 RwCo rwco = {
2741 .bs = bs,
2742 .offset = offset,
2743 .qiov = qiov,
2744 .is_write = is_write,
2745 .ret = NOT_DONE,
2746 .flags = flags,
2750 * In sync call context, when the vcpu is blocked, this throttling timer
2751 * will not fire; so the I/O throttling function has to be disabled here
2752 * if it has been enabled.
2754 if (bs->io_limits_enabled) {
2755 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2756 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2757 bdrv_io_limits_disable(bs);
2760 if (qemu_in_coroutine()) {
2761 /* Fast-path if already in coroutine context */
2762 bdrv_rw_co_entry(&rwco);
2763 } else {
2764 AioContext *aio_context = bdrv_get_aio_context(bs);
2766 co = qemu_coroutine_create(bdrv_rw_co_entry);
2767 qemu_coroutine_enter(co, &rwco);
2768 while (rwco.ret == NOT_DONE) {
2769 aio_poll(aio_context, true);
2772 return rwco.ret;
2776 * Process a synchronous request using coroutines
2778 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
2779 int nb_sectors, bool is_write, BdrvRequestFlags flags)
2781 QEMUIOVector qiov;
2782 struct iovec iov = {
2783 .iov_base = (void *)buf,
2784 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
2787 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {
2788 return -EINVAL;
2791 qemu_iovec_init_external(&qiov, &iov, 1);
2792 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS,
2793 &qiov, is_write, flags);
2796 /* return < 0 if error. See bdrv_write() for the return codes */
2797 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2798 uint8_t *buf, int nb_sectors)
2800 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0);
2803 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2804 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2805 uint8_t *buf, int nb_sectors)
2807 bool enabled;
2808 int ret;
2810 enabled = bs->io_limits_enabled;
2811 bs->io_limits_enabled = false;
2812 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
2813 bs->io_limits_enabled = enabled;
2814 return ret;
2817 /* Return < 0 if error. Important errors are:
2818 -EIO generic I/O error (may happen for all errors)
2819 -ENOMEDIUM No media inserted.
2820 -EINVAL Invalid sector number or nb_sectors
2821 -EACCES Trying to write a read-only device
2823 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2824 const uint8_t *buf, int nb_sectors)
2826 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0);
2829 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num,
2830 int nb_sectors, BdrvRequestFlags flags)
2832 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true,
2833 BDRV_REQ_ZERO_WRITE | flags);
2837 * Completely zero out a block device with the help of bdrv_write_zeroes.
2838 * The operation is sped up by checking the block status and only writing
2839 * zeroes to the device if they currently do not return zeroes. Optional
2840 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP).
2842 * Returns < 0 on error, 0 on success. For error codes see bdrv_write().
2844 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags)
2846 int64_t target_sectors, ret, nb_sectors, sector_num = 0;
2847 int n;
2849 target_sectors = bdrv_nb_sectors(bs);
2850 if (target_sectors < 0) {
2851 return target_sectors;
2854 for (;;) {
2855 nb_sectors = target_sectors - sector_num;
2856 if (nb_sectors <= 0) {
2857 return 0;
2859 if (nb_sectors > INT_MAX) {
2860 nb_sectors = INT_MAX;
2862 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n);
2863 if (ret < 0) {
2864 error_report("error getting block status at sector %" PRId64 ": %s",
2865 sector_num, strerror(-ret));
2866 return ret;
2868 if (ret & BDRV_BLOCK_ZERO) {
2869 sector_num += n;
2870 continue;
2872 ret = bdrv_write_zeroes(bs, sector_num, n, flags);
2873 if (ret < 0) {
2874 error_report("error writing zeroes at sector %" PRId64 ": %s",
2875 sector_num, strerror(-ret));
2876 return ret;
2878 sector_num += n;
2882 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)
2884 QEMUIOVector qiov;
2885 struct iovec iov = {
2886 .iov_base = (void *)buf,
2887 .iov_len = bytes,
2889 int ret;
2891 if (bytes < 0) {
2892 return -EINVAL;
2895 qemu_iovec_init_external(&qiov, &iov, 1);
2896 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);
2897 if (ret < 0) {
2898 return ret;
2901 return bytes;
2904 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
2906 int ret;
2908 ret = bdrv_prwv_co(bs, offset, qiov, true, 0);
2909 if (ret < 0) {
2910 return ret;
2913 return qiov->size;
2916 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2917 const void *buf, int bytes)
2919 QEMUIOVector qiov;
2920 struct iovec iov = {
2921 .iov_base = (void *) buf,
2922 .iov_len = bytes,
2925 if (bytes < 0) {
2926 return -EINVAL;
2929 qemu_iovec_init_external(&qiov, &iov, 1);
2930 return bdrv_pwritev(bs, offset, &qiov);
2934 * Writes to the file and ensures that no writes are reordered across this
2935 * request (acts as a barrier)
2937 * Returns 0 on success, -errno in error cases.
2939 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2940 const void *buf, int count)
2942 int ret;
2944 ret = bdrv_pwrite(bs, offset, buf, count);
2945 if (ret < 0) {
2946 return ret;
2949 /* No flush needed for cache modes that already do it */
2950 if (bs->enable_write_cache) {
2951 bdrv_flush(bs);
2954 return 0;
2957 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2958 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2960 /* Perform I/O through a temporary buffer so that users who scribble over
2961 * their read buffer while the operation is in progress do not end up
2962 * modifying the image file. This is critical for zero-copy guest I/O
2963 * where anything might happen inside guest memory.
2965 void *bounce_buffer;
2967 BlockDriver *drv = bs->drv;
2968 struct iovec iov;
2969 QEMUIOVector bounce_qiov;
2970 int64_t cluster_sector_num;
2971 int cluster_nb_sectors;
2972 size_t skip_bytes;
2973 int ret;
2975 /* Cover entire cluster so no additional backing file I/O is required when
2976 * allocating cluster in the image file.
2978 bdrv_round_to_clusters(bs, sector_num, nb_sectors,
2979 &cluster_sector_num, &cluster_nb_sectors);
2981 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2982 cluster_sector_num, cluster_nb_sectors);
2984 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2985 iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);
2986 if (bounce_buffer == NULL) {
2987 ret = -ENOMEM;
2988 goto err;
2991 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2993 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2994 &bounce_qiov);
2995 if (ret < 0) {
2996 goto err;
2999 if (drv->bdrv_co_write_zeroes &&
3000 buffer_is_zero(bounce_buffer, iov.iov_len)) {
3001 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
3002 cluster_nb_sectors, 0);
3003 } else {
3004 /* This does not change the data on the disk, it is not necessary
3005 * to flush even in cache=writethrough mode.
3007 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
3008 &bounce_qiov);
3011 if (ret < 0) {
3012 /* It might be okay to ignore write errors for guest requests. If this
3013 * is a deliberate copy-on-read then we don't want to ignore the error.
3014 * Simply report it in all cases.
3016 goto err;
3019 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
3020 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
3021 nb_sectors * BDRV_SECTOR_SIZE);
3023 err:
3024 qemu_vfree(bounce_buffer);
3025 return ret;
3029 * Forwards an already correctly aligned request to the BlockDriver. This
3030 * handles copy on read and zeroing after EOF; any other features must be
3031 * implemented by the caller.
3033 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
3034 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3035 int64_t align, QEMUIOVector *qiov, int flags)
3037 BlockDriver *drv = bs->drv;
3038 int ret;
3040 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3041 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3043 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3044 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3045 assert(!qiov || bytes == qiov->size);
3047 /* Handle Copy on Read and associated serialisation */
3048 if (flags & BDRV_REQ_COPY_ON_READ) {
3049 /* If we touch the same cluster it counts as an overlap. This
3050 * guarantees that allocating writes will be serialized and not race
3051 * with each other for the same cluster. For example, in copy-on-read
3052 * it ensures that the CoR read and write operations are atomic and
3053 * guest writes cannot interleave between them. */
3054 mark_request_serialising(req, bdrv_get_cluster_size(bs));
3057 wait_serialising_requests(req);
3059 if (flags & BDRV_REQ_COPY_ON_READ) {
3060 int pnum;
3062 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);
3063 if (ret < 0) {
3064 goto out;
3067 if (!ret || pnum != nb_sectors) {
3068 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
3069 goto out;
3073 /* Forward the request to the BlockDriver */
3074 if (!(bs->zero_beyond_eof && bs->growable)) {
3075 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
3076 } else {
3077 /* Read zeros after EOF of growable BDSes */
3078 int64_t total_sectors, max_nb_sectors;
3080 total_sectors = bdrv_nb_sectors(bs);
3081 if (total_sectors < 0) {
3082 ret = total_sectors;
3083 goto out;
3086 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),
3087 align >> BDRV_SECTOR_BITS);
3088 if (max_nb_sectors > 0) {
3089 QEMUIOVector local_qiov;
3090 size_t local_sectors;
3092 max_nb_sectors = MIN(max_nb_sectors, SIZE_MAX / BDRV_SECTOR_BITS);
3093 local_sectors = MIN(max_nb_sectors, nb_sectors);
3095 qemu_iovec_init(&local_qiov, qiov->niov);
3096 qemu_iovec_concat(&local_qiov, qiov, 0,
3097 local_sectors * BDRV_SECTOR_SIZE);
3099 ret = drv->bdrv_co_readv(bs, sector_num, local_sectors,
3100 &local_qiov);
3102 qemu_iovec_destroy(&local_qiov);
3103 } else {
3104 ret = 0;
3107 /* Reading beyond end of file is supposed to produce zeroes */
3108 if (ret == 0 && total_sectors < sector_num + nb_sectors) {
3109 uint64_t offset = MAX(0, total_sectors - sector_num);
3110 uint64_t bytes = (sector_num + nb_sectors - offset) *
3111 BDRV_SECTOR_SIZE;
3112 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);
3116 out:
3117 return ret;
3121 * Handle a read request in coroutine context
3123 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs,
3124 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3125 BdrvRequestFlags flags)
3127 BlockDriver *drv = bs->drv;
3128 BdrvTrackedRequest req;
3130 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3131 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3132 uint8_t *head_buf = NULL;
3133 uint8_t *tail_buf = NULL;
3134 QEMUIOVector local_qiov;
3135 bool use_local_qiov = false;
3136 int ret;
3138 if (!drv) {
3139 return -ENOMEDIUM;
3141 if (bdrv_check_byte_request(bs, offset, bytes)) {
3142 return -EIO;
3145 if (bs->copy_on_read) {
3146 flags |= BDRV_REQ_COPY_ON_READ;
3149 /* throttling disk I/O */
3150 if (bs->io_limits_enabled) {
3151 bdrv_io_limits_intercept(bs, bytes, false);
3154 /* Align read if necessary by padding qiov */
3155 if (offset & (align - 1)) {
3156 head_buf = qemu_blockalign(bs, align);
3157 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3158 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3159 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3160 use_local_qiov = true;
3162 bytes += offset & (align - 1);
3163 offset = offset & ~(align - 1);
3166 if ((offset + bytes) & (align - 1)) {
3167 if (!use_local_qiov) {
3168 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3169 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3170 use_local_qiov = true;
3172 tail_buf = qemu_blockalign(bs, align);
3173 qemu_iovec_add(&local_qiov, tail_buf,
3174 align - ((offset + bytes) & (align - 1)));
3176 bytes = ROUND_UP(bytes, align);
3179 tracked_request_begin(&req, bs, offset, bytes, false);
3180 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align,
3181 use_local_qiov ? &local_qiov : qiov,
3182 flags);
3183 tracked_request_end(&req);
3185 if (use_local_qiov) {
3186 qemu_iovec_destroy(&local_qiov);
3187 qemu_vfree(head_buf);
3188 qemu_vfree(tail_buf);
3191 return ret;
3194 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
3195 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3196 BdrvRequestFlags flags)
3198 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) {
3199 return -EINVAL;
3202 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS,
3203 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3206 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
3207 int nb_sectors, QEMUIOVector *qiov)
3209 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
3211 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
3214 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
3215 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
3217 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
3219 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
3220 BDRV_REQ_COPY_ON_READ);
3223 /* if no limit is specified in the BlockLimits use a default
3224 * of 32768 512-byte sectors (16 MiB) per request.
3226 #define MAX_WRITE_ZEROES_DEFAULT 32768
3228 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
3229 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
3231 BlockDriver *drv = bs->drv;
3232 QEMUIOVector qiov;
3233 struct iovec iov = {0};
3234 int ret = 0;
3236 int max_write_zeroes = bs->bl.max_write_zeroes ?
3237 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT;
3239 while (nb_sectors > 0 && !ret) {
3240 int num = nb_sectors;
3242 /* Align request. Block drivers can expect the "bulk" of the request
3243 * to be aligned.
3245 if (bs->bl.write_zeroes_alignment
3246 && num > bs->bl.write_zeroes_alignment) {
3247 if (sector_num % bs->bl.write_zeroes_alignment != 0) {
3248 /* Make a small request up to the first aligned sector. */
3249 num = bs->bl.write_zeroes_alignment;
3250 num -= sector_num % bs->bl.write_zeroes_alignment;
3251 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) {
3252 /* Shorten the request to the last aligned sector. num cannot
3253 * underflow because num > bs->bl.write_zeroes_alignment.
3255 num -= (sector_num + num) % bs->bl.write_zeroes_alignment;
3259 /* limit request size */
3260 if (num > max_write_zeroes) {
3261 num = max_write_zeroes;
3264 ret = -ENOTSUP;
3265 /* First try the efficient write zeroes operation */
3266 if (drv->bdrv_co_write_zeroes) {
3267 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags);
3270 if (ret == -ENOTSUP) {
3271 /* Fall back to bounce buffer if write zeroes is unsupported */
3272 iov.iov_len = num * BDRV_SECTOR_SIZE;
3273 if (iov.iov_base == NULL) {
3274 iov.iov_base = qemu_try_blockalign(bs, num * BDRV_SECTOR_SIZE);
3275 if (iov.iov_base == NULL) {
3276 ret = -ENOMEM;
3277 goto fail;
3279 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE);
3281 qemu_iovec_init_external(&qiov, &iov, 1);
3283 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov);
3285 /* Keep bounce buffer around if it is big enough for all
3286 * all future requests.
3288 if (num < max_write_zeroes) {
3289 qemu_vfree(iov.iov_base);
3290 iov.iov_base = NULL;
3294 sector_num += num;
3295 nb_sectors -= num;
3298 fail:
3299 qemu_vfree(iov.iov_base);
3300 return ret;
3304 * Forwards an already correctly aligned write request to the BlockDriver.
3306 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
3307 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
3308 QEMUIOVector *qiov, int flags)
3310 BlockDriver *drv = bs->drv;
3311 bool waited;
3312 int ret;
3314 int64_t sector_num = offset >> BDRV_SECTOR_BITS;
3315 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;
3317 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
3318 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
3319 assert(!qiov || bytes == qiov->size);
3321 waited = wait_serialising_requests(req);
3322 assert(!waited || !req->serialising);
3323 assert(req->overlap_offset <= offset);
3324 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
3326 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req);
3328 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
3329 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes &&
3330 qemu_iovec_is_zero(qiov)) {
3331 flags |= BDRV_REQ_ZERO_WRITE;
3332 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
3333 flags |= BDRV_REQ_MAY_UNMAP;
3337 if (ret < 0) {
3338 /* Do nothing, write notifier decided to fail this request */
3339 } else if (flags & BDRV_REQ_ZERO_WRITE) {
3340 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO);
3341 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags);
3342 } else {
3343 BLKDBG_EVENT(bs, BLKDBG_PWRITEV);
3344 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
3346 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE);
3348 if (ret == 0 && !bs->enable_write_cache) {
3349 ret = bdrv_co_flush(bs);
3352 bdrv_set_dirty(bs, sector_num, nb_sectors);
3354 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
3355 bs->wr_highest_sector = sector_num + nb_sectors - 1;
3357 if (bs->growable && ret >= 0) {
3358 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);
3361 return ret;
3365 * Handle a write request in coroutine context
3367 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs,
3368 int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
3369 BdrvRequestFlags flags)
3371 BdrvTrackedRequest req;
3372 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */
3373 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);
3374 uint8_t *head_buf = NULL;
3375 uint8_t *tail_buf = NULL;
3376 QEMUIOVector local_qiov;
3377 bool use_local_qiov = false;
3378 int ret;
3380 if (!bs->drv) {
3381 return -ENOMEDIUM;
3383 if (bs->read_only) {
3384 return -EACCES;
3386 if (bdrv_check_byte_request(bs, offset, bytes)) {
3387 return -EIO;
3390 /* throttling disk I/O */
3391 if (bs->io_limits_enabled) {
3392 bdrv_io_limits_intercept(bs, bytes, true);
3396 * Align write if necessary by performing a read-modify-write cycle.
3397 * Pad qiov with the read parts and be sure to have a tracked request not
3398 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle.
3400 tracked_request_begin(&req, bs, offset, bytes, true);
3402 if (offset & (align - 1)) {
3403 QEMUIOVector head_qiov;
3404 struct iovec head_iov;
3406 mark_request_serialising(&req, align);
3407 wait_serialising_requests(&req);
3409 head_buf = qemu_blockalign(bs, align);
3410 head_iov = (struct iovec) {
3411 .iov_base = head_buf,
3412 .iov_len = align,
3414 qemu_iovec_init_external(&head_qiov, &head_iov, 1);
3416 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD);
3417 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align,
3418 align, &head_qiov, 0);
3419 if (ret < 0) {
3420 goto fail;
3422 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
3424 qemu_iovec_init(&local_qiov, qiov->niov + 2);
3425 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
3426 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3427 use_local_qiov = true;
3429 bytes += offset & (align - 1);
3430 offset = offset & ~(align - 1);
3433 if ((offset + bytes) & (align - 1)) {
3434 QEMUIOVector tail_qiov;
3435 struct iovec tail_iov;
3436 size_t tail_bytes;
3437 bool waited;
3439 mark_request_serialising(&req, align);
3440 waited = wait_serialising_requests(&req);
3441 assert(!waited || !use_local_qiov);
3443 tail_buf = qemu_blockalign(bs, align);
3444 tail_iov = (struct iovec) {
3445 .iov_base = tail_buf,
3446 .iov_len = align,
3448 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
3450 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL);
3451 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align,
3452 align, &tail_qiov, 0);
3453 if (ret < 0) {
3454 goto fail;
3456 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
3458 if (!use_local_qiov) {
3459 qemu_iovec_init(&local_qiov, qiov->niov + 1);
3460 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
3461 use_local_qiov = true;
3464 tail_bytes = (offset + bytes) & (align - 1);
3465 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
3467 bytes = ROUND_UP(bytes, align);
3470 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes,
3471 use_local_qiov ? &local_qiov : qiov,
3472 flags);
3474 fail:
3475 tracked_request_end(&req);
3477 if (use_local_qiov) {
3478 qemu_iovec_destroy(&local_qiov);
3480 qemu_vfree(head_buf);
3481 qemu_vfree(tail_buf);
3483 return ret;
3486 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
3487 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
3488 BdrvRequestFlags flags)
3490 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) {
3491 return -EINVAL;
3494 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS,
3495 nb_sectors << BDRV_SECTOR_BITS, qiov, flags);
3498 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
3499 int nb_sectors, QEMUIOVector *qiov)
3501 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
3503 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
3506 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
3507 int64_t sector_num, int nb_sectors,
3508 BdrvRequestFlags flags)
3510 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags);
3512 if (!(bs->open_flags & BDRV_O_UNMAP)) {
3513 flags &= ~BDRV_REQ_MAY_UNMAP;
3516 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
3517 BDRV_REQ_ZERO_WRITE | flags);
3521 * Truncate file to 'offset' bytes (needed only for file protocols)
3523 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
3525 BlockDriver *drv = bs->drv;
3526 int ret;
3527 if (!drv)
3528 return -ENOMEDIUM;
3529 if (!drv->bdrv_truncate)
3530 return -ENOTSUP;
3531 if (bs->read_only)
3532 return -EACCES;
3534 ret = drv->bdrv_truncate(bs, offset);
3535 if (ret == 0) {
3536 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
3537 bdrv_dev_resize_cb(bs);
3539 return ret;
3543 * Length of a allocated file in bytes. Sparse files are counted by actual
3544 * allocated space. Return < 0 if error or unknown.
3546 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
3548 BlockDriver *drv = bs->drv;
3549 if (!drv) {
3550 return -ENOMEDIUM;
3552 if (drv->bdrv_get_allocated_file_size) {
3553 return drv->bdrv_get_allocated_file_size(bs);
3555 if (bs->file) {
3556 return bdrv_get_allocated_file_size(bs->file);
3558 return -ENOTSUP;
3562 * Return number of sectors on success, -errno on error.
3564 int64_t bdrv_nb_sectors(BlockDriverState *bs)
3566 BlockDriver *drv = bs->drv;
3568 if (!drv)
3569 return -ENOMEDIUM;
3571 if (drv->has_variable_length) {
3572 int ret = refresh_total_sectors(bs, bs->total_sectors);
3573 if (ret < 0) {
3574 return ret;
3577 return bs->total_sectors;
3581 * Return length in bytes on success, -errno on error.
3582 * The length is always a multiple of BDRV_SECTOR_SIZE.
3584 int64_t bdrv_getlength(BlockDriverState *bs)
3586 int64_t ret = bdrv_nb_sectors(bs);
3588 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;
3591 /* return 0 as number of sectors if no device present or error */
3592 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
3594 int64_t nb_sectors = bdrv_nb_sectors(bs);
3596 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
3599 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
3600 BlockdevOnError on_write_error)
3602 bs->on_read_error = on_read_error;
3603 bs->on_write_error = on_write_error;
3606 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
3608 return is_read ? bs->on_read_error : bs->on_write_error;
3611 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
3613 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
3615 switch (on_err) {
3616 case BLOCKDEV_ON_ERROR_ENOSPC:
3617 return (error == ENOSPC) ?
3618 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
3619 case BLOCKDEV_ON_ERROR_STOP:
3620 return BLOCK_ERROR_ACTION_STOP;
3621 case BLOCKDEV_ON_ERROR_REPORT:
3622 return BLOCK_ERROR_ACTION_REPORT;
3623 case BLOCKDEV_ON_ERROR_IGNORE:
3624 return BLOCK_ERROR_ACTION_IGNORE;
3625 default:
3626 abort();
3630 /* This is done by device models because, while the block layer knows
3631 * about the error, it does not know whether an operation comes from
3632 * the device or the block layer (from a job, for example).
3634 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
3635 bool is_read, int error)
3637 assert(error >= 0);
3639 if (action == BLOCK_ERROR_ACTION_STOP) {
3640 /* First set the iostatus, so that "info block" returns an iostatus
3641 * that matches the events raised so far (an additional error iostatus
3642 * is fine, but not a lost one).
3644 bdrv_iostatus_set_err(bs, error);
3646 /* Then raise the request to stop the VM and the event.
3647 * qemu_system_vmstop_request_prepare has two effects. First,
3648 * it ensures that the STOP event always comes after the
3649 * BLOCK_IO_ERROR event. Second, it ensures that even if management
3650 * can observe the STOP event and do a "cont" before the STOP
3651 * event is issued, the VM will not stop. In this case, vm_start()
3652 * also ensures that the STOP/RESUME pair of events is emitted.
3654 qemu_system_vmstop_request_prepare();
3655 qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3656 is_read ? IO_OPERATION_TYPE_READ :
3657 IO_OPERATION_TYPE_WRITE,
3658 action, &error_abort);
3659 qemu_system_vmstop_request(RUN_STATE_IO_ERROR);
3660 } else {
3661 qapi_event_send_block_io_error(bdrv_get_device_name(bs),
3662 is_read ? IO_OPERATION_TYPE_READ :
3663 IO_OPERATION_TYPE_WRITE,
3664 action, &error_abort);
3668 int bdrv_is_read_only(BlockDriverState *bs)
3670 return bs->read_only;
3673 int bdrv_is_sg(BlockDriverState *bs)
3675 return bs->sg;
3678 int bdrv_enable_write_cache(BlockDriverState *bs)
3680 return bs->enable_write_cache;
3683 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
3685 bs->enable_write_cache = wce;
3687 /* so a reopen() will preserve wce */
3688 if (wce) {
3689 bs->open_flags |= BDRV_O_CACHE_WB;
3690 } else {
3691 bs->open_flags &= ~BDRV_O_CACHE_WB;
3695 int bdrv_is_encrypted(BlockDriverState *bs)
3697 if (bs->backing_hd && bs->backing_hd->encrypted)
3698 return 1;
3699 return bs->encrypted;
3702 int bdrv_key_required(BlockDriverState *bs)
3704 BlockDriverState *backing_hd = bs->backing_hd;
3706 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
3707 return 1;
3708 return (bs->encrypted && !bs->valid_key);
3711 int bdrv_set_key(BlockDriverState *bs, const char *key)
3713 int ret;
3714 if (bs->backing_hd && bs->backing_hd->encrypted) {
3715 ret = bdrv_set_key(bs->backing_hd, key);
3716 if (ret < 0)
3717 return ret;
3718 if (!bs->encrypted)
3719 return 0;
3721 if (!bs->encrypted) {
3722 return -EINVAL;
3723 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
3724 return -ENOMEDIUM;
3726 ret = bs->drv->bdrv_set_key(bs, key);
3727 if (ret < 0) {
3728 bs->valid_key = 0;
3729 } else if (!bs->valid_key) {
3730 bs->valid_key = 1;
3731 /* call the change callback now, we skipped it on open */
3732 bdrv_dev_change_media_cb(bs, true);
3734 return ret;
3737 const char *bdrv_get_format_name(BlockDriverState *bs)
3739 return bs->drv ? bs->drv->format_name : NULL;
3742 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
3743 void *opaque)
3745 BlockDriver *drv;
3746 int count = 0;
3747 const char **formats = NULL;
3749 QLIST_FOREACH(drv, &bdrv_drivers, list) {
3750 if (drv->format_name) {
3751 bool found = false;
3752 int i = count;
3753 while (formats && i && !found) {
3754 found = !strcmp(formats[--i], drv->format_name);
3757 if (!found) {
3758 formats = g_realloc(formats, (count + 1) * sizeof(char *));
3759 formats[count++] = drv->format_name;
3760 it(opaque, drv->format_name);
3764 g_free(formats);
3767 /* This function is to find block backend bs */
3768 BlockDriverState *bdrv_find(const char *name)
3770 BlockDriverState *bs;
3772 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3773 if (!strcmp(name, bs->device_name)) {
3774 return bs;
3777 return NULL;
3780 /* This function is to find a node in the bs graph */
3781 BlockDriverState *bdrv_find_node(const char *node_name)
3783 BlockDriverState *bs;
3785 assert(node_name);
3787 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3788 if (!strcmp(node_name, bs->node_name)) {
3789 return bs;
3792 return NULL;
3795 /* Put this QMP function here so it can access the static graph_bdrv_states. */
3796 BlockDeviceInfoList *bdrv_named_nodes_list(void)
3798 BlockDeviceInfoList *list, *entry;
3799 BlockDriverState *bs;
3801 list = NULL;
3802 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
3803 entry = g_malloc0(sizeof(*entry));
3804 entry->value = bdrv_block_device_info(bs);
3805 entry->next = list;
3806 list = entry;
3809 return list;
3812 BlockDriverState *bdrv_lookup_bs(const char *device,
3813 const char *node_name,
3814 Error **errp)
3816 BlockDriverState *bs = NULL;
3818 if (device) {
3819 bs = bdrv_find(device);
3821 if (bs) {
3822 return bs;
3826 if (node_name) {
3827 bs = bdrv_find_node(node_name);
3829 if (bs) {
3830 return bs;
3834 error_setg(errp, "Cannot find device=%s nor node_name=%s",
3835 device ? device : "",
3836 node_name ? node_name : "");
3837 return NULL;
3840 /* If 'base' is in the same chain as 'top', return true. Otherwise,
3841 * return false. If either argument is NULL, return false. */
3842 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base)
3844 while (top && top != base) {
3845 top = top->backing_hd;
3848 return top != NULL;
3851 BlockDriverState *bdrv_next(BlockDriverState *bs)
3853 if (!bs) {
3854 return QTAILQ_FIRST(&bdrv_states);
3856 return QTAILQ_NEXT(bs, device_list);
3859 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
3861 BlockDriverState *bs;
3863 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3864 it(opaque, bs);
3868 const char *bdrv_get_device_name(BlockDriverState *bs)
3870 return bs->device_name;
3873 int bdrv_get_flags(BlockDriverState *bs)
3875 return bs->open_flags;
3878 int bdrv_flush_all(void)
3880 BlockDriverState *bs;
3881 int result = 0;
3883 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
3884 AioContext *aio_context = bdrv_get_aio_context(bs);
3885 int ret;
3887 aio_context_acquire(aio_context);
3888 ret = bdrv_flush(bs);
3889 if (ret < 0 && !result) {
3890 result = ret;
3892 aio_context_release(aio_context);
3895 return result;
3898 int bdrv_has_zero_init_1(BlockDriverState *bs)
3900 return 1;
3903 int bdrv_has_zero_init(BlockDriverState *bs)
3905 assert(bs->drv);
3907 /* If BS is a copy on write image, it is initialized to
3908 the contents of the base image, which may not be zeroes. */
3909 if (bs->backing_hd) {
3910 return 0;
3912 if (bs->drv->bdrv_has_zero_init) {
3913 return bs->drv->bdrv_has_zero_init(bs);
3916 /* safe default */
3917 return 0;
3920 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
3922 BlockDriverInfo bdi;
3924 if (bs->backing_hd) {
3925 return false;
3928 if (bdrv_get_info(bs, &bdi) == 0) {
3929 return bdi.unallocated_blocks_are_zero;
3932 return false;
3935 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs)
3937 BlockDriverInfo bdi;
3939 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) {
3940 return false;
3943 if (bdrv_get_info(bs, &bdi) == 0) {
3944 return bdi.can_write_zeroes_with_unmap;
3947 return false;
3950 typedef struct BdrvCoGetBlockStatusData {
3951 BlockDriverState *bs;
3952 BlockDriverState *base;
3953 int64_t sector_num;
3954 int nb_sectors;
3955 int *pnum;
3956 int64_t ret;
3957 bool done;
3958 } BdrvCoGetBlockStatusData;
3961 * Returns true iff the specified sector is present in the disk image. Drivers
3962 * not implementing the functionality are assumed to not support backing files,
3963 * hence all their sectors are reported as allocated.
3965 * If 'sector_num' is beyond the end of the disk image the return value is 0
3966 * and 'pnum' is set to 0.
3968 * 'pnum' is set to the number of sectors (including and immediately following
3969 * the specified sector) that are known to be in the same
3970 * allocated/unallocated state.
3972 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
3973 * beyond the end of the disk image it will be clamped.
3975 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
3976 int64_t sector_num,
3977 int nb_sectors, int *pnum)
3979 int64_t total_sectors;
3980 int64_t n;
3981 int64_t ret, ret2;
3983 total_sectors = bdrv_nb_sectors(bs);
3984 if (total_sectors < 0) {
3985 return total_sectors;
3988 if (sector_num >= total_sectors) {
3989 *pnum = 0;
3990 return 0;
3993 n = total_sectors - sector_num;
3994 if (n < nb_sectors) {
3995 nb_sectors = n;
3998 if (!bs->drv->bdrv_co_get_block_status) {
3999 *pnum = nb_sectors;
4000 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED;
4001 if (bs->drv->protocol_name) {
4002 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE);
4004 return ret;
4007 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum);
4008 if (ret < 0) {
4009 *pnum = 0;
4010 return ret;
4013 if (ret & BDRV_BLOCK_RAW) {
4014 assert(ret & BDRV_BLOCK_OFFSET_VALID);
4015 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4016 *pnum, pnum);
4019 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) {
4020 ret |= BDRV_BLOCK_ALLOCATED;
4023 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) {
4024 if (bdrv_unallocated_blocks_are_zero(bs)) {
4025 ret |= BDRV_BLOCK_ZERO;
4026 } else if (bs->backing_hd) {
4027 BlockDriverState *bs2 = bs->backing_hd;
4028 int64_t nb_sectors2 = bdrv_nb_sectors(bs2);
4029 if (nb_sectors2 >= 0 && sector_num >= nb_sectors2) {
4030 ret |= BDRV_BLOCK_ZERO;
4035 if (bs->file &&
4036 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) &&
4037 (ret & BDRV_BLOCK_OFFSET_VALID)) {
4038 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS,
4039 *pnum, pnum);
4040 if (ret2 >= 0) {
4041 /* Ignore errors. This is just providing extra information, it
4042 * is useful but not necessary.
4044 ret |= (ret2 & BDRV_BLOCK_ZERO);
4048 return ret;
4051 /* Coroutine wrapper for bdrv_get_block_status() */
4052 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque)
4054 BdrvCoGetBlockStatusData *data = opaque;
4055 BlockDriverState *bs = data->bs;
4057 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors,
4058 data->pnum);
4059 data->done = true;
4063 * Synchronous wrapper around bdrv_co_get_block_status().
4065 * See bdrv_co_get_block_status() for details.
4067 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num,
4068 int nb_sectors, int *pnum)
4070 Coroutine *co;
4071 BdrvCoGetBlockStatusData data = {
4072 .bs = bs,
4073 .sector_num = sector_num,
4074 .nb_sectors = nb_sectors,
4075 .pnum = pnum,
4076 .done = false,
4079 if (qemu_in_coroutine()) {
4080 /* Fast-path if already in coroutine context */
4081 bdrv_get_block_status_co_entry(&data);
4082 } else {
4083 AioContext *aio_context = bdrv_get_aio_context(bs);
4085 co = qemu_coroutine_create(bdrv_get_block_status_co_entry);
4086 qemu_coroutine_enter(co, &data);
4087 while (!data.done) {
4088 aio_poll(aio_context, true);
4091 return data.ret;
4094 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num,
4095 int nb_sectors, int *pnum)
4097 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum);
4098 if (ret < 0) {
4099 return ret;
4101 return !!(ret & BDRV_BLOCK_ALLOCATED);
4105 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
4107 * Return true if the given sector is allocated in any image between
4108 * BASE and TOP (inclusive). BASE can be NULL to check if the given
4109 * sector is allocated in any image of the chain. Return false otherwise.
4111 * 'pnum' is set to the number of sectors (including and immediately following
4112 * the specified sector) that are known to be in the same
4113 * allocated/unallocated state.
4116 int bdrv_is_allocated_above(BlockDriverState *top,
4117 BlockDriverState *base,
4118 int64_t sector_num,
4119 int nb_sectors, int *pnum)
4121 BlockDriverState *intermediate;
4122 int ret, n = nb_sectors;
4124 intermediate = top;
4125 while (intermediate && intermediate != base) {
4126 int pnum_inter;
4127 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors,
4128 &pnum_inter);
4129 if (ret < 0) {
4130 return ret;
4131 } else if (ret) {
4132 *pnum = pnum_inter;
4133 return 1;
4137 * [sector_num, nb_sectors] is unallocated on top but intermediate
4138 * might have
4140 * [sector_num+x, nr_sectors] allocated.
4142 if (n > pnum_inter &&
4143 (intermediate == top ||
4144 sector_num + pnum_inter < intermediate->total_sectors)) {
4145 n = pnum_inter;
4148 intermediate = intermediate->backing_hd;
4151 *pnum = n;
4152 return 0;
4155 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
4157 if (bs->backing_hd && bs->backing_hd->encrypted)
4158 return bs->backing_file;
4159 else if (bs->encrypted)
4160 return bs->filename;
4161 else
4162 return NULL;
4165 void bdrv_get_backing_filename(BlockDriverState *bs,
4166 char *filename, int filename_size)
4168 pstrcpy(filename, filename_size, bs->backing_file);
4171 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
4172 const uint8_t *buf, int nb_sectors)
4174 BlockDriver *drv = bs->drv;
4175 if (!drv)
4176 return -ENOMEDIUM;
4177 if (!drv->bdrv_write_compressed)
4178 return -ENOTSUP;
4179 if (bdrv_check_request(bs, sector_num, nb_sectors))
4180 return -EIO;
4182 assert(QLIST_EMPTY(&bs->dirty_bitmaps));
4184 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
4187 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
4189 BlockDriver *drv = bs->drv;
4190 if (!drv)
4191 return -ENOMEDIUM;
4192 if (!drv->bdrv_get_info)
4193 return -ENOTSUP;
4194 memset(bdi, 0, sizeof(*bdi));
4195 return drv->bdrv_get_info(bs, bdi);
4198 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs)
4200 BlockDriver *drv = bs->drv;
4201 if (drv && drv->bdrv_get_specific_info) {
4202 return drv->bdrv_get_specific_info(bs);
4204 return NULL;
4207 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
4208 int64_t pos, int size)
4210 QEMUIOVector qiov;
4211 struct iovec iov = {
4212 .iov_base = (void *) buf,
4213 .iov_len = size,
4216 qemu_iovec_init_external(&qiov, &iov, 1);
4217 return bdrv_writev_vmstate(bs, &qiov, pos);
4220 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
4222 BlockDriver *drv = bs->drv;
4224 if (!drv) {
4225 return -ENOMEDIUM;
4226 } else if (drv->bdrv_save_vmstate) {
4227 return drv->bdrv_save_vmstate(bs, qiov, pos);
4228 } else if (bs->file) {
4229 return bdrv_writev_vmstate(bs->file, qiov, pos);
4232 return -ENOTSUP;
4235 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
4236 int64_t pos, int size)
4238 BlockDriver *drv = bs->drv;
4239 if (!drv)
4240 return -ENOMEDIUM;
4241 if (drv->bdrv_load_vmstate)
4242 return drv->bdrv_load_vmstate(bs, buf, pos, size);
4243 if (bs->file)
4244 return bdrv_load_vmstate(bs->file, buf, pos, size);
4245 return -ENOTSUP;
4248 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
4250 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) {
4251 return;
4254 bs->drv->bdrv_debug_event(bs, event);
4257 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
4258 const char *tag)
4260 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
4261 bs = bs->file;
4264 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
4265 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
4268 return -ENOTSUP;
4271 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)
4273 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) {
4274 bs = bs->file;
4277 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) {
4278 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag);
4281 return -ENOTSUP;
4284 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
4286 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) {
4287 bs = bs->file;
4290 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
4291 return bs->drv->bdrv_debug_resume(bs, tag);
4294 return -ENOTSUP;
4297 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
4299 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
4300 bs = bs->file;
4303 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
4304 return bs->drv->bdrv_debug_is_suspended(bs, tag);
4307 return false;
4310 int bdrv_is_snapshot(BlockDriverState *bs)
4312 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
4315 /* backing_file can either be relative, or absolute, or a protocol. If it is
4316 * relative, it must be relative to the chain. So, passing in bs->filename
4317 * from a BDS as backing_file should not be done, as that may be relative to
4318 * the CWD rather than the chain. */
4319 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
4320 const char *backing_file)
4322 char *filename_full = NULL;
4323 char *backing_file_full = NULL;
4324 char *filename_tmp = NULL;
4325 int is_protocol = 0;
4326 BlockDriverState *curr_bs = NULL;
4327 BlockDriverState *retval = NULL;
4329 if (!bs || !bs->drv || !backing_file) {
4330 return NULL;
4333 filename_full = g_malloc(PATH_MAX);
4334 backing_file_full = g_malloc(PATH_MAX);
4335 filename_tmp = g_malloc(PATH_MAX);
4337 is_protocol = path_has_protocol(backing_file);
4339 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
4341 /* If either of the filename paths is actually a protocol, then
4342 * compare unmodified paths; otherwise make paths relative */
4343 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
4344 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
4345 retval = curr_bs->backing_hd;
4346 break;
4348 } else {
4349 /* If not an absolute filename path, make it relative to the current
4350 * image's filename path */
4351 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4352 backing_file);
4354 /* We are going to compare absolute pathnames */
4355 if (!realpath(filename_tmp, filename_full)) {
4356 continue;
4359 /* We need to make sure the backing filename we are comparing against
4360 * is relative to the current image filename (or absolute) */
4361 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
4362 curr_bs->backing_file);
4364 if (!realpath(filename_tmp, backing_file_full)) {
4365 continue;
4368 if (strcmp(backing_file_full, filename_full) == 0) {
4369 retval = curr_bs->backing_hd;
4370 break;
4375 g_free(filename_full);
4376 g_free(backing_file_full);
4377 g_free(filename_tmp);
4378 return retval;
4381 int bdrv_get_backing_file_depth(BlockDriverState *bs)
4383 if (!bs->drv) {
4384 return 0;
4387 if (!bs->backing_hd) {
4388 return 0;
4391 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
4394 /**************************************************************/
4395 /* async I/Os */
4397 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
4398 QEMUIOVector *qiov, int nb_sectors,
4399 BlockDriverCompletionFunc *cb, void *opaque)
4401 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
4403 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4404 cb, opaque, false);
4407 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
4408 QEMUIOVector *qiov, int nb_sectors,
4409 BlockDriverCompletionFunc *cb, void *opaque)
4411 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
4413 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
4414 cb, opaque, true);
4417 BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
4418 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags,
4419 BlockDriverCompletionFunc *cb, void *opaque)
4421 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque);
4423 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
4424 BDRV_REQ_ZERO_WRITE | flags,
4425 cb, opaque, true);
4429 typedef struct MultiwriteCB {
4430 int error;
4431 int num_requests;
4432 int num_callbacks;
4433 struct {
4434 BlockDriverCompletionFunc *cb;
4435 void *opaque;
4436 QEMUIOVector *free_qiov;
4437 } callbacks[];
4438 } MultiwriteCB;
4440 static void multiwrite_user_cb(MultiwriteCB *mcb)
4442 int i;
4444 for (i = 0; i < mcb->num_callbacks; i++) {
4445 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
4446 if (mcb->callbacks[i].free_qiov) {
4447 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
4449 g_free(mcb->callbacks[i].free_qiov);
4453 static void multiwrite_cb(void *opaque, int ret)
4455 MultiwriteCB *mcb = opaque;
4457 trace_multiwrite_cb(mcb, ret);
4459 if (ret < 0 && !mcb->error) {
4460 mcb->error = ret;
4463 mcb->num_requests--;
4464 if (mcb->num_requests == 0) {
4465 multiwrite_user_cb(mcb);
4466 g_free(mcb);
4470 static int multiwrite_req_compare(const void *a, const void *b)
4472 const BlockRequest *req1 = a, *req2 = b;
4475 * Note that we can't simply subtract req2->sector from req1->sector
4476 * here as that could overflow the return value.
4478 if (req1->sector > req2->sector) {
4479 return 1;
4480 } else if (req1->sector < req2->sector) {
4481 return -1;
4482 } else {
4483 return 0;
4488 * Takes a bunch of requests and tries to merge them. Returns the number of
4489 * requests that remain after merging.
4491 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
4492 int num_reqs, MultiwriteCB *mcb)
4494 int i, outidx;
4496 // Sort requests by start sector
4497 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
4499 // Check if adjacent requests touch the same clusters. If so, combine them,
4500 // filling up gaps with zero sectors.
4501 outidx = 0;
4502 for (i = 1; i < num_reqs; i++) {
4503 int merge = 0;
4504 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
4506 // Handle exactly sequential writes and overlapping writes.
4507 if (reqs[i].sector <= oldreq_last) {
4508 merge = 1;
4511 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
4512 merge = 0;
4515 if (merge) {
4516 size_t size;
4517 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
4518 qemu_iovec_init(qiov,
4519 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
4521 // Add the first request to the merged one. If the requests are
4522 // overlapping, drop the last sectors of the first request.
4523 size = (reqs[i].sector - reqs[outidx].sector) << 9;
4524 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
4526 // We should need to add any zeros between the two requests
4527 assert (reqs[i].sector <= oldreq_last);
4529 // Add the second request
4530 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
4532 reqs[outidx].nb_sectors = qiov->size >> 9;
4533 reqs[outidx].qiov = qiov;
4535 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
4536 } else {
4537 outidx++;
4538 reqs[outidx].sector = reqs[i].sector;
4539 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
4540 reqs[outidx].qiov = reqs[i].qiov;
4544 return outidx + 1;
4548 * Submit multiple AIO write requests at once.
4550 * On success, the function returns 0 and all requests in the reqs array have
4551 * been submitted. In error case this function returns -1, and any of the
4552 * requests may or may not be submitted yet. In particular, this means that the
4553 * callback will be called for some of the requests, for others it won't. The
4554 * caller must check the error field of the BlockRequest to wait for the right
4555 * callbacks (if error != 0, no callback will be called).
4557 * The implementation may modify the contents of the reqs array, e.g. to merge
4558 * requests. However, the fields opaque and error are left unmodified as they
4559 * are used to signal failure for a single request to the caller.
4561 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
4563 MultiwriteCB *mcb;
4564 int i;
4566 /* don't submit writes if we don't have a medium */
4567 if (bs->drv == NULL) {
4568 for (i = 0; i < num_reqs; i++) {
4569 reqs[i].error = -ENOMEDIUM;
4571 return -1;
4574 if (num_reqs == 0) {
4575 return 0;
4578 // Create MultiwriteCB structure
4579 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
4580 mcb->num_requests = 0;
4581 mcb->num_callbacks = num_reqs;
4583 for (i = 0; i < num_reqs; i++) {
4584 mcb->callbacks[i].cb = reqs[i].cb;
4585 mcb->callbacks[i].opaque = reqs[i].opaque;
4588 // Check for mergable requests
4589 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
4591 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
4593 /* Run the aio requests. */
4594 mcb->num_requests = num_reqs;
4595 for (i = 0; i < num_reqs; i++) {
4596 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
4597 reqs[i].nb_sectors, reqs[i].flags,
4598 multiwrite_cb, mcb,
4599 true);
4602 return 0;
4605 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
4607 acb->aiocb_info->cancel(acb);
4610 /**************************************************************/
4611 /* async block device emulation */
4613 typedef struct BlockDriverAIOCBSync {
4614 BlockDriverAIOCB common;
4615 QEMUBH *bh;
4616 int ret;
4617 /* vector translation state */
4618 QEMUIOVector *qiov;
4619 uint8_t *bounce;
4620 int is_write;
4621 } BlockDriverAIOCBSync;
4623 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
4625 BlockDriverAIOCBSync *acb =
4626 container_of(blockacb, BlockDriverAIOCBSync, common);
4627 qemu_bh_delete(acb->bh);
4628 acb->bh = NULL;
4629 qemu_aio_release(acb);
4632 static const AIOCBInfo bdrv_em_aiocb_info = {
4633 .aiocb_size = sizeof(BlockDriverAIOCBSync),
4634 .cancel = bdrv_aio_cancel_em,
4637 static void bdrv_aio_bh_cb(void *opaque)
4639 BlockDriverAIOCBSync *acb = opaque;
4641 if (!acb->is_write && acb->ret >= 0) {
4642 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
4644 qemu_vfree(acb->bounce);
4645 acb->common.cb(acb->common.opaque, acb->ret);
4646 qemu_bh_delete(acb->bh);
4647 acb->bh = NULL;
4648 qemu_aio_release(acb);
4651 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
4652 int64_t sector_num,
4653 QEMUIOVector *qiov,
4654 int nb_sectors,
4655 BlockDriverCompletionFunc *cb,
4656 void *opaque,
4657 int is_write)
4660 BlockDriverAIOCBSync *acb;
4662 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
4663 acb->is_write = is_write;
4664 acb->qiov = qiov;
4665 acb->bounce = qemu_try_blockalign(bs, qiov->size);
4666 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb);
4668 if (acb->bounce == NULL) {
4669 acb->ret = -ENOMEM;
4670 } else if (is_write) {
4671 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
4672 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
4673 } else {
4674 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
4677 qemu_bh_schedule(acb->bh);
4679 return &acb->common;
4682 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
4683 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4684 BlockDriverCompletionFunc *cb, void *opaque)
4686 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
4689 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
4690 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
4691 BlockDriverCompletionFunc *cb, void *opaque)
4693 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
4697 typedef struct BlockDriverAIOCBCoroutine {
4698 BlockDriverAIOCB common;
4699 BlockRequest req;
4700 bool is_write;
4701 bool *done;
4702 QEMUBH* bh;
4703 } BlockDriverAIOCBCoroutine;
4705 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
4707 AioContext *aio_context = bdrv_get_aio_context(blockacb->bs);
4708 BlockDriverAIOCBCoroutine *acb =
4709 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
4710 bool done = false;
4712 acb->done = &done;
4713 while (!done) {
4714 aio_poll(aio_context, true);
4718 static const AIOCBInfo bdrv_em_co_aiocb_info = {
4719 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
4720 .cancel = bdrv_aio_co_cancel_em,
4723 static void bdrv_co_em_bh(void *opaque)
4725 BlockDriverAIOCBCoroutine *acb = opaque;
4727 acb->common.cb(acb->common.opaque, acb->req.error);
4729 if (acb->done) {
4730 *acb->done = true;
4733 qemu_bh_delete(acb->bh);
4734 qemu_aio_release(acb);
4737 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
4738 static void coroutine_fn bdrv_co_do_rw(void *opaque)
4740 BlockDriverAIOCBCoroutine *acb = opaque;
4741 BlockDriverState *bs = acb->common.bs;
4743 if (!acb->is_write) {
4744 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
4745 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4746 } else {
4747 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
4748 acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
4751 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4752 qemu_bh_schedule(acb->bh);
4755 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
4756 int64_t sector_num,
4757 QEMUIOVector *qiov,
4758 int nb_sectors,
4759 BdrvRequestFlags flags,
4760 BlockDriverCompletionFunc *cb,
4761 void *opaque,
4762 bool is_write)
4764 Coroutine *co;
4765 BlockDriverAIOCBCoroutine *acb;
4767 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4768 acb->req.sector = sector_num;
4769 acb->req.nb_sectors = nb_sectors;
4770 acb->req.qiov = qiov;
4771 acb->req.flags = flags;
4772 acb->is_write = is_write;
4773 acb->done = NULL;
4775 co = qemu_coroutine_create(bdrv_co_do_rw);
4776 qemu_coroutine_enter(co, acb);
4778 return &acb->common;
4781 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
4783 BlockDriverAIOCBCoroutine *acb = opaque;
4784 BlockDriverState *bs = acb->common.bs;
4786 acb->req.error = bdrv_co_flush(bs);
4787 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4788 qemu_bh_schedule(acb->bh);
4791 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
4792 BlockDriverCompletionFunc *cb, void *opaque)
4794 trace_bdrv_aio_flush(bs, opaque);
4796 Coroutine *co;
4797 BlockDriverAIOCBCoroutine *acb;
4799 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4800 acb->done = NULL;
4802 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
4803 qemu_coroutine_enter(co, acb);
4805 return &acb->common;
4808 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
4810 BlockDriverAIOCBCoroutine *acb = opaque;
4811 BlockDriverState *bs = acb->common.bs;
4813 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
4814 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
4815 qemu_bh_schedule(acb->bh);
4818 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
4819 int64_t sector_num, int nb_sectors,
4820 BlockDriverCompletionFunc *cb, void *opaque)
4822 Coroutine *co;
4823 BlockDriverAIOCBCoroutine *acb;
4825 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
4827 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
4828 acb->req.sector = sector_num;
4829 acb->req.nb_sectors = nb_sectors;
4830 acb->done = NULL;
4831 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
4832 qemu_coroutine_enter(co, acb);
4834 return &acb->common;
4837 void bdrv_init(void)
4839 module_call_init(MODULE_INIT_BLOCK);
4842 void bdrv_init_with_whitelist(void)
4844 use_bdrv_whitelist = 1;
4845 bdrv_init();
4848 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
4849 BlockDriverCompletionFunc *cb, void *opaque)
4851 BlockDriverAIOCB *acb;
4853 acb = g_slice_alloc(aiocb_info->aiocb_size);
4854 acb->aiocb_info = aiocb_info;
4855 acb->bs = bs;
4856 acb->cb = cb;
4857 acb->opaque = opaque;
4858 return acb;
4861 void qemu_aio_release(void *p)
4863 BlockDriverAIOCB *acb = p;
4864 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
4867 /**************************************************************/
4868 /* Coroutine block device emulation */
4870 typedef struct CoroutineIOCompletion {
4871 Coroutine *coroutine;
4872 int ret;
4873 } CoroutineIOCompletion;
4875 static void bdrv_co_io_em_complete(void *opaque, int ret)
4877 CoroutineIOCompletion *co = opaque;
4879 co->ret = ret;
4880 qemu_coroutine_enter(co->coroutine, NULL);
4883 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4884 int nb_sectors, QEMUIOVector *iov,
4885 bool is_write)
4887 CoroutineIOCompletion co = {
4888 .coroutine = qemu_coroutine_self(),
4890 BlockDriverAIOCB *acb;
4892 if (is_write) {
4893 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4894 bdrv_co_io_em_complete, &co);
4895 } else {
4896 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4897 bdrv_co_io_em_complete, &co);
4900 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4901 if (!acb) {
4902 return -EIO;
4904 qemu_coroutine_yield();
4906 return co.ret;
4909 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4910 int64_t sector_num, int nb_sectors,
4911 QEMUIOVector *iov)
4913 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4916 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4917 int64_t sector_num, int nb_sectors,
4918 QEMUIOVector *iov)
4920 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4923 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4925 RwCo *rwco = opaque;
4927 rwco->ret = bdrv_co_flush(rwco->bs);
4930 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4932 int ret;
4934 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4935 return 0;
4938 /* Write back cached data to the OS even with cache=unsafe */
4939 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS);
4940 if (bs->drv->bdrv_co_flush_to_os) {
4941 ret = bs->drv->bdrv_co_flush_to_os(bs);
4942 if (ret < 0) {
4943 return ret;
4947 /* But don't actually force it to the disk with cache=unsafe */
4948 if (bs->open_flags & BDRV_O_NO_FLUSH) {
4949 goto flush_parent;
4952 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK);
4953 if (bs->drv->bdrv_co_flush_to_disk) {
4954 ret = bs->drv->bdrv_co_flush_to_disk(bs);
4955 } else if (bs->drv->bdrv_aio_flush) {
4956 BlockDriverAIOCB *acb;
4957 CoroutineIOCompletion co = {
4958 .coroutine = qemu_coroutine_self(),
4961 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4962 if (acb == NULL) {
4963 ret = -EIO;
4964 } else {
4965 qemu_coroutine_yield();
4966 ret = co.ret;
4968 } else {
4970 * Some block drivers always operate in either writethrough or unsafe
4971 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4972 * know how the server works (because the behaviour is hardcoded or
4973 * depends on server-side configuration), so we can't ensure that
4974 * everything is safe on disk. Returning an error doesn't work because
4975 * that would break guests even if the server operates in writethrough
4976 * mode.
4978 * Let's hope the user knows what he's doing.
4980 ret = 0;
4982 if (ret < 0) {
4983 return ret;
4986 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4987 * in the case of cache=unsafe, so there are no useless flushes.
4989 flush_parent:
4990 return bdrv_co_flush(bs->file);
4993 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
4995 Error *local_err = NULL;
4996 int ret;
4998 if (!bs->drv) {
4999 return;
5002 if (bs->drv->bdrv_invalidate_cache) {
5003 bs->drv->bdrv_invalidate_cache(bs, &local_err);
5004 } else if (bs->file) {
5005 bdrv_invalidate_cache(bs->file, &local_err);
5007 if (local_err) {
5008 error_propagate(errp, local_err);
5009 return;
5012 ret = refresh_total_sectors(bs, bs->total_sectors);
5013 if (ret < 0) {
5014 error_setg_errno(errp, -ret, "Could not refresh total sector count");
5015 return;
5019 void bdrv_invalidate_cache_all(Error **errp)
5021 BlockDriverState *bs;
5022 Error *local_err = NULL;
5024 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5025 AioContext *aio_context = bdrv_get_aio_context(bs);
5027 aio_context_acquire(aio_context);
5028 bdrv_invalidate_cache(bs, &local_err);
5029 aio_context_release(aio_context);
5030 if (local_err) {
5031 error_propagate(errp, local_err);
5032 return;
5037 void bdrv_clear_incoming_migration_all(void)
5039 BlockDriverState *bs;
5041 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5042 AioContext *aio_context = bdrv_get_aio_context(bs);
5044 aio_context_acquire(aio_context);
5045 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
5046 aio_context_release(aio_context);
5050 int bdrv_flush(BlockDriverState *bs)
5052 Coroutine *co;
5053 RwCo rwco = {
5054 .bs = bs,
5055 .ret = NOT_DONE,
5058 if (qemu_in_coroutine()) {
5059 /* Fast-path if already in coroutine context */
5060 bdrv_flush_co_entry(&rwco);
5061 } else {
5062 AioContext *aio_context = bdrv_get_aio_context(bs);
5064 co = qemu_coroutine_create(bdrv_flush_co_entry);
5065 qemu_coroutine_enter(co, &rwco);
5066 while (rwco.ret == NOT_DONE) {
5067 aio_poll(aio_context, true);
5071 return rwco.ret;
5074 typedef struct DiscardCo {
5075 BlockDriverState *bs;
5076 int64_t sector_num;
5077 int nb_sectors;
5078 int ret;
5079 } DiscardCo;
5080 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
5082 DiscardCo *rwco = opaque;
5084 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
5087 /* if no limit is specified in the BlockLimits use a default
5088 * of 32768 512-byte sectors (16 MiB) per request.
5090 #define MAX_DISCARD_DEFAULT 32768
5092 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
5093 int nb_sectors)
5095 int max_discard;
5097 if (!bs->drv) {
5098 return -ENOMEDIUM;
5099 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
5100 return -EIO;
5101 } else if (bs->read_only) {
5102 return -EROFS;
5105 bdrv_reset_dirty(bs, sector_num, nb_sectors);
5107 /* Do nothing if disabled. */
5108 if (!(bs->open_flags & BDRV_O_UNMAP)) {
5109 return 0;
5112 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) {
5113 return 0;
5116 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT;
5117 while (nb_sectors > 0) {
5118 int ret;
5119 int num = nb_sectors;
5121 /* align request */
5122 if (bs->bl.discard_alignment &&
5123 num >= bs->bl.discard_alignment &&
5124 sector_num % bs->bl.discard_alignment) {
5125 if (num > bs->bl.discard_alignment) {
5126 num = bs->bl.discard_alignment;
5128 num -= sector_num % bs->bl.discard_alignment;
5131 /* limit request size */
5132 if (num > max_discard) {
5133 num = max_discard;
5136 if (bs->drv->bdrv_co_discard) {
5137 ret = bs->drv->bdrv_co_discard(bs, sector_num, num);
5138 } else {
5139 BlockDriverAIOCB *acb;
5140 CoroutineIOCompletion co = {
5141 .coroutine = qemu_coroutine_self(),
5144 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
5145 bdrv_co_io_em_complete, &co);
5146 if (acb == NULL) {
5147 return -EIO;
5148 } else {
5149 qemu_coroutine_yield();
5150 ret = co.ret;
5153 if (ret && ret != -ENOTSUP) {
5154 return ret;
5157 sector_num += num;
5158 nb_sectors -= num;
5160 return 0;
5163 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
5165 Coroutine *co;
5166 DiscardCo rwco = {
5167 .bs = bs,
5168 .sector_num = sector_num,
5169 .nb_sectors = nb_sectors,
5170 .ret = NOT_DONE,
5173 if (qemu_in_coroutine()) {
5174 /* Fast-path if already in coroutine context */
5175 bdrv_discard_co_entry(&rwco);
5176 } else {
5177 AioContext *aio_context = bdrv_get_aio_context(bs);
5179 co = qemu_coroutine_create(bdrv_discard_co_entry);
5180 qemu_coroutine_enter(co, &rwco);
5181 while (rwco.ret == NOT_DONE) {
5182 aio_poll(aio_context, true);
5186 return rwco.ret;
5189 /**************************************************************/
5190 /* removable device support */
5193 * Return TRUE if the media is present
5195 int bdrv_is_inserted(BlockDriverState *bs)
5197 BlockDriver *drv = bs->drv;
5199 if (!drv)
5200 return 0;
5201 if (!drv->bdrv_is_inserted)
5202 return 1;
5203 return drv->bdrv_is_inserted(bs);
5207 * Return whether the media changed since the last call to this
5208 * function, or -ENOTSUP if we don't know. Most drivers don't know.
5210 int bdrv_media_changed(BlockDriverState *bs)
5212 BlockDriver *drv = bs->drv;
5214 if (drv && drv->bdrv_media_changed) {
5215 return drv->bdrv_media_changed(bs);
5217 return -ENOTSUP;
5221 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
5223 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
5225 BlockDriver *drv = bs->drv;
5227 if (drv && drv->bdrv_eject) {
5228 drv->bdrv_eject(bs, eject_flag);
5231 if (bs->device_name[0] != '\0') {
5232 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs),
5233 eject_flag, &error_abort);
5238 * Lock or unlock the media (if it is locked, the user won't be able
5239 * to eject it manually).
5241 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
5243 BlockDriver *drv = bs->drv;
5245 trace_bdrv_lock_medium(bs, locked);
5247 if (drv && drv->bdrv_lock_medium) {
5248 drv->bdrv_lock_medium(bs, locked);
5252 /* needed for generic scsi interface */
5254 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
5256 BlockDriver *drv = bs->drv;
5258 if (drv && drv->bdrv_ioctl)
5259 return drv->bdrv_ioctl(bs, req, buf);
5260 return -ENOTSUP;
5263 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
5264 unsigned long int req, void *buf,
5265 BlockDriverCompletionFunc *cb, void *opaque)
5267 BlockDriver *drv = bs->drv;
5269 if (drv && drv->bdrv_aio_ioctl)
5270 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
5271 return NULL;
5274 void bdrv_set_guest_block_size(BlockDriverState *bs, int align)
5276 bs->guest_block_size = align;
5279 void *qemu_blockalign(BlockDriverState *bs, size_t size)
5281 return qemu_memalign(bdrv_opt_mem_align(bs), size);
5284 void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
5286 size_t align = bdrv_opt_mem_align(bs);
5288 /* Ensure that NULL is never returned on success */
5289 assert(align > 0);
5290 if (size == 0) {
5291 size = align;
5294 return qemu_try_memalign(align, size);
5298 * Check if all memory in this vector is sector aligned.
5300 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
5302 int i;
5303 size_t alignment = bdrv_opt_mem_align(bs);
5305 for (i = 0; i < qiov->niov; i++) {
5306 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
5307 return false;
5309 if (qiov->iov[i].iov_len % alignment) {
5310 return false;
5314 return true;
5317 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity,
5318 Error **errp)
5320 int64_t bitmap_size;
5321 BdrvDirtyBitmap *bitmap;
5323 assert((granularity & (granularity - 1)) == 0);
5325 granularity >>= BDRV_SECTOR_BITS;
5326 assert(granularity);
5327 bitmap_size = bdrv_nb_sectors(bs);
5328 if (bitmap_size < 0) {
5329 error_setg_errno(errp, -bitmap_size, "could not get length of device");
5330 errno = -bitmap_size;
5331 return NULL;
5333 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));
5334 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);
5335 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);
5336 return bitmap;
5339 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5341 BdrvDirtyBitmap *bm, *next;
5342 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
5343 if (bm == bitmap) {
5344 QLIST_REMOVE(bitmap, list);
5345 hbitmap_free(bitmap->bitmap);
5346 g_free(bitmap);
5347 return;
5352 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
5354 BdrvDirtyBitmap *bm;
5355 BlockDirtyInfoList *list = NULL;
5356 BlockDirtyInfoList **plist = &list;
5358 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {
5359 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));
5360 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));
5361 info->count = bdrv_get_dirty_count(bs, bm);
5362 info->granularity =
5363 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
5364 entry->value = info;
5365 *plist = entry;
5366 plist = &entry->next;
5369 return list;
5372 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector)
5374 if (bitmap) {
5375 return hbitmap_get(bitmap->bitmap, sector);
5376 } else {
5377 return 0;
5381 void bdrv_dirty_iter_init(BlockDriverState *bs,
5382 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)
5384 hbitmap_iter_init(hbi, bitmap->bitmap, 0);
5387 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
5388 int nr_sectors)
5390 BdrvDirtyBitmap *bitmap;
5391 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5392 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors);
5396 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
5398 BdrvDirtyBitmap *bitmap;
5399 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
5400 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
5404 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
5406 return hbitmap_count(bitmap->bitmap);
5409 /* Get a reference to bs */
5410 void bdrv_ref(BlockDriverState *bs)
5412 bs->refcnt++;
5415 /* Release a previously grabbed reference to bs.
5416 * If after releasing, reference count is zero, the BlockDriverState is
5417 * deleted. */
5418 void bdrv_unref(BlockDriverState *bs)
5420 if (!bs) {
5421 return;
5423 assert(bs->refcnt > 0);
5424 if (--bs->refcnt == 0) {
5425 bdrv_delete(bs);
5429 struct BdrvOpBlocker {
5430 Error *reason;
5431 QLIST_ENTRY(BdrvOpBlocker) list;
5434 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
5436 BdrvOpBlocker *blocker;
5437 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5438 if (!QLIST_EMPTY(&bs->op_blockers[op])) {
5439 blocker = QLIST_FIRST(&bs->op_blockers[op]);
5440 if (errp) {
5441 error_setg(errp, "Device '%s' is busy: %s",
5442 bs->device_name, error_get_pretty(blocker->reason));
5444 return true;
5446 return false;
5449 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason)
5451 BdrvOpBlocker *blocker;
5452 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5454 blocker = g_malloc0(sizeof(BdrvOpBlocker));
5455 blocker->reason = reason;
5456 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);
5459 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason)
5461 BdrvOpBlocker *blocker, *next;
5462 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
5463 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) {
5464 if (blocker->reason == reason) {
5465 QLIST_REMOVE(blocker, list);
5466 g_free(blocker);
5471 void bdrv_op_block_all(BlockDriverState *bs, Error *reason)
5473 int i;
5474 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5475 bdrv_op_block(bs, i, reason);
5479 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason)
5481 int i;
5482 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5483 bdrv_op_unblock(bs, i, reason);
5487 bool bdrv_op_blocker_is_empty(BlockDriverState *bs)
5489 int i;
5491 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) {
5492 if (!QLIST_EMPTY(&bs->op_blockers[i])) {
5493 return false;
5496 return true;
5499 void bdrv_iostatus_enable(BlockDriverState *bs)
5501 bs->iostatus_enabled = true;
5502 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5505 /* The I/O status is only enabled if the drive explicitly
5506 * enables it _and_ the VM is configured to stop on errors */
5507 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
5509 return (bs->iostatus_enabled &&
5510 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
5511 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
5512 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
5515 void bdrv_iostatus_disable(BlockDriverState *bs)
5517 bs->iostatus_enabled = false;
5520 void bdrv_iostatus_reset(BlockDriverState *bs)
5522 if (bdrv_iostatus_is_enabled(bs)) {
5523 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
5524 if (bs->job) {
5525 block_job_iostatus_reset(bs->job);
5530 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
5532 assert(bdrv_iostatus_is_enabled(bs));
5533 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
5534 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
5535 BLOCK_DEVICE_IO_STATUS_FAILED;
5539 void
5540 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
5541 enum BlockAcctType type)
5543 assert(type < BDRV_MAX_IOTYPE);
5545 cookie->bytes = bytes;
5546 cookie->start_time_ns = get_clock();
5547 cookie->type = type;
5550 void
5551 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
5553 assert(cookie->type < BDRV_MAX_IOTYPE);
5555 bs->nr_bytes[cookie->type] += cookie->bytes;
5556 bs->nr_ops[cookie->type]++;
5557 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
5560 void bdrv_img_create(const char *filename, const char *fmt,
5561 const char *base_filename, const char *base_fmt,
5562 char *options, uint64_t img_size, int flags,
5563 Error **errp, bool quiet)
5565 QemuOptsList *create_opts = NULL;
5566 QemuOpts *opts = NULL;
5567 const char *backing_fmt, *backing_file;
5568 int64_t size;
5569 BlockDriver *drv, *proto_drv;
5570 BlockDriver *backing_drv = NULL;
5571 Error *local_err = NULL;
5572 int ret = 0;
5574 /* Find driver and parse its options */
5575 drv = bdrv_find_format(fmt);
5576 if (!drv) {
5577 error_setg(errp, "Unknown file format '%s'", fmt);
5578 return;
5581 proto_drv = bdrv_find_protocol(filename, true);
5582 if (!proto_drv) {
5583 error_setg(errp, "Unknown protocol '%s'", filename);
5584 return;
5587 create_opts = qemu_opts_append(create_opts, drv->create_opts);
5588 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
5590 /* Create parameter list with default values */
5591 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
5592 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);
5594 /* Parse -o options */
5595 if (options) {
5596 if (qemu_opts_do_parse(opts, options, NULL) != 0) {
5597 error_setg(errp, "Invalid options for file format '%s'", fmt);
5598 goto out;
5602 if (base_filename) {
5603 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
5604 error_setg(errp, "Backing file not supported for file format '%s'",
5605 fmt);
5606 goto out;
5610 if (base_fmt) {
5611 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {
5612 error_setg(errp, "Backing file format not supported for file "
5613 "format '%s'", fmt);
5614 goto out;
5618 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5619 if (backing_file) {
5620 if (!strcmp(filename, backing_file)) {
5621 error_setg(errp, "Error: Trying to create an image with the "
5622 "same filename as the backing file");
5623 goto out;
5627 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5628 if (backing_fmt) {
5629 backing_drv = bdrv_find_format(backing_fmt);
5630 if (!backing_drv) {
5631 error_setg(errp, "Unknown backing file format '%s'",
5632 backing_fmt);
5633 goto out;
5637 // The size for the image must always be specified, with one exception:
5638 // If we are using a backing file, we can obtain the size from there
5639 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5640 if (size == -1) {
5641 if (backing_file) {
5642 BlockDriverState *bs;
5643 int64_t size;
5644 int back_flags;
5646 /* backing files always opened read-only */
5647 back_flags =
5648 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
5650 bs = NULL;
5651 ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,
5652 backing_drv, &local_err);
5653 if (ret < 0) {
5654 error_setg_errno(errp, -ret, "Could not open '%s': %s",
5655 backing_file,
5656 error_get_pretty(local_err));
5657 error_free(local_err);
5658 local_err = NULL;
5659 goto out;
5661 size = bdrv_getlength(bs);
5662 if (size < 0) {
5663 error_setg_errno(errp, -size, "Could not get size of '%s'",
5664 backing_file);
5665 bdrv_unref(bs);
5666 goto out;
5669 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);
5671 bdrv_unref(bs);
5672 } else {
5673 error_setg(errp, "Image creation needs a size parameter");
5674 goto out;
5678 if (!quiet) {
5679 printf("Formatting '%s', fmt=%s ", filename, fmt);
5680 qemu_opts_print(opts);
5681 puts("");
5684 ret = bdrv_create(drv, filename, opts, &local_err);
5686 if (ret == -EFBIG) {
5687 /* This is generally a better message than whatever the driver would
5688 * deliver (especially because of the cluster_size_hint), since that
5689 * is most probably not much different from "image too large". */
5690 const char *cluster_size_hint = "";
5691 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {
5692 cluster_size_hint = " (try using a larger cluster size)";
5694 error_setg(errp, "The image size is too large for file format '%s'"
5695 "%s", fmt, cluster_size_hint);
5696 error_free(local_err);
5697 local_err = NULL;
5700 out:
5701 qemu_opts_del(opts);
5702 qemu_opts_free(create_opts);
5703 if (local_err) {
5704 error_propagate(errp, local_err);
5708 AioContext *bdrv_get_aio_context(BlockDriverState *bs)
5710 return bs->aio_context;
5713 void bdrv_detach_aio_context(BlockDriverState *bs)
5715 if (!bs->drv) {
5716 return;
5719 if (bs->io_limits_enabled) {
5720 throttle_detach_aio_context(&bs->throttle_state);
5722 if (bs->drv->bdrv_detach_aio_context) {
5723 bs->drv->bdrv_detach_aio_context(bs);
5725 if (bs->file) {
5726 bdrv_detach_aio_context(bs->file);
5728 if (bs->backing_hd) {
5729 bdrv_detach_aio_context(bs->backing_hd);
5732 bs->aio_context = NULL;
5735 void bdrv_attach_aio_context(BlockDriverState *bs,
5736 AioContext *new_context)
5738 if (!bs->drv) {
5739 return;
5742 bs->aio_context = new_context;
5744 if (bs->backing_hd) {
5745 bdrv_attach_aio_context(bs->backing_hd, new_context);
5747 if (bs->file) {
5748 bdrv_attach_aio_context(bs->file, new_context);
5750 if (bs->drv->bdrv_attach_aio_context) {
5751 bs->drv->bdrv_attach_aio_context(bs, new_context);
5753 if (bs->io_limits_enabled) {
5754 throttle_attach_aio_context(&bs->throttle_state, new_context);
5758 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
5760 bdrv_drain_all(); /* ensure there are no in-flight requests */
5762 bdrv_detach_aio_context(bs);
5764 /* This function executes in the old AioContext so acquire the new one in
5765 * case it runs in a different thread.
5767 aio_context_acquire(new_context);
5768 bdrv_attach_aio_context(bs, new_context);
5769 aio_context_release(new_context);
5772 void bdrv_add_before_write_notifier(BlockDriverState *bs,
5773 NotifierWithReturn *notifier)
5775 notifier_with_return_list_add(&bs->before_write_notifiers, notifier);
5778 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)
5780 if (!bs->drv->bdrv_amend_options) {
5781 return -ENOTSUP;
5783 return bs->drv->bdrv_amend_options(bs, opts);
5786 /* This function will be called by the bdrv_recurse_is_first_non_filter method
5787 * of block filter and by bdrv_is_first_non_filter.
5788 * It is used to test if the given bs is the candidate or recurse more in the
5789 * node graph.
5791 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
5792 BlockDriverState *candidate)
5794 /* return false if basic checks fails */
5795 if (!bs || !bs->drv) {
5796 return false;
5799 /* the code reached a non block filter driver -> check if the bs is
5800 * the same as the candidate. It's the recursion termination condition.
5802 if (!bs->drv->is_filter) {
5803 return bs == candidate;
5805 /* Down this path the driver is a block filter driver */
5807 /* If the block filter recursion method is defined use it to recurse down
5808 * the node graph.
5810 if (bs->drv->bdrv_recurse_is_first_non_filter) {
5811 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate);
5814 /* the driver is a block filter but don't allow to recurse -> return false
5816 return false;
5819 /* This function checks if the candidate is the first non filter bs down it's
5820 * bs chain. Since we don't have pointers to parents it explore all bs chains
5821 * from the top. Some filters can choose not to pass down the recursion.
5823 bool bdrv_is_first_non_filter(BlockDriverState *candidate)
5825 BlockDriverState *bs;
5827 /* walk down the bs forest recursively */
5828 QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
5829 bool perm;
5831 /* try to recurse in this top level bs */
5832 perm = bdrv_recurse_is_first_non_filter(bs, candidate);
5834 /* candidate is the first non filter */
5835 if (perm) {
5836 return true;
5840 return false;
5843 BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)
5845 BlockDriverState *to_replace_bs = bdrv_find_node(node_name);
5846 if (!to_replace_bs) {
5847 error_setg(errp, "Node name '%s' not found", node_name);
5848 return NULL;
5851 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {
5852 return NULL;
5855 /* We don't want arbitrary node of the BDS chain to be replaced only the top
5856 * most non filter in order to prevent data corruption.
5857 * Another benefit is that this tests exclude backing files which are
5858 * blocked by the backing blockers.
5860 if (!bdrv_is_first_non_filter(to_replace_bs)) {
5861 error_setg(errp, "Only top most non filter can be replaced");
5862 return NULL;
5865 return to_replace_bs;
5868 void bdrv_io_plug(BlockDriverState *bs)
5870 BlockDriver *drv = bs->drv;
5871 if (drv && drv->bdrv_io_plug) {
5872 drv->bdrv_io_plug(bs);
5873 } else if (bs->file) {
5874 bdrv_io_plug(bs->file);
5878 void bdrv_io_unplug(BlockDriverState *bs)
5880 BlockDriver *drv = bs->drv;
5881 if (drv && drv->bdrv_io_unplug) {
5882 drv->bdrv_io_unplug(bs);
5883 } else if (bs->file) {
5884 bdrv_io_unplug(bs->file);
5888 void bdrv_flush_io_queue(BlockDriverState *bs)
5890 BlockDriver *drv = bs->drv;
5891 if (drv && drv->bdrv_flush_io_queue) {
5892 drv->bdrv_flush_io_queue(bs);
5893 } else if (bs->file) {
5894 bdrv_flush_io_queue(bs->file);