hw/omap1.c: Add fallthrough markers and breaks
[qemu/pbrook.git] / block.c
blob6fa7c901442d846af54a79578b90115e6b0c7a0f
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 "monitor/monitor.h"
28 #include "block/block_int.h"
29 #include "block/blockjob.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qjson.h"
32 #include "sysemu/sysemu.h"
33 #include "qemu/notify.h"
34 #include "block/coroutine.h"
35 #include "qmp-commands.h"
36 #include "qemu/timer.h"
38 #ifdef CONFIG_BSD
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <sys/ioctl.h>
42 #include <sys/queue.h>
43 #ifndef __DragonFly__
44 #include <sys/disk.h>
45 #endif
46 #endif
48 #ifdef _WIN32
49 #include <windows.h>
50 #endif
52 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */
54 typedef enum {
55 BDRV_REQ_COPY_ON_READ = 0x1,
56 BDRV_REQ_ZERO_WRITE = 0x2,
57 } BdrvRequestFlags;
59 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load);
60 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
61 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
62 BlockDriverCompletionFunc *cb, void *opaque);
63 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
64 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
65 BlockDriverCompletionFunc *cb, void *opaque);
66 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
67 int64_t sector_num, int nb_sectors,
68 QEMUIOVector *iov);
69 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
70 int64_t sector_num, int nb_sectors,
71 QEMUIOVector *iov);
72 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
73 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
74 BdrvRequestFlags flags);
75 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
76 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
77 BdrvRequestFlags flags);
78 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
79 int64_t sector_num,
80 QEMUIOVector *qiov,
81 int nb_sectors,
82 BlockDriverCompletionFunc *cb,
83 void *opaque,
84 bool is_write);
85 static void coroutine_fn bdrv_co_do_rw(void *opaque);
86 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
87 int64_t sector_num, int nb_sectors);
89 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
90 bool is_write, double elapsed_time, uint64_t *wait);
91 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
92 double elapsed_time, uint64_t *wait);
93 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
94 bool is_write, int64_t *wait);
96 static QTAILQ_HEAD(, BlockDriverState) bdrv_states =
97 QTAILQ_HEAD_INITIALIZER(bdrv_states);
99 static QLIST_HEAD(, BlockDriver) bdrv_drivers =
100 QLIST_HEAD_INITIALIZER(bdrv_drivers);
102 /* The device to use for VM snapshots */
103 static BlockDriverState *bs_snapshots;
105 /* If non-zero, use only whitelisted block drivers */
106 static int use_bdrv_whitelist;
108 #ifdef _WIN32
109 static int is_windows_drive_prefix(const char *filename)
111 return (((filename[0] >= 'a' && filename[0] <= 'z') ||
112 (filename[0] >= 'A' && filename[0] <= 'Z')) &&
113 filename[1] == ':');
116 int is_windows_drive(const char *filename)
118 if (is_windows_drive_prefix(filename) &&
119 filename[2] == '\0')
120 return 1;
121 if (strstart(filename, "\\\\.\\", NULL) ||
122 strstart(filename, "//./", NULL))
123 return 1;
124 return 0;
126 #endif
128 /* throttling disk I/O limits */
129 void bdrv_io_limits_disable(BlockDriverState *bs)
131 bs->io_limits_enabled = false;
133 while (qemu_co_queue_next(&bs->throttled_reqs));
135 if (bs->block_timer) {
136 qemu_del_timer(bs->block_timer);
137 qemu_free_timer(bs->block_timer);
138 bs->block_timer = NULL;
141 bs->slice_start = 0;
142 bs->slice_end = 0;
143 bs->slice_time = 0;
144 memset(&bs->io_base, 0, sizeof(bs->io_base));
147 static void bdrv_block_timer(void *opaque)
149 BlockDriverState *bs = opaque;
151 qemu_co_queue_next(&bs->throttled_reqs);
154 void bdrv_io_limits_enable(BlockDriverState *bs)
156 qemu_co_queue_init(&bs->throttled_reqs);
157 bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs);
158 bs->io_limits_enabled = true;
161 bool bdrv_io_limits_enabled(BlockDriverState *bs)
163 BlockIOLimit *io_limits = &bs->io_limits;
164 return io_limits->bps[BLOCK_IO_LIMIT_READ]
165 || io_limits->bps[BLOCK_IO_LIMIT_WRITE]
166 || io_limits->bps[BLOCK_IO_LIMIT_TOTAL]
167 || io_limits->iops[BLOCK_IO_LIMIT_READ]
168 || io_limits->iops[BLOCK_IO_LIMIT_WRITE]
169 || io_limits->iops[BLOCK_IO_LIMIT_TOTAL];
172 static void bdrv_io_limits_intercept(BlockDriverState *bs,
173 bool is_write, int nb_sectors)
175 int64_t wait_time = -1;
177 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
178 qemu_co_queue_wait(&bs->throttled_reqs);
181 /* In fact, we hope to keep each request's timing, in FIFO mode. The next
182 * throttled requests will not be dequeued until the current request is
183 * allowed to be serviced. So if the current request still exceeds the
184 * limits, it will be inserted to the head. All requests followed it will
185 * be still in throttled_reqs queue.
188 while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) {
189 qemu_mod_timer(bs->block_timer,
190 wait_time + qemu_get_clock_ns(vm_clock));
191 qemu_co_queue_wait_insert_head(&bs->throttled_reqs);
194 qemu_co_queue_next(&bs->throttled_reqs);
197 /* check if the path starts with "<protocol>:" */
198 static int path_has_protocol(const char *path)
200 const char *p;
202 #ifdef _WIN32
203 if (is_windows_drive(path) ||
204 is_windows_drive_prefix(path)) {
205 return 0;
207 p = path + strcspn(path, ":/\\");
208 #else
209 p = path + strcspn(path, ":/");
210 #endif
212 return *p == ':';
215 int path_is_absolute(const char *path)
217 #ifdef _WIN32
218 /* specific case for names like: "\\.\d:" */
219 if (is_windows_drive(path) || is_windows_drive_prefix(path)) {
220 return 1;
222 return (*path == '/' || *path == '\\');
223 #else
224 return (*path == '/');
225 #endif
228 /* if filename is absolute, just copy it to dest. Otherwise, build a
229 path to it by considering it is relative to base_path. URL are
230 supported. */
231 void path_combine(char *dest, int dest_size,
232 const char *base_path,
233 const char *filename)
235 const char *p, *p1;
236 int len;
238 if (dest_size <= 0)
239 return;
240 if (path_is_absolute(filename)) {
241 pstrcpy(dest, dest_size, filename);
242 } else {
243 p = strchr(base_path, ':');
244 if (p)
245 p++;
246 else
247 p = base_path;
248 p1 = strrchr(base_path, '/');
249 #ifdef _WIN32
251 const char *p2;
252 p2 = strrchr(base_path, '\\');
253 if (!p1 || p2 > p1)
254 p1 = p2;
256 #endif
257 if (p1)
258 p1++;
259 else
260 p1 = base_path;
261 if (p1 > p)
262 p = p1;
263 len = p - base_path;
264 if (len > dest_size - 1)
265 len = dest_size - 1;
266 memcpy(dest, base_path, len);
267 dest[len] = '\0';
268 pstrcat(dest, dest_size, filename);
272 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz)
274 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) {
275 pstrcpy(dest, sz, bs->backing_file);
276 } else {
277 path_combine(dest, sz, bs->filename, bs->backing_file);
281 void bdrv_register(BlockDriver *bdrv)
283 /* Block drivers without coroutine functions need emulation */
284 if (!bdrv->bdrv_co_readv) {
285 bdrv->bdrv_co_readv = bdrv_co_readv_em;
286 bdrv->bdrv_co_writev = bdrv_co_writev_em;
288 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if
289 * the block driver lacks aio we need to emulate that too.
291 if (!bdrv->bdrv_aio_readv) {
292 /* add AIO emulation layer */
293 bdrv->bdrv_aio_readv = bdrv_aio_readv_em;
294 bdrv->bdrv_aio_writev = bdrv_aio_writev_em;
298 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list);
301 /* create a new block device (by default it is empty) */
302 BlockDriverState *bdrv_new(const char *device_name)
304 BlockDriverState *bs;
306 bs = g_malloc0(sizeof(BlockDriverState));
307 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
308 if (device_name[0] != '\0') {
309 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
311 bdrv_iostatus_disable(bs);
312 notifier_list_init(&bs->close_notifiers);
314 return bs;
317 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify)
319 notifier_list_add(&bs->close_notifiers, notify);
322 BlockDriver *bdrv_find_format(const char *format_name)
324 BlockDriver *drv1;
325 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
326 if (!strcmp(drv1->format_name, format_name)) {
327 return drv1;
330 return NULL;
333 static int bdrv_is_whitelisted(BlockDriver *drv)
335 static const char *whitelist[] = {
336 CONFIG_BDRV_WHITELIST
338 const char **p;
340 if (!whitelist[0])
341 return 1; /* no whitelist, anything goes */
343 for (p = whitelist; *p; p++) {
344 if (!strcmp(drv->format_name, *p)) {
345 return 1;
348 return 0;
351 BlockDriver *bdrv_find_whitelisted_format(const char *format_name)
353 BlockDriver *drv = bdrv_find_format(format_name);
354 return drv && bdrv_is_whitelisted(drv) ? drv : NULL;
357 typedef struct CreateCo {
358 BlockDriver *drv;
359 char *filename;
360 QEMUOptionParameter *options;
361 int ret;
362 } CreateCo;
364 static void coroutine_fn bdrv_create_co_entry(void *opaque)
366 CreateCo *cco = opaque;
367 assert(cco->drv);
369 cco->ret = cco->drv->bdrv_create(cco->filename, cco->options);
372 int bdrv_create(BlockDriver *drv, const char* filename,
373 QEMUOptionParameter *options)
375 int ret;
377 Coroutine *co;
378 CreateCo cco = {
379 .drv = drv,
380 .filename = g_strdup(filename),
381 .options = options,
382 .ret = NOT_DONE,
385 if (!drv->bdrv_create) {
386 ret = -ENOTSUP;
387 goto out;
390 if (qemu_in_coroutine()) {
391 /* Fast-path if already in coroutine context */
392 bdrv_create_co_entry(&cco);
393 } else {
394 co = qemu_coroutine_create(bdrv_create_co_entry);
395 qemu_coroutine_enter(co, &cco);
396 while (cco.ret == NOT_DONE) {
397 qemu_aio_wait();
401 ret = cco.ret;
403 out:
404 g_free(cco.filename);
405 return ret;
408 int bdrv_create_file(const char* filename, QEMUOptionParameter *options)
410 BlockDriver *drv;
412 drv = bdrv_find_protocol(filename);
413 if (drv == NULL) {
414 return -ENOENT;
417 return bdrv_create(drv, filename, options);
421 * Create a uniquely-named empty temporary file.
422 * Return 0 upon success, otherwise a negative errno value.
424 int get_tmp_filename(char *filename, int size)
426 #ifdef _WIN32
427 char temp_dir[MAX_PATH];
428 /* GetTempFileName requires that its output buffer (4th param)
429 have length MAX_PATH or greater. */
430 assert(size >= MAX_PATH);
431 return (GetTempPath(MAX_PATH, temp_dir)
432 && GetTempFileName(temp_dir, "qem", 0, filename)
433 ? 0 : -GetLastError());
434 #else
435 int fd;
436 const char *tmpdir;
437 tmpdir = getenv("TMPDIR");
438 if (!tmpdir)
439 tmpdir = "/tmp";
440 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) {
441 return -EOVERFLOW;
443 fd = mkstemp(filename);
444 if (fd < 0) {
445 return -errno;
447 if (close(fd) != 0) {
448 unlink(filename);
449 return -errno;
451 return 0;
452 #endif
456 * Detect host devices. By convention, /dev/cdrom[N] is always
457 * recognized as a host CDROM.
459 static BlockDriver *find_hdev_driver(const char *filename)
461 int score_max = 0, score;
462 BlockDriver *drv = NULL, *d;
464 QLIST_FOREACH(d, &bdrv_drivers, list) {
465 if (d->bdrv_probe_device) {
466 score = d->bdrv_probe_device(filename);
467 if (score > score_max) {
468 score_max = score;
469 drv = d;
474 return drv;
477 BlockDriver *bdrv_find_protocol(const char *filename)
479 BlockDriver *drv1;
480 char protocol[128];
481 int len;
482 const char *p;
484 /* TODO Drivers without bdrv_file_open must be specified explicitly */
487 * XXX(hch): we really should not let host device detection
488 * override an explicit protocol specification, but moving this
489 * later breaks access to device names with colons in them.
490 * Thanks to the brain-dead persistent naming schemes on udev-
491 * based Linux systems those actually are quite common.
493 drv1 = find_hdev_driver(filename);
494 if (drv1) {
495 return drv1;
498 if (!path_has_protocol(filename)) {
499 return bdrv_find_format("file");
501 p = strchr(filename, ':');
502 assert(p != NULL);
503 len = p - filename;
504 if (len > sizeof(protocol) - 1)
505 len = sizeof(protocol) - 1;
506 memcpy(protocol, filename, len);
507 protocol[len] = '\0';
508 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
509 if (drv1->protocol_name &&
510 !strcmp(drv1->protocol_name, protocol)) {
511 return drv1;
514 return NULL;
517 static int find_image_format(BlockDriverState *bs, const char *filename,
518 BlockDriver **pdrv)
520 int score, score_max;
521 BlockDriver *drv1, *drv;
522 uint8_t buf[2048];
523 int ret = 0;
525 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
526 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
527 drv = bdrv_find_format("raw");
528 if (!drv) {
529 ret = -ENOENT;
531 *pdrv = drv;
532 return ret;
535 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
536 if (ret < 0) {
537 *pdrv = NULL;
538 return ret;
541 score_max = 0;
542 drv = NULL;
543 QLIST_FOREACH(drv1, &bdrv_drivers, list) {
544 if (drv1->bdrv_probe) {
545 score = drv1->bdrv_probe(buf, ret, filename);
546 if (score > score_max) {
547 score_max = score;
548 drv = drv1;
552 if (!drv) {
553 ret = -ENOENT;
555 *pdrv = drv;
556 return ret;
560 * Set the current 'total_sectors' value
562 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
564 BlockDriver *drv = bs->drv;
566 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */
567 if (bs->sg)
568 return 0;
570 /* query actual device if possible, otherwise just trust the hint */
571 if (drv->bdrv_getlength) {
572 int64_t length = drv->bdrv_getlength(bs);
573 if (length < 0) {
574 return length;
576 hint = length >> BDRV_SECTOR_BITS;
579 bs->total_sectors = hint;
580 return 0;
584 * Set open flags for a given cache mode
586 * Return 0 on success, -1 if the cache mode was invalid.
588 int bdrv_parse_cache_flags(const char *mode, int *flags)
590 *flags &= ~BDRV_O_CACHE_MASK;
592 if (!strcmp(mode, "off") || !strcmp(mode, "none")) {
593 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB;
594 } else if (!strcmp(mode, "directsync")) {
595 *flags |= BDRV_O_NOCACHE;
596 } else if (!strcmp(mode, "writeback")) {
597 *flags |= BDRV_O_CACHE_WB;
598 } else if (!strcmp(mode, "unsafe")) {
599 *flags |= BDRV_O_CACHE_WB;
600 *flags |= BDRV_O_NO_FLUSH;
601 } else if (!strcmp(mode, "writethrough")) {
602 /* this is the default */
603 } else {
604 return -1;
607 return 0;
611 * The copy-on-read flag is actually a reference count so multiple users may
612 * use the feature without worrying about clobbering its previous state.
613 * Copy-on-read stays enabled until all users have called to disable it.
615 void bdrv_enable_copy_on_read(BlockDriverState *bs)
617 bs->copy_on_read++;
620 void bdrv_disable_copy_on_read(BlockDriverState *bs)
622 assert(bs->copy_on_read > 0);
623 bs->copy_on_read--;
626 static int bdrv_open_flags(BlockDriverState *bs, int flags)
628 int open_flags = flags | BDRV_O_CACHE_WB;
631 * Clear flags that are internal to the block layer before opening the
632 * image.
634 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
637 * Snapshots should be writable.
639 if (bs->is_temporary) {
640 open_flags |= BDRV_O_RDWR;
643 return open_flags;
647 * Common part for opening disk images and files
649 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file,
650 const char *filename,
651 int flags, BlockDriver *drv)
653 int ret, open_flags;
655 assert(drv != NULL);
656 assert(bs->file == NULL);
658 trace_bdrv_open_common(bs, filename, flags, drv->format_name);
660 bs->open_flags = flags;
661 bs->buffer_alignment = 512;
663 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */
664 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) {
665 bdrv_enable_copy_on_read(bs);
668 pstrcpy(bs->filename, sizeof(bs->filename), filename);
670 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) {
671 return -ENOTSUP;
674 bs->drv = drv;
675 bs->opaque = g_malloc0(drv->instance_size);
677 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB);
678 open_flags = bdrv_open_flags(bs, flags);
680 bs->read_only = !(open_flags & BDRV_O_RDWR);
682 /* Open the image, either directly or using a protocol */
683 if (drv->bdrv_file_open) {
684 if (file != NULL) {
685 bdrv_swap(file, bs);
686 ret = 0;
687 } else {
688 ret = drv->bdrv_file_open(bs, filename, open_flags);
690 } else {
691 assert(file != NULL);
692 bs->file = file;
693 ret = drv->bdrv_open(bs, open_flags);
696 if (ret < 0) {
697 goto free_and_fail;
700 ret = refresh_total_sectors(bs, bs->total_sectors);
701 if (ret < 0) {
702 goto free_and_fail;
705 #ifndef _WIN32
706 if (bs->is_temporary) {
707 unlink(filename);
709 #endif
710 return 0;
712 free_and_fail:
713 bs->file = NULL;
714 g_free(bs->opaque);
715 bs->opaque = NULL;
716 bs->drv = NULL;
717 return ret;
721 * Opens a file using a protocol (file, host_device, nbd, ...)
723 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
725 BlockDriverState *bs;
726 BlockDriver *drv;
727 int ret;
729 drv = bdrv_find_protocol(filename);
730 if (!drv) {
731 return -ENOENT;
734 bs = bdrv_new("");
735 ret = bdrv_open_common(bs, NULL, filename, flags, drv);
736 if (ret < 0) {
737 bdrv_delete(bs);
738 return ret;
740 bs->growable = 1;
741 *pbs = bs;
742 return 0;
745 int bdrv_open_backing_file(BlockDriverState *bs)
747 char backing_filename[PATH_MAX];
748 int back_flags, ret;
749 BlockDriver *back_drv = NULL;
751 if (bs->backing_hd != NULL) {
752 return 0;
755 bs->open_flags &= ~BDRV_O_NO_BACKING;
756 if (bs->backing_file[0] == '\0') {
757 return 0;
760 bs->backing_hd = bdrv_new("");
761 bdrv_get_full_backing_filename(bs, backing_filename,
762 sizeof(backing_filename));
764 if (bs->backing_format[0] != '\0') {
765 back_drv = bdrv_find_format(bs->backing_format);
768 /* backing files always opened read-only */
769 back_flags = bs->open_flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT);
771 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
772 if (ret < 0) {
773 bdrv_delete(bs->backing_hd);
774 bs->backing_hd = NULL;
775 bs->open_flags |= BDRV_O_NO_BACKING;
776 return ret;
778 return 0;
782 * Opens a disk image (raw, qcow2, vmdk, ...)
784 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
785 BlockDriver *drv)
787 int ret;
788 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
789 char tmp_filename[PATH_MAX + 1];
790 BlockDriverState *file = NULL;
792 if (flags & BDRV_O_SNAPSHOT) {
793 BlockDriverState *bs1;
794 int64_t total_size;
795 int is_protocol = 0;
796 BlockDriver *bdrv_qcow2;
797 QEMUOptionParameter *options;
798 char backing_filename[PATH_MAX];
800 /* if snapshot, we create a temporary backing file and open it
801 instead of opening 'filename' directly */
803 /* if there is a backing file, use it */
804 bs1 = bdrv_new("");
805 ret = bdrv_open(bs1, filename, 0, drv);
806 if (ret < 0) {
807 bdrv_delete(bs1);
808 return ret;
810 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
812 if (bs1->drv && bs1->drv->protocol_name)
813 is_protocol = 1;
815 bdrv_delete(bs1);
817 ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename));
818 if (ret < 0) {
819 return ret;
822 /* Real path is meaningless for protocols */
823 if (is_protocol)
824 snprintf(backing_filename, sizeof(backing_filename),
825 "%s", filename);
826 else if (!realpath(filename, backing_filename))
827 return -errno;
829 bdrv_qcow2 = bdrv_find_format("qcow2");
830 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL);
832 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size);
833 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename);
834 if (drv) {
835 set_option_parameter(options, BLOCK_OPT_BACKING_FMT,
836 drv->format_name);
839 ret = bdrv_create(bdrv_qcow2, tmp_filename, options);
840 free_option_parameters(options);
841 if (ret < 0) {
842 return ret;
845 filename = tmp_filename;
846 drv = bdrv_qcow2;
847 bs->is_temporary = 1;
850 /* Open image file without format layer */
851 if (flags & BDRV_O_RDWR) {
852 flags |= BDRV_O_ALLOW_RDWR;
855 ret = bdrv_file_open(&file, filename, bdrv_open_flags(bs, flags));
856 if (ret < 0) {
857 return ret;
860 /* Find the right image format driver */
861 if (!drv) {
862 ret = find_image_format(file, filename, &drv);
865 if (!drv) {
866 goto unlink_and_fail;
869 /* Open the image */
870 ret = bdrv_open_common(bs, file, filename, flags, drv);
871 if (ret < 0) {
872 goto unlink_and_fail;
875 if (bs->file != file) {
876 bdrv_delete(file);
877 file = NULL;
880 /* If there is a backing file, use it */
881 if ((flags & BDRV_O_NO_BACKING) == 0) {
882 ret = bdrv_open_backing_file(bs);
883 if (ret < 0) {
884 bdrv_close(bs);
885 return ret;
889 if (!bdrv_key_required(bs)) {
890 bdrv_dev_change_media_cb(bs, true);
893 /* throttling disk I/O limits */
894 if (bs->io_limits_enabled) {
895 bdrv_io_limits_enable(bs);
898 return 0;
900 unlink_and_fail:
901 if (file != NULL) {
902 bdrv_delete(file);
904 if (bs->is_temporary) {
905 unlink(filename);
907 return ret;
910 typedef struct BlockReopenQueueEntry {
911 bool prepared;
912 BDRVReopenState state;
913 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;
914 } BlockReopenQueueEntry;
917 * Adds a BlockDriverState to a simple queue for an atomic, transactional
918 * reopen of multiple devices.
920 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT
921 * already performed, or alternatively may be NULL a new BlockReopenQueue will
922 * be created and initialized. This newly created BlockReopenQueue should be
923 * passed back in for subsequent calls that are intended to be of the same
924 * atomic 'set'.
926 * bs is the BlockDriverState to add to the reopen queue.
928 * flags contains the open flags for the associated bs
930 * returns a pointer to bs_queue, which is either the newly allocated
931 * bs_queue, or the existing bs_queue being used.
934 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
935 BlockDriverState *bs, int flags)
937 assert(bs != NULL);
939 BlockReopenQueueEntry *bs_entry;
940 if (bs_queue == NULL) {
941 bs_queue = g_new0(BlockReopenQueue, 1);
942 QSIMPLEQ_INIT(bs_queue);
945 if (bs->file) {
946 bdrv_reopen_queue(bs_queue, bs->file, flags);
949 bs_entry = g_new0(BlockReopenQueueEntry, 1);
950 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
952 bs_entry->state.bs = bs;
953 bs_entry->state.flags = flags;
955 return bs_queue;
959 * Reopen multiple BlockDriverStates atomically & transactionally.
961 * The queue passed in (bs_queue) must have been built up previous
962 * via bdrv_reopen_queue().
964 * Reopens all BDS specified in the queue, with the appropriate
965 * flags. All devices are prepared for reopen, and failure of any
966 * device will cause all device changes to be abandonded, and intermediate
967 * data cleaned up.
969 * If all devices prepare successfully, then the changes are committed
970 * to all devices.
973 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp)
975 int ret = -1;
976 BlockReopenQueueEntry *bs_entry, *next;
977 Error *local_err = NULL;
979 assert(bs_queue != NULL);
981 bdrv_drain_all();
983 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
984 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
985 error_propagate(errp, local_err);
986 goto cleanup;
988 bs_entry->prepared = true;
991 /* If we reach this point, we have success and just need to apply the
992 * changes
994 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
995 bdrv_reopen_commit(&bs_entry->state);
998 ret = 0;
1000 cleanup:
1001 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {
1002 if (ret && bs_entry->prepared) {
1003 bdrv_reopen_abort(&bs_entry->state);
1005 g_free(bs_entry);
1007 g_free(bs_queue);
1008 return ret;
1012 /* Reopen a single BlockDriverState with the specified flags. */
1013 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
1015 int ret = -1;
1016 Error *local_err = NULL;
1017 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags);
1019 ret = bdrv_reopen_multiple(queue, &local_err);
1020 if (local_err != NULL) {
1021 error_propagate(errp, local_err);
1023 return ret;
1028 * Prepares a BlockDriverState for reopen. All changes are staged in the
1029 * 'opaque' field of the BDRVReopenState, which is used and allocated by
1030 * the block driver layer .bdrv_reopen_prepare()
1032 * bs is the BlockDriverState to reopen
1033 * flags are the new open flags
1034 * queue is the reopen queue
1036 * Returns 0 on success, non-zero on error. On error errp will be set
1037 * as well.
1039 * On failure, bdrv_reopen_abort() will be called to clean up any data.
1040 * It is the responsibility of the caller to then call the abort() or
1041 * commit() for any other BDS that have been left in a prepare() state
1044 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
1045 Error **errp)
1047 int ret = -1;
1048 Error *local_err = NULL;
1049 BlockDriver *drv;
1051 assert(reopen_state != NULL);
1052 assert(reopen_state->bs->drv != NULL);
1053 drv = reopen_state->bs->drv;
1055 /* if we are to stay read-only, do not allow permission change
1056 * to r/w */
1057 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
1058 reopen_state->flags & BDRV_O_RDWR) {
1059 error_set(errp, QERR_DEVICE_IS_READ_ONLY,
1060 reopen_state->bs->device_name);
1061 goto error;
1065 ret = bdrv_flush(reopen_state->bs);
1066 if (ret) {
1067 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive",
1068 strerror(-ret));
1069 goto error;
1072 if (drv->bdrv_reopen_prepare) {
1073 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err);
1074 if (ret) {
1075 if (local_err != NULL) {
1076 error_propagate(errp, local_err);
1077 } else {
1078 error_set(errp, QERR_OPEN_FILE_FAILED,
1079 reopen_state->bs->filename);
1081 goto error;
1083 } else {
1084 /* It is currently mandatory to have a bdrv_reopen_prepare()
1085 * handler for each supported drv. */
1086 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
1087 drv->format_name, reopen_state->bs->device_name,
1088 "reopening of file");
1089 ret = -1;
1090 goto error;
1093 ret = 0;
1095 error:
1096 return ret;
1100 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and
1101 * makes them final by swapping the staging BlockDriverState contents into
1102 * the active BlockDriverState contents.
1104 void bdrv_reopen_commit(BDRVReopenState *reopen_state)
1106 BlockDriver *drv;
1108 assert(reopen_state != NULL);
1109 drv = reopen_state->bs->drv;
1110 assert(drv != NULL);
1112 /* If there are any driver level actions to take */
1113 if (drv->bdrv_reopen_commit) {
1114 drv->bdrv_reopen_commit(reopen_state);
1117 /* set BDS specific flags now */
1118 reopen_state->bs->open_flags = reopen_state->flags;
1119 reopen_state->bs->enable_write_cache = !!(reopen_state->flags &
1120 BDRV_O_CACHE_WB);
1121 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR);
1125 * Abort the reopen, and delete and free the staged changes in
1126 * reopen_state
1128 void bdrv_reopen_abort(BDRVReopenState *reopen_state)
1130 BlockDriver *drv;
1132 assert(reopen_state != NULL);
1133 drv = reopen_state->bs->drv;
1134 assert(drv != NULL);
1136 if (drv->bdrv_reopen_abort) {
1137 drv->bdrv_reopen_abort(reopen_state);
1142 void bdrv_close(BlockDriverState *bs)
1144 bdrv_flush(bs);
1145 if (bs->job) {
1146 block_job_cancel_sync(bs->job);
1148 bdrv_drain_all();
1149 notifier_list_notify(&bs->close_notifiers, bs);
1151 if (bs->drv) {
1152 if (bs == bs_snapshots) {
1153 bs_snapshots = NULL;
1155 if (bs->backing_hd) {
1156 bdrv_delete(bs->backing_hd);
1157 bs->backing_hd = NULL;
1159 bs->drv->bdrv_close(bs);
1160 g_free(bs->opaque);
1161 #ifdef _WIN32
1162 if (bs->is_temporary) {
1163 unlink(bs->filename);
1165 #endif
1166 bs->opaque = NULL;
1167 bs->drv = NULL;
1168 bs->copy_on_read = 0;
1169 bs->backing_file[0] = '\0';
1170 bs->backing_format[0] = '\0';
1171 bs->total_sectors = 0;
1172 bs->encrypted = 0;
1173 bs->valid_key = 0;
1174 bs->sg = 0;
1175 bs->growable = 0;
1177 if (bs->file != NULL) {
1178 bdrv_delete(bs->file);
1179 bs->file = NULL;
1183 bdrv_dev_change_media_cb(bs, false);
1185 /*throttling disk I/O limits*/
1186 if (bs->io_limits_enabled) {
1187 bdrv_io_limits_disable(bs);
1191 void bdrv_close_all(void)
1193 BlockDriverState *bs;
1195 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1196 bdrv_close(bs);
1201 * Wait for pending requests to complete across all BlockDriverStates
1203 * This function does not flush data to disk, use bdrv_flush_all() for that
1204 * after calling this function.
1206 * Note that completion of an asynchronous I/O operation can trigger any
1207 * number of other I/O operations on other devices---for example a coroutine
1208 * can be arbitrarily complex and a constant flow of I/O can come until the
1209 * coroutine is complete. Because of this, it is not possible to have a
1210 * function to drain a single device's I/O queue.
1212 void bdrv_drain_all(void)
1214 BlockDriverState *bs;
1215 bool busy;
1217 do {
1218 busy = qemu_aio_wait();
1220 /* FIXME: We do not have timer support here, so this is effectively
1221 * a busy wait.
1223 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1224 if (!qemu_co_queue_empty(&bs->throttled_reqs)) {
1225 qemu_co_queue_restart_all(&bs->throttled_reqs);
1226 busy = true;
1229 } while (busy);
1231 /* If requests are still pending there is a bug somewhere */
1232 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1233 assert(QLIST_EMPTY(&bs->tracked_requests));
1234 assert(qemu_co_queue_empty(&bs->throttled_reqs));
1238 /* make a BlockDriverState anonymous by removing from bdrv_state list.
1239 Also, NULL terminate the device_name to prevent double remove */
1240 void bdrv_make_anon(BlockDriverState *bs)
1242 if (bs->device_name[0] != '\0') {
1243 QTAILQ_REMOVE(&bdrv_states, bs, list);
1245 bs->device_name[0] = '\0';
1248 static void bdrv_rebind(BlockDriverState *bs)
1250 if (bs->drv && bs->drv->bdrv_rebind) {
1251 bs->drv->bdrv_rebind(bs);
1255 static void bdrv_move_feature_fields(BlockDriverState *bs_dest,
1256 BlockDriverState *bs_src)
1258 /* move some fields that need to stay attached to the device */
1259 bs_dest->open_flags = bs_src->open_flags;
1261 /* dev info */
1262 bs_dest->dev_ops = bs_src->dev_ops;
1263 bs_dest->dev_opaque = bs_src->dev_opaque;
1264 bs_dest->dev = bs_src->dev;
1265 bs_dest->buffer_alignment = bs_src->buffer_alignment;
1266 bs_dest->copy_on_read = bs_src->copy_on_read;
1268 bs_dest->enable_write_cache = bs_src->enable_write_cache;
1270 /* i/o timing parameters */
1271 bs_dest->slice_time = bs_src->slice_time;
1272 bs_dest->slice_start = bs_src->slice_start;
1273 bs_dest->slice_end = bs_src->slice_end;
1274 bs_dest->io_limits = bs_src->io_limits;
1275 bs_dest->io_base = bs_src->io_base;
1276 bs_dest->throttled_reqs = bs_src->throttled_reqs;
1277 bs_dest->block_timer = bs_src->block_timer;
1278 bs_dest->io_limits_enabled = bs_src->io_limits_enabled;
1280 /* r/w error */
1281 bs_dest->on_read_error = bs_src->on_read_error;
1282 bs_dest->on_write_error = bs_src->on_write_error;
1284 /* i/o status */
1285 bs_dest->iostatus_enabled = bs_src->iostatus_enabled;
1286 bs_dest->iostatus = bs_src->iostatus;
1288 /* dirty bitmap */
1289 bs_dest->dirty_count = bs_src->dirty_count;
1290 bs_dest->dirty_bitmap = bs_src->dirty_bitmap;
1292 /* job */
1293 bs_dest->in_use = bs_src->in_use;
1294 bs_dest->job = bs_src->job;
1296 /* keep the same entry in bdrv_states */
1297 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name),
1298 bs_src->device_name);
1299 bs_dest->list = bs_src->list;
1303 * Swap bs contents for two image chains while they are live,
1304 * while keeping required fields on the BlockDriverState that is
1305 * actually attached to a device.
1307 * This will modify the BlockDriverState fields, and swap contents
1308 * between bs_new and bs_old. Both bs_new and bs_old are modified.
1310 * bs_new is required to be anonymous.
1312 * This function does not create any image files.
1314 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old)
1316 BlockDriverState tmp;
1318 /* bs_new must be anonymous and shouldn't have anything fancy enabled */
1319 assert(bs_new->device_name[0] == '\0');
1320 assert(bs_new->dirty_bitmap == NULL);
1321 assert(bs_new->job == NULL);
1322 assert(bs_new->dev == NULL);
1323 assert(bs_new->in_use == 0);
1324 assert(bs_new->io_limits_enabled == false);
1325 assert(bs_new->block_timer == NULL);
1327 tmp = *bs_new;
1328 *bs_new = *bs_old;
1329 *bs_old = tmp;
1331 /* there are some fields that should not be swapped, move them back */
1332 bdrv_move_feature_fields(&tmp, bs_old);
1333 bdrv_move_feature_fields(bs_old, bs_new);
1334 bdrv_move_feature_fields(bs_new, &tmp);
1336 /* bs_new shouldn't be in bdrv_states even after the swap! */
1337 assert(bs_new->device_name[0] == '\0');
1339 /* Check a few fields that should remain attached to the device */
1340 assert(bs_new->dev == NULL);
1341 assert(bs_new->job == NULL);
1342 assert(bs_new->in_use == 0);
1343 assert(bs_new->io_limits_enabled == false);
1344 assert(bs_new->block_timer == NULL);
1346 bdrv_rebind(bs_new);
1347 bdrv_rebind(bs_old);
1351 * Add new bs contents at the top of an image chain while the chain is
1352 * live, while keeping required fields on the top layer.
1354 * This will modify the BlockDriverState fields, and swap contents
1355 * between bs_new and bs_top. Both bs_new and bs_top are modified.
1357 * bs_new is required to be anonymous.
1359 * This function does not create any image files.
1361 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top)
1363 bdrv_swap(bs_new, bs_top);
1365 /* The contents of 'tmp' will become bs_top, as we are
1366 * swapping bs_new and bs_top contents. */
1367 bs_top->backing_hd = bs_new;
1368 bs_top->open_flags &= ~BDRV_O_NO_BACKING;
1369 pstrcpy(bs_top->backing_file, sizeof(bs_top->backing_file),
1370 bs_new->filename);
1371 pstrcpy(bs_top->backing_format, sizeof(bs_top->backing_format),
1372 bs_new->drv ? bs_new->drv->format_name : "");
1375 void bdrv_delete(BlockDriverState *bs)
1377 assert(!bs->dev);
1378 assert(!bs->job);
1379 assert(!bs->in_use);
1381 /* remove from list, if necessary */
1382 bdrv_make_anon(bs);
1384 bdrv_close(bs);
1386 assert(bs != bs_snapshots);
1387 g_free(bs);
1390 int bdrv_attach_dev(BlockDriverState *bs, void *dev)
1391 /* TODO change to DeviceState *dev when all users are qdevified */
1393 if (bs->dev) {
1394 return -EBUSY;
1396 bs->dev = dev;
1397 bdrv_iostatus_reset(bs);
1398 return 0;
1401 /* TODO qdevified devices don't use this, remove when devices are qdevified */
1402 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev)
1404 if (bdrv_attach_dev(bs, dev) < 0) {
1405 abort();
1409 void bdrv_detach_dev(BlockDriverState *bs, void *dev)
1410 /* TODO change to DeviceState *dev when all users are qdevified */
1412 assert(bs->dev == dev);
1413 bs->dev = NULL;
1414 bs->dev_ops = NULL;
1415 bs->dev_opaque = NULL;
1416 bs->buffer_alignment = 512;
1419 /* TODO change to return DeviceState * when all users are qdevified */
1420 void *bdrv_get_attached_dev(BlockDriverState *bs)
1422 return bs->dev;
1425 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops,
1426 void *opaque)
1428 bs->dev_ops = ops;
1429 bs->dev_opaque = opaque;
1430 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) {
1431 bs_snapshots = NULL;
1435 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv,
1436 enum MonitorEvent ev,
1437 BlockErrorAction action, bool is_read)
1439 QObject *data;
1440 const char *action_str;
1442 switch (action) {
1443 case BDRV_ACTION_REPORT:
1444 action_str = "report";
1445 break;
1446 case BDRV_ACTION_IGNORE:
1447 action_str = "ignore";
1448 break;
1449 case BDRV_ACTION_STOP:
1450 action_str = "stop";
1451 break;
1452 default:
1453 abort();
1456 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }",
1457 bdrv->device_name,
1458 action_str,
1459 is_read ? "read" : "write");
1460 monitor_protocol_event(ev, data);
1462 qobject_decref(data);
1465 static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected)
1467 QObject *data;
1469 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }",
1470 bdrv_get_device_name(bs), ejected);
1471 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data);
1473 qobject_decref(data);
1476 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load)
1478 if (bs->dev_ops && bs->dev_ops->change_media_cb) {
1479 bool tray_was_closed = !bdrv_dev_is_tray_open(bs);
1480 bs->dev_ops->change_media_cb(bs->dev_opaque, load);
1481 if (tray_was_closed) {
1482 /* tray open */
1483 bdrv_emit_qmp_eject_event(bs, true);
1485 if (load) {
1486 /* tray close */
1487 bdrv_emit_qmp_eject_event(bs, false);
1492 bool bdrv_dev_has_removable_media(BlockDriverState *bs)
1494 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb);
1497 void bdrv_dev_eject_request(BlockDriverState *bs, bool force)
1499 if (bs->dev_ops && bs->dev_ops->eject_request_cb) {
1500 bs->dev_ops->eject_request_cb(bs->dev_opaque, force);
1504 bool bdrv_dev_is_tray_open(BlockDriverState *bs)
1506 if (bs->dev_ops && bs->dev_ops->is_tray_open) {
1507 return bs->dev_ops->is_tray_open(bs->dev_opaque);
1509 return false;
1512 static void bdrv_dev_resize_cb(BlockDriverState *bs)
1514 if (bs->dev_ops && bs->dev_ops->resize_cb) {
1515 bs->dev_ops->resize_cb(bs->dev_opaque);
1519 bool bdrv_dev_is_medium_locked(BlockDriverState *bs)
1521 if (bs->dev_ops && bs->dev_ops->is_medium_locked) {
1522 return bs->dev_ops->is_medium_locked(bs->dev_opaque);
1524 return false;
1528 * Run consistency checks on an image
1530 * Returns 0 if the check could be completed (it doesn't mean that the image is
1531 * free of errors) or -errno when an internal error occurred. The results of the
1532 * check are stored in res.
1534 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
1536 if (bs->drv->bdrv_check == NULL) {
1537 return -ENOTSUP;
1540 memset(res, 0, sizeof(*res));
1541 return bs->drv->bdrv_check(bs, res, fix);
1544 #define COMMIT_BUF_SECTORS 2048
1546 /* commit COW file into the raw image */
1547 int bdrv_commit(BlockDriverState *bs)
1549 BlockDriver *drv = bs->drv;
1550 int64_t sector, total_sectors;
1551 int n, ro, open_flags;
1552 int ret = 0;
1553 uint8_t *buf;
1554 char filename[PATH_MAX];
1556 if (!drv)
1557 return -ENOMEDIUM;
1559 if (!bs->backing_hd) {
1560 return -ENOTSUP;
1563 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) {
1564 return -EBUSY;
1567 ro = bs->backing_hd->read_only;
1568 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */
1569 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename);
1570 open_flags = bs->backing_hd->open_flags;
1572 if (ro) {
1573 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) {
1574 return -EACCES;
1578 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
1579 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
1581 for (sector = 0; sector < total_sectors; sector += n) {
1582 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
1584 if (bdrv_read(bs, sector, buf, n) != 0) {
1585 ret = -EIO;
1586 goto ro_cleanup;
1589 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
1590 ret = -EIO;
1591 goto ro_cleanup;
1596 if (drv->bdrv_make_empty) {
1597 ret = drv->bdrv_make_empty(bs);
1598 bdrv_flush(bs);
1602 * Make sure all data we wrote to the backing device is actually
1603 * stable on disk.
1605 if (bs->backing_hd)
1606 bdrv_flush(bs->backing_hd);
1608 ro_cleanup:
1609 g_free(buf);
1611 if (ro) {
1612 /* ignoring error return here */
1613 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL);
1616 return ret;
1619 int bdrv_commit_all(void)
1621 BlockDriverState *bs;
1623 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1624 int ret = bdrv_commit(bs);
1625 if (ret < 0) {
1626 return ret;
1629 return 0;
1632 struct BdrvTrackedRequest {
1633 BlockDriverState *bs;
1634 int64_t sector_num;
1635 int nb_sectors;
1636 bool is_write;
1637 QLIST_ENTRY(BdrvTrackedRequest) list;
1638 Coroutine *co; /* owner, used for deadlock detection */
1639 CoQueue wait_queue; /* coroutines blocked on this request */
1643 * Remove an active request from the tracked requests list
1645 * This function should be called when a tracked request is completing.
1647 static void tracked_request_end(BdrvTrackedRequest *req)
1649 QLIST_REMOVE(req, list);
1650 qemu_co_queue_restart_all(&req->wait_queue);
1654 * Add an active request to the tracked requests list
1656 static void tracked_request_begin(BdrvTrackedRequest *req,
1657 BlockDriverState *bs,
1658 int64_t sector_num,
1659 int nb_sectors, bool is_write)
1661 *req = (BdrvTrackedRequest){
1662 .bs = bs,
1663 .sector_num = sector_num,
1664 .nb_sectors = nb_sectors,
1665 .is_write = is_write,
1666 .co = qemu_coroutine_self(),
1669 qemu_co_queue_init(&req->wait_queue);
1671 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list);
1675 * Round a region to cluster boundaries
1677 static void round_to_clusters(BlockDriverState *bs,
1678 int64_t sector_num, int nb_sectors,
1679 int64_t *cluster_sector_num,
1680 int *cluster_nb_sectors)
1682 BlockDriverInfo bdi;
1684 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {
1685 *cluster_sector_num = sector_num;
1686 *cluster_nb_sectors = nb_sectors;
1687 } else {
1688 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE;
1689 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c);
1690 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num +
1691 nb_sectors, c);
1695 static bool tracked_request_overlaps(BdrvTrackedRequest *req,
1696 int64_t sector_num, int nb_sectors) {
1697 /* aaaa bbbb */
1698 if (sector_num >= req->sector_num + req->nb_sectors) {
1699 return false;
1701 /* bbbb aaaa */
1702 if (req->sector_num >= sector_num + nb_sectors) {
1703 return false;
1705 return true;
1708 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs,
1709 int64_t sector_num, int nb_sectors)
1711 BdrvTrackedRequest *req;
1712 int64_t cluster_sector_num;
1713 int cluster_nb_sectors;
1714 bool retry;
1716 /* If we touch the same cluster it counts as an overlap. This guarantees
1717 * that allocating writes will be serialized and not race with each other
1718 * for the same cluster. For example, in copy-on-read it ensures that the
1719 * CoR read and write operations are atomic and guest writes cannot
1720 * interleave between them.
1722 round_to_clusters(bs, sector_num, nb_sectors,
1723 &cluster_sector_num, &cluster_nb_sectors);
1725 do {
1726 retry = false;
1727 QLIST_FOREACH(req, &bs->tracked_requests, list) {
1728 if (tracked_request_overlaps(req, cluster_sector_num,
1729 cluster_nb_sectors)) {
1730 /* Hitting this means there was a reentrant request, for
1731 * example, a block driver issuing nested requests. This must
1732 * never happen since it means deadlock.
1734 assert(qemu_coroutine_self() != req->co);
1736 qemu_co_queue_wait(&req->wait_queue);
1737 retry = true;
1738 break;
1741 } while (retry);
1745 * Return values:
1746 * 0 - success
1747 * -EINVAL - backing format specified, but no file
1748 * -ENOSPC - can't update the backing file because no space is left in the
1749 * image file header
1750 * -ENOTSUP - format driver doesn't support changing the backing file
1752 int bdrv_change_backing_file(BlockDriverState *bs,
1753 const char *backing_file, const char *backing_fmt)
1755 BlockDriver *drv = bs->drv;
1756 int ret;
1758 /* Backing file format doesn't make sense without a backing file */
1759 if (backing_fmt && !backing_file) {
1760 return -EINVAL;
1763 if (drv->bdrv_change_backing_file != NULL) {
1764 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
1765 } else {
1766 ret = -ENOTSUP;
1769 if (ret == 0) {
1770 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
1771 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
1773 return ret;
1777 * Finds the image layer in the chain that has 'bs' as its backing file.
1779 * active is the current topmost image.
1781 * Returns NULL if bs is not found in active's image chain,
1782 * or if active == bs.
1784 BlockDriverState *bdrv_find_overlay(BlockDriverState *active,
1785 BlockDriverState *bs)
1787 BlockDriverState *overlay = NULL;
1788 BlockDriverState *intermediate;
1790 assert(active != NULL);
1791 assert(bs != NULL);
1793 /* if bs is the same as active, then by definition it has no overlay
1795 if (active == bs) {
1796 return NULL;
1799 intermediate = active;
1800 while (intermediate->backing_hd) {
1801 if (intermediate->backing_hd == bs) {
1802 overlay = intermediate;
1803 break;
1805 intermediate = intermediate->backing_hd;
1808 return overlay;
1811 typedef struct BlkIntermediateStates {
1812 BlockDriverState *bs;
1813 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry;
1814 } BlkIntermediateStates;
1818 * Drops images above 'base' up to and including 'top', and sets the image
1819 * above 'top' to have base as its backing file.
1821 * Requires that the overlay to 'top' is opened r/w, so that the backing file
1822 * information in 'bs' can be properly updated.
1824 * E.g., this will convert the following chain:
1825 * bottom <- base <- intermediate <- top <- active
1827 * to
1829 * bottom <- base <- active
1831 * It is allowed for bottom==base, in which case it converts:
1833 * base <- intermediate <- top <- active
1835 * to
1837 * base <- active
1839 * Error conditions:
1840 * if active == top, that is considered an error
1843 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top,
1844 BlockDriverState *base)
1846 BlockDriverState *intermediate;
1847 BlockDriverState *base_bs = NULL;
1848 BlockDriverState *new_top_bs = NULL;
1849 BlkIntermediateStates *intermediate_state, *next;
1850 int ret = -EIO;
1852 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete;
1853 QSIMPLEQ_INIT(&states_to_delete);
1855 if (!top->drv || !base->drv) {
1856 goto exit;
1859 new_top_bs = bdrv_find_overlay(active, top);
1861 if (new_top_bs == NULL) {
1862 /* we could not find the image above 'top', this is an error */
1863 goto exit;
1866 /* special case of new_top_bs->backing_hd already pointing to base - nothing
1867 * to do, no intermediate images */
1868 if (new_top_bs->backing_hd == base) {
1869 ret = 0;
1870 goto exit;
1873 intermediate = top;
1875 /* now we will go down through the list, and add each BDS we find
1876 * into our deletion queue, until we hit the 'base'
1878 while (intermediate) {
1879 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));
1880 intermediate_state->bs = intermediate;
1881 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
1883 if (intermediate->backing_hd == base) {
1884 base_bs = intermediate->backing_hd;
1885 break;
1887 intermediate = intermediate->backing_hd;
1889 if (base_bs == NULL) {
1890 /* something went wrong, we did not end at the base. safely
1891 * unravel everything, and exit with error */
1892 goto exit;
1895 /* success - we can delete the intermediate states, and link top->base */
1896 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename,
1897 base_bs->drv ? base_bs->drv->format_name : "");
1898 if (ret) {
1899 goto exit;
1901 new_top_bs->backing_hd = base_bs;
1904 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1905 /* so that bdrv_close() does not recursively close the chain */
1906 intermediate_state->bs->backing_hd = NULL;
1907 bdrv_delete(intermediate_state->bs);
1909 ret = 0;
1911 exit:
1912 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) {
1913 g_free(intermediate_state);
1915 return ret;
1919 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
1920 size_t size)
1922 int64_t len;
1924 if (!bdrv_is_inserted(bs))
1925 return -ENOMEDIUM;
1927 if (bs->growable)
1928 return 0;
1930 len = bdrv_getlength(bs);
1932 if (offset < 0)
1933 return -EIO;
1935 if ((offset > len) || (len - offset < size))
1936 return -EIO;
1938 return 0;
1941 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
1942 int nb_sectors)
1944 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
1945 nb_sectors * BDRV_SECTOR_SIZE);
1948 typedef struct RwCo {
1949 BlockDriverState *bs;
1950 int64_t sector_num;
1951 int nb_sectors;
1952 QEMUIOVector *qiov;
1953 bool is_write;
1954 int ret;
1955 } RwCo;
1957 static void coroutine_fn bdrv_rw_co_entry(void *opaque)
1959 RwCo *rwco = opaque;
1961 if (!rwco->is_write) {
1962 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num,
1963 rwco->nb_sectors, rwco->qiov, 0);
1964 } else {
1965 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num,
1966 rwco->nb_sectors, rwco->qiov, 0);
1971 * Process a synchronous request using coroutines
1973 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
1974 int nb_sectors, bool is_write)
1976 QEMUIOVector qiov;
1977 struct iovec iov = {
1978 .iov_base = (void *)buf,
1979 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
1981 Coroutine *co;
1982 RwCo rwco = {
1983 .bs = bs,
1984 .sector_num = sector_num,
1985 .nb_sectors = nb_sectors,
1986 .qiov = &qiov,
1987 .is_write = is_write,
1988 .ret = NOT_DONE,
1991 qemu_iovec_init_external(&qiov, &iov, 1);
1994 * In sync call context, when the vcpu is blocked, this throttling timer
1995 * will not fire; so the I/O throttling function has to be disabled here
1996 * if it has been enabled.
1998 if (bs->io_limits_enabled) {
1999 fprintf(stderr, "Disabling I/O throttling on '%s' due "
2000 "to synchronous I/O.\n", bdrv_get_device_name(bs));
2001 bdrv_io_limits_disable(bs);
2004 if (qemu_in_coroutine()) {
2005 /* Fast-path if already in coroutine context */
2006 bdrv_rw_co_entry(&rwco);
2007 } else {
2008 co = qemu_coroutine_create(bdrv_rw_co_entry);
2009 qemu_coroutine_enter(co, &rwco);
2010 while (rwco.ret == NOT_DONE) {
2011 qemu_aio_wait();
2014 return rwco.ret;
2017 /* return < 0 if error. See bdrv_write() for the return codes */
2018 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
2019 uint8_t *buf, int nb_sectors)
2021 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false);
2024 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */
2025 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num,
2026 uint8_t *buf, int nb_sectors)
2028 bool enabled;
2029 int ret;
2031 enabled = bs->io_limits_enabled;
2032 bs->io_limits_enabled = false;
2033 ret = bdrv_read(bs, 0, buf, 1);
2034 bs->io_limits_enabled = enabled;
2035 return ret;
2038 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
2040 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
2041 int nb_sectors, int dirty)
2043 int64_t start, end;
2044 unsigned long val, idx, bit;
2046 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
2047 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
2049 for (; start <= end; start++) {
2050 idx = start / BITS_PER_LONG;
2051 bit = start % BITS_PER_LONG;
2052 val = bs->dirty_bitmap[idx];
2053 if (dirty) {
2054 if (!(val & (1UL << bit))) {
2055 bs->dirty_count++;
2056 val |= 1UL << bit;
2058 } else {
2059 if (val & (1UL << bit)) {
2060 bs->dirty_count--;
2061 val &= ~(1UL << bit);
2064 bs->dirty_bitmap[idx] = val;
2068 /* Return < 0 if error. Important errors are:
2069 -EIO generic I/O error (may happen for all errors)
2070 -ENOMEDIUM No media inserted.
2071 -EINVAL Invalid sector number or nb_sectors
2072 -EACCES Trying to write a read-only device
2074 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
2075 const uint8_t *buf, int nb_sectors)
2077 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
2080 int bdrv_pread(BlockDriverState *bs, int64_t offset,
2081 void *buf, int count1)
2083 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2084 int len, nb_sectors, count;
2085 int64_t sector_num;
2086 int ret;
2088 count = count1;
2089 /* first read to align to sector start */
2090 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2091 if (len > count)
2092 len = count;
2093 sector_num = offset >> BDRV_SECTOR_BITS;
2094 if (len > 0) {
2095 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2096 return ret;
2097 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len);
2098 count -= len;
2099 if (count == 0)
2100 return count1;
2101 sector_num++;
2102 buf += len;
2105 /* read the sectors "in place" */
2106 nb_sectors = count >> BDRV_SECTOR_BITS;
2107 if (nb_sectors > 0) {
2108 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
2109 return ret;
2110 sector_num += nb_sectors;
2111 len = nb_sectors << BDRV_SECTOR_BITS;
2112 buf += len;
2113 count -= len;
2116 /* add data from the last sector */
2117 if (count > 0) {
2118 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2119 return ret;
2120 memcpy(buf, tmp_buf, count);
2122 return count1;
2125 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
2126 const void *buf, int count1)
2128 uint8_t tmp_buf[BDRV_SECTOR_SIZE];
2129 int len, nb_sectors, count;
2130 int64_t sector_num;
2131 int ret;
2133 count = count1;
2134 /* first write to align to sector start */
2135 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
2136 if (len > count)
2137 len = count;
2138 sector_num = offset >> BDRV_SECTOR_BITS;
2139 if (len > 0) {
2140 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2141 return ret;
2142 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
2143 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2144 return ret;
2145 count -= len;
2146 if (count == 0)
2147 return count1;
2148 sector_num++;
2149 buf += len;
2152 /* write the sectors "in place" */
2153 nb_sectors = count >> BDRV_SECTOR_BITS;
2154 if (nb_sectors > 0) {
2155 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
2156 return ret;
2157 sector_num += nb_sectors;
2158 len = nb_sectors << BDRV_SECTOR_BITS;
2159 buf += len;
2160 count -= len;
2163 /* add data from the last sector */
2164 if (count > 0) {
2165 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
2166 return ret;
2167 memcpy(tmp_buf, buf, count);
2168 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
2169 return ret;
2171 return count1;
2175 * Writes to the file and ensures that no writes are reordered across this
2176 * request (acts as a barrier)
2178 * Returns 0 on success, -errno in error cases.
2180 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
2181 const void *buf, int count)
2183 int ret;
2185 ret = bdrv_pwrite(bs, offset, buf, count);
2186 if (ret < 0) {
2187 return ret;
2190 /* No flush needed for cache modes that already do it */
2191 if (bs->enable_write_cache) {
2192 bdrv_flush(bs);
2195 return 0;
2198 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,
2199 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2201 /* Perform I/O through a temporary buffer so that users who scribble over
2202 * their read buffer while the operation is in progress do not end up
2203 * modifying the image file. This is critical for zero-copy guest I/O
2204 * where anything might happen inside guest memory.
2206 void *bounce_buffer;
2208 BlockDriver *drv = bs->drv;
2209 struct iovec iov;
2210 QEMUIOVector bounce_qiov;
2211 int64_t cluster_sector_num;
2212 int cluster_nb_sectors;
2213 size_t skip_bytes;
2214 int ret;
2216 /* Cover entire cluster so no additional backing file I/O is required when
2217 * allocating cluster in the image file.
2219 round_to_clusters(bs, sector_num, nb_sectors,
2220 &cluster_sector_num, &cluster_nb_sectors);
2222 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,
2223 cluster_sector_num, cluster_nb_sectors);
2225 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;
2226 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len);
2227 qemu_iovec_init_external(&bounce_qiov, &iov, 1);
2229 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors,
2230 &bounce_qiov);
2231 if (ret < 0) {
2232 goto err;
2235 if (drv->bdrv_co_write_zeroes &&
2236 buffer_is_zero(bounce_buffer, iov.iov_len)) {
2237 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num,
2238 cluster_nb_sectors);
2239 } else {
2240 /* This does not change the data on the disk, it is not necessary
2241 * to flush even in cache=writethrough mode.
2243 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors,
2244 &bounce_qiov);
2247 if (ret < 0) {
2248 /* It might be okay to ignore write errors for guest requests. If this
2249 * is a deliberate copy-on-read then we don't want to ignore the error.
2250 * Simply report it in all cases.
2252 goto err;
2255 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;
2256 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,
2257 nb_sectors * BDRV_SECTOR_SIZE);
2259 err:
2260 qemu_vfree(bounce_buffer);
2261 return ret;
2265 * Handle a read request in coroutine context
2267 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs,
2268 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2269 BdrvRequestFlags flags)
2271 BlockDriver *drv = bs->drv;
2272 BdrvTrackedRequest req;
2273 int ret;
2275 if (!drv) {
2276 return -ENOMEDIUM;
2278 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2279 return -EIO;
2282 /* throttling disk read I/O */
2283 if (bs->io_limits_enabled) {
2284 bdrv_io_limits_intercept(bs, false, nb_sectors);
2287 if (bs->copy_on_read) {
2288 flags |= BDRV_REQ_COPY_ON_READ;
2290 if (flags & BDRV_REQ_COPY_ON_READ) {
2291 bs->copy_on_read_in_flight++;
2294 if (bs->copy_on_read_in_flight) {
2295 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2298 tracked_request_begin(&req, bs, sector_num, nb_sectors, false);
2300 if (flags & BDRV_REQ_COPY_ON_READ) {
2301 int pnum;
2303 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum);
2304 if (ret < 0) {
2305 goto out;
2308 if (!ret || pnum != nb_sectors) {
2309 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);
2310 goto out;
2314 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
2316 out:
2317 tracked_request_end(&req);
2319 if (flags & BDRV_REQ_COPY_ON_READ) {
2320 bs->copy_on_read_in_flight--;
2323 return ret;
2326 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,
2327 int nb_sectors, QEMUIOVector *qiov)
2329 trace_bdrv_co_readv(bs, sector_num, nb_sectors);
2331 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0);
2334 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs,
2335 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
2337 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors);
2339 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov,
2340 BDRV_REQ_COPY_ON_READ);
2343 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
2344 int64_t sector_num, int nb_sectors)
2346 BlockDriver *drv = bs->drv;
2347 QEMUIOVector qiov;
2348 struct iovec iov;
2349 int ret;
2351 /* TODO Emulate only part of misaligned requests instead of letting block
2352 * drivers return -ENOTSUP and emulate everything */
2354 /* First try the efficient write zeroes operation */
2355 if (drv->bdrv_co_write_zeroes) {
2356 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2357 if (ret != -ENOTSUP) {
2358 return ret;
2362 /* Fall back to bounce buffer if write zeroes is unsupported */
2363 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE;
2364 iov.iov_base = qemu_blockalign(bs, iov.iov_len);
2365 memset(iov.iov_base, 0, iov.iov_len);
2366 qemu_iovec_init_external(&qiov, &iov, 1);
2368 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov);
2370 qemu_vfree(iov.iov_base);
2371 return ret;
2375 * Handle a write request in coroutine context
2377 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs,
2378 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,
2379 BdrvRequestFlags flags)
2381 BlockDriver *drv = bs->drv;
2382 BdrvTrackedRequest req;
2383 int ret;
2385 if (!bs->drv) {
2386 return -ENOMEDIUM;
2388 if (bs->read_only) {
2389 return -EACCES;
2391 if (bdrv_check_request(bs, sector_num, nb_sectors)) {
2392 return -EIO;
2395 /* throttling disk write I/O */
2396 if (bs->io_limits_enabled) {
2397 bdrv_io_limits_intercept(bs, true, nb_sectors);
2400 if (bs->copy_on_read_in_flight) {
2401 wait_for_overlapping_requests(bs, sector_num, nb_sectors);
2404 tracked_request_begin(&req, bs, sector_num, nb_sectors, true);
2406 if (flags & BDRV_REQ_ZERO_WRITE) {
2407 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors);
2408 } else {
2409 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov);
2412 if (ret == 0 && !bs->enable_write_cache) {
2413 ret = bdrv_co_flush(bs);
2416 if (bs->dirty_bitmap) {
2417 bdrv_set_dirty(bs, sector_num, nb_sectors);
2420 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2421 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2424 tracked_request_end(&req);
2426 return ret;
2429 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num,
2430 int nb_sectors, QEMUIOVector *qiov)
2432 trace_bdrv_co_writev(bs, sector_num, nb_sectors);
2434 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0);
2437 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs,
2438 int64_t sector_num, int nb_sectors)
2440 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors);
2442 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL,
2443 BDRV_REQ_ZERO_WRITE);
2447 * Truncate file to 'offset' bytes (needed only for file protocols)
2449 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
2451 BlockDriver *drv = bs->drv;
2452 int ret;
2453 if (!drv)
2454 return -ENOMEDIUM;
2455 if (!drv->bdrv_truncate)
2456 return -ENOTSUP;
2457 if (bs->read_only)
2458 return -EACCES;
2459 if (bdrv_in_use(bs))
2460 return -EBUSY;
2461 ret = drv->bdrv_truncate(bs, offset);
2462 if (ret == 0) {
2463 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
2464 bdrv_dev_resize_cb(bs);
2466 return ret;
2470 * Length of a allocated file in bytes. Sparse files are counted by actual
2471 * allocated space. Return < 0 if error or unknown.
2473 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)
2475 BlockDriver *drv = bs->drv;
2476 if (!drv) {
2477 return -ENOMEDIUM;
2479 if (drv->bdrv_get_allocated_file_size) {
2480 return drv->bdrv_get_allocated_file_size(bs);
2482 if (bs->file) {
2483 return bdrv_get_allocated_file_size(bs->file);
2485 return -ENOTSUP;
2489 * Length of a file in bytes. Return < 0 if error or unknown.
2491 int64_t bdrv_getlength(BlockDriverState *bs)
2493 BlockDriver *drv = bs->drv;
2494 if (!drv)
2495 return -ENOMEDIUM;
2497 if (bs->growable || bdrv_dev_has_removable_media(bs)) {
2498 if (drv->bdrv_getlength) {
2499 return drv->bdrv_getlength(bs);
2502 return bs->total_sectors * BDRV_SECTOR_SIZE;
2505 /* return 0 as number of sectors if no device present or error */
2506 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
2508 int64_t length;
2509 length = bdrv_getlength(bs);
2510 if (length < 0)
2511 length = 0;
2512 else
2513 length = length >> BDRV_SECTOR_BITS;
2514 *nb_sectors_ptr = length;
2517 /* throttling disk io limits */
2518 void bdrv_set_io_limits(BlockDriverState *bs,
2519 BlockIOLimit *io_limits)
2521 bs->io_limits = *io_limits;
2522 bs->io_limits_enabled = bdrv_io_limits_enabled(bs);
2525 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error,
2526 BlockdevOnError on_write_error)
2528 bs->on_read_error = on_read_error;
2529 bs->on_write_error = on_write_error;
2532 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read)
2534 return is_read ? bs->on_read_error : bs->on_write_error;
2537 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error)
2539 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error;
2541 switch (on_err) {
2542 case BLOCKDEV_ON_ERROR_ENOSPC:
2543 return (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
2544 case BLOCKDEV_ON_ERROR_STOP:
2545 return BDRV_ACTION_STOP;
2546 case BLOCKDEV_ON_ERROR_REPORT:
2547 return BDRV_ACTION_REPORT;
2548 case BLOCKDEV_ON_ERROR_IGNORE:
2549 return BDRV_ACTION_IGNORE;
2550 default:
2551 abort();
2555 /* This is done by device models because, while the block layer knows
2556 * about the error, it does not know whether an operation comes from
2557 * the device or the block layer (from a job, for example).
2559 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
2560 bool is_read, int error)
2562 assert(error >= 0);
2563 bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
2564 if (action == BDRV_ACTION_STOP) {
2565 vm_stop(RUN_STATE_IO_ERROR);
2566 bdrv_iostatus_set_err(bs, error);
2570 int bdrv_is_read_only(BlockDriverState *bs)
2572 return bs->read_only;
2575 int bdrv_is_sg(BlockDriverState *bs)
2577 return bs->sg;
2580 int bdrv_enable_write_cache(BlockDriverState *bs)
2582 return bs->enable_write_cache;
2585 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce)
2587 bs->enable_write_cache = wce;
2589 /* so a reopen() will preserve wce */
2590 if (wce) {
2591 bs->open_flags |= BDRV_O_CACHE_WB;
2592 } else {
2593 bs->open_flags &= ~BDRV_O_CACHE_WB;
2597 int bdrv_is_encrypted(BlockDriverState *bs)
2599 if (bs->backing_hd && bs->backing_hd->encrypted)
2600 return 1;
2601 return bs->encrypted;
2604 int bdrv_key_required(BlockDriverState *bs)
2606 BlockDriverState *backing_hd = bs->backing_hd;
2608 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
2609 return 1;
2610 return (bs->encrypted && !bs->valid_key);
2613 int bdrv_set_key(BlockDriverState *bs, const char *key)
2615 int ret;
2616 if (bs->backing_hd && bs->backing_hd->encrypted) {
2617 ret = bdrv_set_key(bs->backing_hd, key);
2618 if (ret < 0)
2619 return ret;
2620 if (!bs->encrypted)
2621 return 0;
2623 if (!bs->encrypted) {
2624 return -EINVAL;
2625 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
2626 return -ENOMEDIUM;
2628 ret = bs->drv->bdrv_set_key(bs, key);
2629 if (ret < 0) {
2630 bs->valid_key = 0;
2631 } else if (!bs->valid_key) {
2632 bs->valid_key = 1;
2633 /* call the change callback now, we skipped it on open */
2634 bdrv_dev_change_media_cb(bs, true);
2636 return ret;
2639 const char *bdrv_get_format_name(BlockDriverState *bs)
2641 return bs->drv ? bs->drv->format_name : NULL;
2644 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
2645 void *opaque)
2647 BlockDriver *drv;
2649 QLIST_FOREACH(drv, &bdrv_drivers, list) {
2650 it(opaque, drv->format_name);
2654 BlockDriverState *bdrv_find(const char *name)
2656 BlockDriverState *bs;
2658 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2659 if (!strcmp(name, bs->device_name)) {
2660 return bs;
2663 return NULL;
2666 BlockDriverState *bdrv_next(BlockDriverState *bs)
2668 if (!bs) {
2669 return QTAILQ_FIRST(&bdrv_states);
2671 return QTAILQ_NEXT(bs, list);
2674 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
2676 BlockDriverState *bs;
2678 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2679 it(opaque, bs);
2683 const char *bdrv_get_device_name(BlockDriverState *bs)
2685 return bs->device_name;
2688 int bdrv_get_flags(BlockDriverState *bs)
2690 return bs->open_flags;
2693 void bdrv_flush_all(void)
2695 BlockDriverState *bs;
2697 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2698 bdrv_flush(bs);
2702 int bdrv_has_zero_init(BlockDriverState *bs)
2704 assert(bs->drv);
2706 if (bs->drv->bdrv_has_zero_init) {
2707 return bs->drv->bdrv_has_zero_init(bs);
2710 return 1;
2713 typedef struct BdrvCoIsAllocatedData {
2714 BlockDriverState *bs;
2715 int64_t sector_num;
2716 int nb_sectors;
2717 int *pnum;
2718 int ret;
2719 bool done;
2720 } BdrvCoIsAllocatedData;
2723 * Returns true iff the specified sector is present in the disk image. Drivers
2724 * not implementing the functionality are assumed to not support backing files,
2725 * hence all their sectors are reported as allocated.
2727 * If 'sector_num' is beyond the end of the disk image the return value is 0
2728 * and 'pnum' is set to 0.
2730 * 'pnum' is set to the number of sectors (including and immediately following
2731 * the specified sector) that are known to be in the same
2732 * allocated/unallocated state.
2734 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
2735 * beyond the end of the disk image it will be clamped.
2737 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num,
2738 int nb_sectors, int *pnum)
2740 int64_t n;
2742 if (sector_num >= bs->total_sectors) {
2743 *pnum = 0;
2744 return 0;
2747 n = bs->total_sectors - sector_num;
2748 if (n < nb_sectors) {
2749 nb_sectors = n;
2752 if (!bs->drv->bdrv_co_is_allocated) {
2753 *pnum = nb_sectors;
2754 return 1;
2757 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum);
2760 /* Coroutine wrapper for bdrv_is_allocated() */
2761 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque)
2763 BdrvCoIsAllocatedData *data = opaque;
2764 BlockDriverState *bs = data->bs;
2766 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors,
2767 data->pnum);
2768 data->done = true;
2772 * Synchronous wrapper around bdrv_co_is_allocated().
2774 * See bdrv_co_is_allocated() for details.
2776 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
2777 int *pnum)
2779 Coroutine *co;
2780 BdrvCoIsAllocatedData data = {
2781 .bs = bs,
2782 .sector_num = sector_num,
2783 .nb_sectors = nb_sectors,
2784 .pnum = pnum,
2785 .done = false,
2788 co = qemu_coroutine_create(bdrv_is_allocated_co_entry);
2789 qemu_coroutine_enter(co, &data);
2790 while (!data.done) {
2791 qemu_aio_wait();
2793 return data.ret;
2797 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]
2799 * Return true if the given sector is allocated in any image between
2800 * BASE and TOP (inclusive). BASE can be NULL to check if the given
2801 * sector is allocated in any image of the chain. Return false otherwise.
2803 * 'pnum' is set to the number of sectors (including and immediately following
2804 * the specified sector) that are known to be in the same
2805 * allocated/unallocated state.
2808 int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top,
2809 BlockDriverState *base,
2810 int64_t sector_num,
2811 int nb_sectors, int *pnum)
2813 BlockDriverState *intermediate;
2814 int ret, n = nb_sectors;
2816 intermediate = top;
2817 while (intermediate && intermediate != base) {
2818 int pnum_inter;
2819 ret = bdrv_co_is_allocated(intermediate, sector_num, nb_sectors,
2820 &pnum_inter);
2821 if (ret < 0) {
2822 return ret;
2823 } else if (ret) {
2824 *pnum = pnum_inter;
2825 return 1;
2829 * [sector_num, nb_sectors] is unallocated on top but intermediate
2830 * might have
2832 * [sector_num+x, nr_sectors] allocated.
2834 if (n > pnum_inter) {
2835 n = pnum_inter;
2838 intermediate = intermediate->backing_hd;
2841 *pnum = n;
2842 return 0;
2845 BlockInfo *bdrv_query_info(BlockDriverState *bs)
2847 BlockInfo *info = g_malloc0(sizeof(*info));
2848 info->device = g_strdup(bs->device_name);
2849 info->type = g_strdup("unknown");
2850 info->locked = bdrv_dev_is_medium_locked(bs);
2851 info->removable = bdrv_dev_has_removable_media(bs);
2853 if (bdrv_dev_has_removable_media(bs)) {
2854 info->has_tray_open = true;
2855 info->tray_open = bdrv_dev_is_tray_open(bs);
2858 if (bdrv_iostatus_is_enabled(bs)) {
2859 info->has_io_status = true;
2860 info->io_status = bs->iostatus;
2863 if (bs->dirty_bitmap) {
2864 info->has_dirty = true;
2865 info->dirty = g_malloc0(sizeof(*info->dirty));
2866 info->dirty->count = bdrv_get_dirty_count(bs) *
2867 BDRV_SECTORS_PER_DIRTY_CHUNK * BDRV_SECTOR_SIZE;
2870 if (bs->drv) {
2871 info->has_inserted = true;
2872 info->inserted = g_malloc0(sizeof(*info->inserted));
2873 info->inserted->file = g_strdup(bs->filename);
2874 info->inserted->ro = bs->read_only;
2875 info->inserted->drv = g_strdup(bs->drv->format_name);
2876 info->inserted->encrypted = bs->encrypted;
2877 info->inserted->encryption_key_missing = bdrv_key_required(bs);
2879 if (bs->backing_file[0]) {
2880 info->inserted->has_backing_file = true;
2881 info->inserted->backing_file = g_strdup(bs->backing_file);
2884 info->inserted->backing_file_depth = bdrv_get_backing_file_depth(bs);
2886 if (bs->io_limits_enabled) {
2887 info->inserted->bps =
2888 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
2889 info->inserted->bps_rd =
2890 bs->io_limits.bps[BLOCK_IO_LIMIT_READ];
2891 info->inserted->bps_wr =
2892 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE];
2893 info->inserted->iops =
2894 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
2895 info->inserted->iops_rd =
2896 bs->io_limits.iops[BLOCK_IO_LIMIT_READ];
2897 info->inserted->iops_wr =
2898 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE];
2901 return info;
2904 BlockInfoList *qmp_query_block(Error **errp)
2906 BlockInfoList *head = NULL, **p_next = &head;
2907 BlockDriverState *bs;
2909 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2910 BlockInfoList *info = g_malloc0(sizeof(*info));
2911 info->value = bdrv_query_info(bs);
2913 *p_next = info;
2914 p_next = &info->next;
2917 return head;
2920 BlockStats *bdrv_query_stats(const BlockDriverState *bs)
2922 BlockStats *s;
2924 s = g_malloc0(sizeof(*s));
2926 if (bs->device_name[0]) {
2927 s->has_device = true;
2928 s->device = g_strdup(bs->device_name);
2931 s->stats = g_malloc0(sizeof(*s->stats));
2932 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ];
2933 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE];
2934 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ];
2935 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE];
2936 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE;
2937 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH];
2938 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE];
2939 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ];
2940 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH];
2942 if (bs->file) {
2943 s->has_parent = true;
2944 s->parent = bdrv_query_stats(bs->file);
2947 return s;
2950 BlockStatsList *qmp_query_blockstats(Error **errp)
2952 BlockStatsList *head = NULL, **p_next = &head;
2953 BlockDriverState *bs;
2955 QTAILQ_FOREACH(bs, &bdrv_states, list) {
2956 BlockStatsList *info = g_malloc0(sizeof(*info));
2957 info->value = bdrv_query_stats(bs);
2959 *p_next = info;
2960 p_next = &info->next;
2963 return head;
2966 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
2968 if (bs->backing_hd && bs->backing_hd->encrypted)
2969 return bs->backing_file;
2970 else if (bs->encrypted)
2971 return bs->filename;
2972 else
2973 return NULL;
2976 void bdrv_get_backing_filename(BlockDriverState *bs,
2977 char *filename, int filename_size)
2979 pstrcpy(filename, filename_size, bs->backing_file);
2982 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
2983 const uint8_t *buf, int nb_sectors)
2985 BlockDriver *drv = bs->drv;
2986 if (!drv)
2987 return -ENOMEDIUM;
2988 if (!drv->bdrv_write_compressed)
2989 return -ENOTSUP;
2990 if (bdrv_check_request(bs, sector_num, nb_sectors))
2991 return -EIO;
2993 assert(!bs->dirty_bitmap);
2995 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
2998 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3000 BlockDriver *drv = bs->drv;
3001 if (!drv)
3002 return -ENOMEDIUM;
3003 if (!drv->bdrv_get_info)
3004 return -ENOTSUP;
3005 memset(bdi, 0, sizeof(*bdi));
3006 return drv->bdrv_get_info(bs, bdi);
3009 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
3010 int64_t pos, int size)
3012 BlockDriver *drv = bs->drv;
3013 if (!drv)
3014 return -ENOMEDIUM;
3015 if (drv->bdrv_save_vmstate)
3016 return drv->bdrv_save_vmstate(bs, buf, pos, size);
3017 if (bs->file)
3018 return bdrv_save_vmstate(bs->file, buf, pos, size);
3019 return -ENOTSUP;
3022 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
3023 int64_t pos, int size)
3025 BlockDriver *drv = bs->drv;
3026 if (!drv)
3027 return -ENOMEDIUM;
3028 if (drv->bdrv_load_vmstate)
3029 return drv->bdrv_load_vmstate(bs, buf, pos, size);
3030 if (bs->file)
3031 return bdrv_load_vmstate(bs->file, buf, pos, size);
3032 return -ENOTSUP;
3035 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
3037 BlockDriver *drv = bs->drv;
3039 if (!drv || !drv->bdrv_debug_event) {
3040 return;
3043 drv->bdrv_debug_event(bs, event);
3046 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event,
3047 const char *tag)
3049 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) {
3050 bs = bs->file;
3053 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
3054 return bs->drv->bdrv_debug_breakpoint(bs, event, tag);
3057 return -ENOTSUP;
3060 int bdrv_debug_resume(BlockDriverState *bs, const char *tag)
3062 while (bs && bs->drv && !bs->drv->bdrv_debug_resume) {
3063 bs = bs->file;
3066 if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
3067 return bs->drv->bdrv_debug_resume(bs, tag);
3070 return -ENOTSUP;
3073 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag)
3075 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) {
3076 bs = bs->file;
3079 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
3080 return bs->drv->bdrv_debug_is_suspended(bs, tag);
3083 return false;
3086 /**************************************************************/
3087 /* handling of snapshots */
3089 int bdrv_can_snapshot(BlockDriverState *bs)
3091 BlockDriver *drv = bs->drv;
3092 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
3093 return 0;
3096 if (!drv->bdrv_snapshot_create) {
3097 if (bs->file != NULL) {
3098 return bdrv_can_snapshot(bs->file);
3100 return 0;
3103 return 1;
3106 int bdrv_is_snapshot(BlockDriverState *bs)
3108 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
3111 BlockDriverState *bdrv_snapshots(void)
3113 BlockDriverState *bs;
3115 if (bs_snapshots) {
3116 return bs_snapshots;
3119 bs = NULL;
3120 while ((bs = bdrv_next(bs))) {
3121 if (bdrv_can_snapshot(bs)) {
3122 bs_snapshots = bs;
3123 return bs;
3126 return NULL;
3129 int bdrv_snapshot_create(BlockDriverState *bs,
3130 QEMUSnapshotInfo *sn_info)
3132 BlockDriver *drv = bs->drv;
3133 if (!drv)
3134 return -ENOMEDIUM;
3135 if (drv->bdrv_snapshot_create)
3136 return drv->bdrv_snapshot_create(bs, sn_info);
3137 if (bs->file)
3138 return bdrv_snapshot_create(bs->file, sn_info);
3139 return -ENOTSUP;
3142 int bdrv_snapshot_goto(BlockDriverState *bs,
3143 const char *snapshot_id)
3145 BlockDriver *drv = bs->drv;
3146 int ret, open_ret;
3148 if (!drv)
3149 return -ENOMEDIUM;
3150 if (drv->bdrv_snapshot_goto)
3151 return drv->bdrv_snapshot_goto(bs, snapshot_id);
3153 if (bs->file) {
3154 drv->bdrv_close(bs);
3155 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
3156 open_ret = drv->bdrv_open(bs, bs->open_flags);
3157 if (open_ret < 0) {
3158 bdrv_delete(bs->file);
3159 bs->drv = NULL;
3160 return open_ret;
3162 return ret;
3165 return -ENOTSUP;
3168 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
3170 BlockDriver *drv = bs->drv;
3171 if (!drv)
3172 return -ENOMEDIUM;
3173 if (drv->bdrv_snapshot_delete)
3174 return drv->bdrv_snapshot_delete(bs, snapshot_id);
3175 if (bs->file)
3176 return bdrv_snapshot_delete(bs->file, snapshot_id);
3177 return -ENOTSUP;
3180 int bdrv_snapshot_list(BlockDriverState *bs,
3181 QEMUSnapshotInfo **psn_info)
3183 BlockDriver *drv = bs->drv;
3184 if (!drv)
3185 return -ENOMEDIUM;
3186 if (drv->bdrv_snapshot_list)
3187 return drv->bdrv_snapshot_list(bs, psn_info);
3188 if (bs->file)
3189 return bdrv_snapshot_list(bs->file, psn_info);
3190 return -ENOTSUP;
3193 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
3194 const char *snapshot_name)
3196 BlockDriver *drv = bs->drv;
3197 if (!drv) {
3198 return -ENOMEDIUM;
3200 if (!bs->read_only) {
3201 return -EINVAL;
3203 if (drv->bdrv_snapshot_load_tmp) {
3204 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name);
3206 return -ENOTSUP;
3209 /* backing_file can either be relative, or absolute, or a protocol. If it is
3210 * relative, it must be relative to the chain. So, passing in bs->filename
3211 * from a BDS as backing_file should not be done, as that may be relative to
3212 * the CWD rather than the chain. */
3213 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
3214 const char *backing_file)
3216 char *filename_full = NULL;
3217 char *backing_file_full = NULL;
3218 char *filename_tmp = NULL;
3219 int is_protocol = 0;
3220 BlockDriverState *curr_bs = NULL;
3221 BlockDriverState *retval = NULL;
3223 if (!bs || !bs->drv || !backing_file) {
3224 return NULL;
3227 filename_full = g_malloc(PATH_MAX);
3228 backing_file_full = g_malloc(PATH_MAX);
3229 filename_tmp = g_malloc(PATH_MAX);
3231 is_protocol = path_has_protocol(backing_file);
3233 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) {
3235 /* If either of the filename paths is actually a protocol, then
3236 * compare unmodified paths; otherwise make paths relative */
3237 if (is_protocol || path_has_protocol(curr_bs->backing_file)) {
3238 if (strcmp(backing_file, curr_bs->backing_file) == 0) {
3239 retval = curr_bs->backing_hd;
3240 break;
3242 } else {
3243 /* If not an absolute filename path, make it relative to the current
3244 * image's filename path */
3245 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3246 backing_file);
3248 /* We are going to compare absolute pathnames */
3249 if (!realpath(filename_tmp, filename_full)) {
3250 continue;
3253 /* We need to make sure the backing filename we are comparing against
3254 * is relative to the current image filename (or absolute) */
3255 path_combine(filename_tmp, PATH_MAX, curr_bs->filename,
3256 curr_bs->backing_file);
3258 if (!realpath(filename_tmp, backing_file_full)) {
3259 continue;
3262 if (strcmp(backing_file_full, filename_full) == 0) {
3263 retval = curr_bs->backing_hd;
3264 break;
3269 g_free(filename_full);
3270 g_free(backing_file_full);
3271 g_free(filename_tmp);
3272 return retval;
3275 int bdrv_get_backing_file_depth(BlockDriverState *bs)
3277 if (!bs->drv) {
3278 return 0;
3281 if (!bs->backing_hd) {
3282 return 0;
3285 return 1 + bdrv_get_backing_file_depth(bs->backing_hd);
3288 BlockDriverState *bdrv_find_base(BlockDriverState *bs)
3290 BlockDriverState *curr_bs = NULL;
3292 if (!bs) {
3293 return NULL;
3296 curr_bs = bs;
3298 while (curr_bs->backing_hd) {
3299 curr_bs = curr_bs->backing_hd;
3301 return curr_bs;
3304 #define NB_SUFFIXES 4
3306 char *get_human_readable_size(char *buf, int buf_size, int64_t size)
3308 static const char suffixes[NB_SUFFIXES] = "KMGT";
3309 int64_t base;
3310 int i;
3312 if (size <= 999) {
3313 snprintf(buf, buf_size, "%" PRId64, size);
3314 } else {
3315 base = 1024;
3316 for(i = 0; i < NB_SUFFIXES; i++) {
3317 if (size < (10 * base)) {
3318 snprintf(buf, buf_size, "%0.1f%c",
3319 (double)size / base,
3320 suffixes[i]);
3321 break;
3322 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
3323 snprintf(buf, buf_size, "%" PRId64 "%c",
3324 ((size + (base >> 1)) / base),
3325 suffixes[i]);
3326 break;
3328 base = base * 1024;
3331 return buf;
3334 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn)
3336 char buf1[128], date_buf[128], clock_buf[128];
3337 struct tm tm;
3338 time_t ti;
3339 int64_t secs;
3341 if (!sn) {
3342 snprintf(buf, buf_size,
3343 "%-10s%-20s%7s%20s%15s",
3344 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
3345 } else {
3346 ti = sn->date_sec;
3347 localtime_r(&ti, &tm);
3348 strftime(date_buf, sizeof(date_buf),
3349 "%Y-%m-%d %H:%M:%S", &tm);
3350 secs = sn->vm_clock_nsec / 1000000000;
3351 snprintf(clock_buf, sizeof(clock_buf),
3352 "%02d:%02d:%02d.%03d",
3353 (int)(secs / 3600),
3354 (int)((secs / 60) % 60),
3355 (int)(secs % 60),
3356 (int)((sn->vm_clock_nsec / 1000000) % 1000));
3357 snprintf(buf, buf_size,
3358 "%-10s%-20s%7s%20s%15s",
3359 sn->id_str, sn->name,
3360 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),
3361 date_buf,
3362 clock_buf);
3364 return buf;
3367 /**************************************************************/
3368 /* async I/Os */
3370 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
3371 QEMUIOVector *qiov, int nb_sectors,
3372 BlockDriverCompletionFunc *cb, void *opaque)
3374 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
3376 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3377 cb, opaque, false);
3380 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
3381 QEMUIOVector *qiov, int nb_sectors,
3382 BlockDriverCompletionFunc *cb, void *opaque)
3384 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
3386 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors,
3387 cb, opaque, true);
3391 typedef struct MultiwriteCB {
3392 int error;
3393 int num_requests;
3394 int num_callbacks;
3395 struct {
3396 BlockDriverCompletionFunc *cb;
3397 void *opaque;
3398 QEMUIOVector *free_qiov;
3399 } callbacks[];
3400 } MultiwriteCB;
3402 static void multiwrite_user_cb(MultiwriteCB *mcb)
3404 int i;
3406 for (i = 0; i < mcb->num_callbacks; i++) {
3407 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);
3408 if (mcb->callbacks[i].free_qiov) {
3409 qemu_iovec_destroy(mcb->callbacks[i].free_qiov);
3411 g_free(mcb->callbacks[i].free_qiov);
3415 static void multiwrite_cb(void *opaque, int ret)
3417 MultiwriteCB *mcb = opaque;
3419 trace_multiwrite_cb(mcb, ret);
3421 if (ret < 0 && !mcb->error) {
3422 mcb->error = ret;
3425 mcb->num_requests--;
3426 if (mcb->num_requests == 0) {
3427 multiwrite_user_cb(mcb);
3428 g_free(mcb);
3432 static int multiwrite_req_compare(const void *a, const void *b)
3434 const BlockRequest *req1 = a, *req2 = b;
3437 * Note that we can't simply subtract req2->sector from req1->sector
3438 * here as that could overflow the return value.
3440 if (req1->sector > req2->sector) {
3441 return 1;
3442 } else if (req1->sector < req2->sector) {
3443 return -1;
3444 } else {
3445 return 0;
3450 * Takes a bunch of requests and tries to merge them. Returns the number of
3451 * requests that remain after merging.
3453 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
3454 int num_reqs, MultiwriteCB *mcb)
3456 int i, outidx;
3458 // Sort requests by start sector
3459 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);
3461 // Check if adjacent requests touch the same clusters. If so, combine them,
3462 // filling up gaps with zero sectors.
3463 outidx = 0;
3464 for (i = 1; i < num_reqs; i++) {
3465 int merge = 0;
3466 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;
3468 // Handle exactly sequential writes and overlapping writes.
3469 if (reqs[i].sector <= oldreq_last) {
3470 merge = 1;
3473 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) {
3474 merge = 0;
3477 if (merge) {
3478 size_t size;
3479 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
3480 qemu_iovec_init(qiov,
3481 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);
3483 // Add the first request to the merged one. If the requests are
3484 // overlapping, drop the last sectors of the first request.
3485 size = (reqs[i].sector - reqs[outidx].sector) << 9;
3486 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);
3488 // We should need to add any zeros between the two requests
3489 assert (reqs[i].sector <= oldreq_last);
3491 // Add the second request
3492 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);
3494 reqs[outidx].nb_sectors = qiov->size >> 9;
3495 reqs[outidx].qiov = qiov;
3497 mcb->callbacks[i].free_qiov = reqs[outidx].qiov;
3498 } else {
3499 outidx++;
3500 reqs[outidx].sector = reqs[i].sector;
3501 reqs[outidx].nb_sectors = reqs[i].nb_sectors;
3502 reqs[outidx].qiov = reqs[i].qiov;
3506 return outidx + 1;
3510 * Submit multiple AIO write requests at once.
3512 * On success, the function returns 0 and all requests in the reqs array have
3513 * been submitted. In error case this function returns -1, and any of the
3514 * requests may or may not be submitted yet. In particular, this means that the
3515 * callback will be called for some of the requests, for others it won't. The
3516 * caller must check the error field of the BlockRequest to wait for the right
3517 * callbacks (if error != 0, no callback will be called).
3519 * The implementation may modify the contents of the reqs array, e.g. to merge
3520 * requests. However, the fields opaque and error are left unmodified as they
3521 * are used to signal failure for a single request to the caller.
3523 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
3525 MultiwriteCB *mcb;
3526 int i;
3528 /* don't submit writes if we don't have a medium */
3529 if (bs->drv == NULL) {
3530 for (i = 0; i < num_reqs; i++) {
3531 reqs[i].error = -ENOMEDIUM;
3533 return -1;
3536 if (num_reqs == 0) {
3537 return 0;
3540 // Create MultiwriteCB structure
3541 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));
3542 mcb->num_requests = 0;
3543 mcb->num_callbacks = num_reqs;
3545 for (i = 0; i < num_reqs; i++) {
3546 mcb->callbacks[i].cb = reqs[i].cb;
3547 mcb->callbacks[i].opaque = reqs[i].opaque;
3550 // Check for mergable requests
3551 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
3553 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);
3555 /* Run the aio requests. */
3556 mcb->num_requests = num_reqs;
3557 for (i = 0; i < num_reqs; i++) {
3558 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
3559 reqs[i].nb_sectors, multiwrite_cb, mcb);
3562 return 0;
3565 void bdrv_aio_cancel(BlockDriverAIOCB *acb)
3567 acb->aiocb_info->cancel(acb);
3570 /* block I/O throttling */
3571 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors,
3572 bool is_write, double elapsed_time, uint64_t *wait)
3574 uint64_t bps_limit = 0;
3575 double bytes_limit, bytes_base, bytes_res;
3576 double slice_time, wait_time;
3578 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3579 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL];
3580 } else if (bs->io_limits.bps[is_write]) {
3581 bps_limit = bs->io_limits.bps[is_write];
3582 } else {
3583 if (wait) {
3584 *wait = 0;
3587 return false;
3590 slice_time = bs->slice_end - bs->slice_start;
3591 slice_time /= (NANOSECONDS_PER_SECOND);
3592 bytes_limit = bps_limit * slice_time;
3593 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write];
3594 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) {
3595 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write];
3598 /* bytes_base: the bytes of data which have been read/written; and
3599 * it is obtained from the history statistic info.
3600 * bytes_res: the remaining bytes of data which need to be read/written.
3601 * (bytes_base + bytes_res) / bps_limit: used to calcuate
3602 * the total time for completing reading/writting all data.
3604 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
3606 if (bytes_base + bytes_res <= bytes_limit) {
3607 if (wait) {
3608 *wait = 0;
3611 return false;
3614 /* Calc approx time to dispatch */
3615 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time;
3617 /* When the I/O rate at runtime exceeds the limits,
3618 * bs->slice_end need to be extended in order that the current statistic
3619 * info can be kept until the timer fire, so it is increased and tuned
3620 * based on the result of experiment.
3622 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3623 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3624 if (wait) {
3625 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3628 return true;
3631 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write,
3632 double elapsed_time, uint64_t *wait)
3634 uint64_t iops_limit = 0;
3635 double ios_limit, ios_base;
3636 double slice_time, wait_time;
3638 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3639 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL];
3640 } else if (bs->io_limits.iops[is_write]) {
3641 iops_limit = bs->io_limits.iops[is_write];
3642 } else {
3643 if (wait) {
3644 *wait = 0;
3647 return false;
3650 slice_time = bs->slice_end - bs->slice_start;
3651 slice_time /= (NANOSECONDS_PER_SECOND);
3652 ios_limit = iops_limit * slice_time;
3653 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write];
3654 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) {
3655 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write];
3658 if (ios_base + 1 <= ios_limit) {
3659 if (wait) {
3660 *wait = 0;
3663 return false;
3666 /* Calc approx time to dispatch */
3667 wait_time = (ios_base + 1) / iops_limit;
3668 if (wait_time > elapsed_time) {
3669 wait_time = wait_time - elapsed_time;
3670 } else {
3671 wait_time = 0;
3674 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10;
3675 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME;
3676 if (wait) {
3677 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10;
3680 return true;
3683 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors,
3684 bool is_write, int64_t *wait)
3686 int64_t now, max_wait;
3687 uint64_t bps_wait = 0, iops_wait = 0;
3688 double elapsed_time;
3689 int bps_ret, iops_ret;
3691 now = qemu_get_clock_ns(vm_clock);
3692 if ((bs->slice_start < now)
3693 && (bs->slice_end > now)) {
3694 bs->slice_end = now + bs->slice_time;
3695 } else {
3696 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME;
3697 bs->slice_start = now;
3698 bs->slice_end = now + bs->slice_time;
3700 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write];
3701 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write];
3703 bs->io_base.ios[is_write] = bs->nr_ops[is_write];
3704 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write];
3707 elapsed_time = now - bs->slice_start;
3708 elapsed_time /= (NANOSECONDS_PER_SECOND);
3710 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors,
3711 is_write, elapsed_time, &bps_wait);
3712 iops_ret = bdrv_exceed_iops_limits(bs, is_write,
3713 elapsed_time, &iops_wait);
3714 if (bps_ret || iops_ret) {
3715 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait;
3716 if (wait) {
3717 *wait = max_wait;
3720 now = qemu_get_clock_ns(vm_clock);
3721 if (bs->slice_end < now + max_wait) {
3722 bs->slice_end = now + max_wait;
3725 return true;
3728 if (wait) {
3729 *wait = 0;
3732 return false;
3735 /**************************************************************/
3736 /* async block device emulation */
3738 typedef struct BlockDriverAIOCBSync {
3739 BlockDriverAIOCB common;
3740 QEMUBH *bh;
3741 int ret;
3742 /* vector translation state */
3743 QEMUIOVector *qiov;
3744 uint8_t *bounce;
3745 int is_write;
3746 } BlockDriverAIOCBSync;
3748 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb)
3750 BlockDriverAIOCBSync *acb =
3751 container_of(blockacb, BlockDriverAIOCBSync, common);
3752 qemu_bh_delete(acb->bh);
3753 acb->bh = NULL;
3754 qemu_aio_release(acb);
3757 static const AIOCBInfo bdrv_em_aiocb_info = {
3758 .aiocb_size = sizeof(BlockDriverAIOCBSync),
3759 .cancel = bdrv_aio_cancel_em,
3762 static void bdrv_aio_bh_cb(void *opaque)
3764 BlockDriverAIOCBSync *acb = opaque;
3766 if (!acb->is_write)
3767 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
3768 qemu_vfree(acb->bounce);
3769 acb->common.cb(acb->common.opaque, acb->ret);
3770 qemu_bh_delete(acb->bh);
3771 acb->bh = NULL;
3772 qemu_aio_release(acb);
3775 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
3776 int64_t sector_num,
3777 QEMUIOVector *qiov,
3778 int nb_sectors,
3779 BlockDriverCompletionFunc *cb,
3780 void *opaque,
3781 int is_write)
3784 BlockDriverAIOCBSync *acb;
3786 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque);
3787 acb->is_write = is_write;
3788 acb->qiov = qiov;
3789 acb->bounce = qemu_blockalign(bs, qiov->size);
3790 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb);
3792 if (is_write) {
3793 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size);
3794 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
3795 } else {
3796 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
3799 qemu_bh_schedule(acb->bh);
3801 return &acb->common;
3804 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
3805 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3806 BlockDriverCompletionFunc *cb, void *opaque)
3808 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
3811 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
3812 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
3813 BlockDriverCompletionFunc *cb, void *opaque)
3815 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
3819 typedef struct BlockDriverAIOCBCoroutine {
3820 BlockDriverAIOCB common;
3821 BlockRequest req;
3822 bool is_write;
3823 bool *done;
3824 QEMUBH* bh;
3825 } BlockDriverAIOCBCoroutine;
3827 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb)
3829 BlockDriverAIOCBCoroutine *acb =
3830 container_of(blockacb, BlockDriverAIOCBCoroutine, common);
3831 bool done = false;
3833 acb->done = &done;
3834 while (!done) {
3835 qemu_aio_wait();
3839 static const AIOCBInfo bdrv_em_co_aiocb_info = {
3840 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine),
3841 .cancel = bdrv_aio_co_cancel_em,
3844 static void bdrv_co_em_bh(void *opaque)
3846 BlockDriverAIOCBCoroutine *acb = opaque;
3848 acb->common.cb(acb->common.opaque, acb->req.error);
3850 if (acb->done) {
3851 *acb->done = true;
3854 qemu_bh_delete(acb->bh);
3855 qemu_aio_release(acb);
3858 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */
3859 static void coroutine_fn bdrv_co_do_rw(void *opaque)
3861 BlockDriverAIOCBCoroutine *acb = opaque;
3862 BlockDriverState *bs = acb->common.bs;
3864 if (!acb->is_write) {
3865 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector,
3866 acb->req.nb_sectors, acb->req.qiov, 0);
3867 } else {
3868 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector,
3869 acb->req.nb_sectors, acb->req.qiov, 0);
3872 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3873 qemu_bh_schedule(acb->bh);
3876 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
3877 int64_t sector_num,
3878 QEMUIOVector *qiov,
3879 int nb_sectors,
3880 BlockDriverCompletionFunc *cb,
3881 void *opaque,
3882 bool is_write)
3884 Coroutine *co;
3885 BlockDriverAIOCBCoroutine *acb;
3887 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
3888 acb->req.sector = sector_num;
3889 acb->req.nb_sectors = nb_sectors;
3890 acb->req.qiov = qiov;
3891 acb->is_write = is_write;
3892 acb->done = NULL;
3894 co = qemu_coroutine_create(bdrv_co_do_rw);
3895 qemu_coroutine_enter(co, acb);
3897 return &acb->common;
3900 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
3902 BlockDriverAIOCBCoroutine *acb = opaque;
3903 BlockDriverState *bs = acb->common.bs;
3905 acb->req.error = bdrv_co_flush(bs);
3906 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3907 qemu_bh_schedule(acb->bh);
3910 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
3911 BlockDriverCompletionFunc *cb, void *opaque)
3913 trace_bdrv_aio_flush(bs, opaque);
3915 Coroutine *co;
3916 BlockDriverAIOCBCoroutine *acb;
3918 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
3919 acb->done = NULL;
3921 co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
3922 qemu_coroutine_enter(co, acb);
3924 return &acb->common;
3927 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
3929 BlockDriverAIOCBCoroutine *acb = opaque;
3930 BlockDriverState *bs = acb->common.bs;
3932 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors);
3933 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb);
3934 qemu_bh_schedule(acb->bh);
3937 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs,
3938 int64_t sector_num, int nb_sectors,
3939 BlockDriverCompletionFunc *cb, void *opaque)
3941 Coroutine *co;
3942 BlockDriverAIOCBCoroutine *acb;
3944 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque);
3946 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
3947 acb->req.sector = sector_num;
3948 acb->req.nb_sectors = nb_sectors;
3949 acb->done = NULL;
3950 co = qemu_coroutine_create(bdrv_aio_discard_co_entry);
3951 qemu_coroutine_enter(co, acb);
3953 return &acb->common;
3956 void bdrv_init(void)
3958 module_call_init(MODULE_INIT_BLOCK);
3961 void bdrv_init_with_whitelist(void)
3963 use_bdrv_whitelist = 1;
3964 bdrv_init();
3967 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
3968 BlockDriverCompletionFunc *cb, void *opaque)
3970 BlockDriverAIOCB *acb;
3972 acb = g_slice_alloc(aiocb_info->aiocb_size);
3973 acb->aiocb_info = aiocb_info;
3974 acb->bs = bs;
3975 acb->cb = cb;
3976 acb->opaque = opaque;
3977 return acb;
3980 void qemu_aio_release(void *p)
3982 BlockDriverAIOCB *acb = p;
3983 g_slice_free1(acb->aiocb_info->aiocb_size, acb);
3986 /**************************************************************/
3987 /* Coroutine block device emulation */
3989 typedef struct CoroutineIOCompletion {
3990 Coroutine *coroutine;
3991 int ret;
3992 } CoroutineIOCompletion;
3994 static void bdrv_co_io_em_complete(void *opaque, int ret)
3996 CoroutineIOCompletion *co = opaque;
3998 co->ret = ret;
3999 qemu_coroutine_enter(co->coroutine, NULL);
4002 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num,
4003 int nb_sectors, QEMUIOVector *iov,
4004 bool is_write)
4006 CoroutineIOCompletion co = {
4007 .coroutine = qemu_coroutine_self(),
4009 BlockDriverAIOCB *acb;
4011 if (is_write) {
4012 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors,
4013 bdrv_co_io_em_complete, &co);
4014 } else {
4015 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors,
4016 bdrv_co_io_em_complete, &co);
4019 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb);
4020 if (!acb) {
4021 return -EIO;
4023 qemu_coroutine_yield();
4025 return co.ret;
4028 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs,
4029 int64_t sector_num, int nb_sectors,
4030 QEMUIOVector *iov)
4032 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false);
4035 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs,
4036 int64_t sector_num, int nb_sectors,
4037 QEMUIOVector *iov)
4039 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true);
4042 static void coroutine_fn bdrv_flush_co_entry(void *opaque)
4044 RwCo *rwco = opaque;
4046 rwco->ret = bdrv_co_flush(rwco->bs);
4049 int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
4051 int ret;
4053 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
4054 return 0;
4057 /* Write back cached data to the OS even with cache=unsafe */
4058 if (bs->drv->bdrv_co_flush_to_os) {
4059 ret = bs->drv->bdrv_co_flush_to_os(bs);
4060 if (ret < 0) {
4061 return ret;
4065 /* But don't actually force it to the disk with cache=unsafe */
4066 if (bs->open_flags & BDRV_O_NO_FLUSH) {
4067 goto flush_parent;
4070 if (bs->drv->bdrv_co_flush_to_disk) {
4071 ret = bs->drv->bdrv_co_flush_to_disk(bs);
4072 } else if (bs->drv->bdrv_aio_flush) {
4073 BlockDriverAIOCB *acb;
4074 CoroutineIOCompletion co = {
4075 .coroutine = qemu_coroutine_self(),
4078 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co);
4079 if (acb == NULL) {
4080 ret = -EIO;
4081 } else {
4082 qemu_coroutine_yield();
4083 ret = co.ret;
4085 } else {
4087 * Some block drivers always operate in either writethrough or unsafe
4088 * mode and don't support bdrv_flush therefore. Usually qemu doesn't
4089 * know how the server works (because the behaviour is hardcoded or
4090 * depends on server-side configuration), so we can't ensure that
4091 * everything is safe on disk. Returning an error doesn't work because
4092 * that would break guests even if the server operates in writethrough
4093 * mode.
4095 * Let's hope the user knows what he's doing.
4097 ret = 0;
4099 if (ret < 0) {
4100 return ret;
4103 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH
4104 * in the case of cache=unsafe, so there are no useless flushes.
4106 flush_parent:
4107 return bdrv_co_flush(bs->file);
4110 void bdrv_invalidate_cache(BlockDriverState *bs)
4112 if (bs->drv && bs->drv->bdrv_invalidate_cache) {
4113 bs->drv->bdrv_invalidate_cache(bs);
4117 void bdrv_invalidate_cache_all(void)
4119 BlockDriverState *bs;
4121 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4122 bdrv_invalidate_cache(bs);
4126 void bdrv_clear_incoming_migration_all(void)
4128 BlockDriverState *bs;
4130 QTAILQ_FOREACH(bs, &bdrv_states, list) {
4131 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);
4135 int bdrv_flush(BlockDriverState *bs)
4137 Coroutine *co;
4138 RwCo rwco = {
4139 .bs = bs,
4140 .ret = NOT_DONE,
4143 if (qemu_in_coroutine()) {
4144 /* Fast-path if already in coroutine context */
4145 bdrv_flush_co_entry(&rwco);
4146 } else {
4147 co = qemu_coroutine_create(bdrv_flush_co_entry);
4148 qemu_coroutine_enter(co, &rwco);
4149 while (rwco.ret == NOT_DONE) {
4150 qemu_aio_wait();
4154 return rwco.ret;
4157 static void coroutine_fn bdrv_discard_co_entry(void *opaque)
4159 RwCo *rwco = opaque;
4161 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);
4164 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num,
4165 int nb_sectors)
4167 if (!bs->drv) {
4168 return -ENOMEDIUM;
4169 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) {
4170 return -EIO;
4171 } else if (bs->read_only) {
4172 return -EROFS;
4175 if (bs->dirty_bitmap) {
4176 set_dirty_bitmap(bs, sector_num, nb_sectors, 0);
4179 if (bs->drv->bdrv_co_discard) {
4180 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);
4181 } else if (bs->drv->bdrv_aio_discard) {
4182 BlockDriverAIOCB *acb;
4183 CoroutineIOCompletion co = {
4184 .coroutine = qemu_coroutine_self(),
4187 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors,
4188 bdrv_co_io_em_complete, &co);
4189 if (acb == NULL) {
4190 return -EIO;
4191 } else {
4192 qemu_coroutine_yield();
4193 return co.ret;
4195 } else {
4196 return 0;
4200 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors)
4202 Coroutine *co;
4203 RwCo rwco = {
4204 .bs = bs,
4205 .sector_num = sector_num,
4206 .nb_sectors = nb_sectors,
4207 .ret = NOT_DONE,
4210 if (qemu_in_coroutine()) {
4211 /* Fast-path if already in coroutine context */
4212 bdrv_discard_co_entry(&rwco);
4213 } else {
4214 co = qemu_coroutine_create(bdrv_discard_co_entry);
4215 qemu_coroutine_enter(co, &rwco);
4216 while (rwco.ret == NOT_DONE) {
4217 qemu_aio_wait();
4221 return rwco.ret;
4224 /**************************************************************/
4225 /* removable device support */
4228 * Return TRUE if the media is present
4230 int bdrv_is_inserted(BlockDriverState *bs)
4232 BlockDriver *drv = bs->drv;
4234 if (!drv)
4235 return 0;
4236 if (!drv->bdrv_is_inserted)
4237 return 1;
4238 return drv->bdrv_is_inserted(bs);
4242 * Return whether the media changed since the last call to this
4243 * function, or -ENOTSUP if we don't know. Most drivers don't know.
4245 int bdrv_media_changed(BlockDriverState *bs)
4247 BlockDriver *drv = bs->drv;
4249 if (drv && drv->bdrv_media_changed) {
4250 return drv->bdrv_media_changed(bs);
4252 return -ENOTSUP;
4256 * If eject_flag is TRUE, eject the media. Otherwise, close the tray
4258 void bdrv_eject(BlockDriverState *bs, bool eject_flag)
4260 BlockDriver *drv = bs->drv;
4262 if (drv && drv->bdrv_eject) {
4263 drv->bdrv_eject(bs, eject_flag);
4266 if (bs->device_name[0] != '\0') {
4267 bdrv_emit_qmp_eject_event(bs, eject_flag);
4272 * Lock or unlock the media (if it is locked, the user won't be able
4273 * to eject it manually).
4275 void bdrv_lock_medium(BlockDriverState *bs, bool locked)
4277 BlockDriver *drv = bs->drv;
4279 trace_bdrv_lock_medium(bs, locked);
4281 if (drv && drv->bdrv_lock_medium) {
4282 drv->bdrv_lock_medium(bs, locked);
4286 /* needed for generic scsi interface */
4288 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4290 BlockDriver *drv = bs->drv;
4292 if (drv && drv->bdrv_ioctl)
4293 return drv->bdrv_ioctl(bs, req, buf);
4294 return -ENOTSUP;
4297 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
4298 unsigned long int req, void *buf,
4299 BlockDriverCompletionFunc *cb, void *opaque)
4301 BlockDriver *drv = bs->drv;
4303 if (drv && drv->bdrv_aio_ioctl)
4304 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
4305 return NULL;
4308 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align)
4310 bs->buffer_alignment = align;
4313 void *qemu_blockalign(BlockDriverState *bs, size_t size)
4315 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
4319 * Check if all memory in this vector is sector aligned.
4321 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
4323 int i;
4325 for (i = 0; i < qiov->niov; i++) {
4326 if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
4327 return false;
4331 return true;
4334 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
4336 int64_t bitmap_size;
4338 bs->dirty_count = 0;
4339 if (enable) {
4340 if (!bs->dirty_bitmap) {
4341 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
4342 BDRV_SECTORS_PER_DIRTY_CHUNK * BITS_PER_LONG - 1;
4343 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * BITS_PER_LONG;
4345 bs->dirty_bitmap = g_new0(unsigned long, bitmap_size);
4347 } else {
4348 if (bs->dirty_bitmap) {
4349 g_free(bs->dirty_bitmap);
4350 bs->dirty_bitmap = NULL;
4355 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
4357 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
4359 if (bs->dirty_bitmap &&
4360 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
4361 return !!(bs->dirty_bitmap[chunk / BITS_PER_LONG] &
4362 (1UL << (chunk % BITS_PER_LONG)));
4363 } else {
4364 return 0;
4368 int64_t bdrv_get_next_dirty(BlockDriverState *bs, int64_t sector)
4370 int64_t chunk;
4371 int bit, elem;
4373 /* Avoid an infinite loop. */
4374 assert(bs->dirty_count > 0);
4376 sector = (sector | (BDRV_SECTORS_PER_DIRTY_CHUNK - 1)) + 1;
4377 chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
4379 QEMU_BUILD_BUG_ON(sizeof(bs->dirty_bitmap[0]) * 8 != BITS_PER_LONG);
4380 elem = chunk / BITS_PER_LONG;
4381 bit = chunk % BITS_PER_LONG;
4382 for (;;) {
4383 if (sector >= bs->total_sectors) {
4384 sector = 0;
4385 bit = elem = 0;
4387 if (bit == 0 && bs->dirty_bitmap[elem] == 0) {
4388 sector += BDRV_SECTORS_PER_DIRTY_CHUNK * BITS_PER_LONG;
4389 elem++;
4390 } else {
4391 if (bs->dirty_bitmap[elem] & (1UL << bit)) {
4392 return sector;
4394 sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
4395 if (++bit == BITS_PER_LONG) {
4396 bit = 0;
4397 elem++;
4403 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector,
4404 int nr_sectors)
4406 set_dirty_bitmap(bs, cur_sector, nr_sectors, 1);
4409 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
4410 int nr_sectors)
4412 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
4415 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
4417 return bs->dirty_count;
4420 void bdrv_set_in_use(BlockDriverState *bs, int in_use)
4422 assert(bs->in_use != in_use);
4423 bs->in_use = in_use;
4426 int bdrv_in_use(BlockDriverState *bs)
4428 return bs->in_use;
4431 void bdrv_iostatus_enable(BlockDriverState *bs)
4433 bs->iostatus_enabled = true;
4434 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
4437 /* The I/O status is only enabled if the drive explicitly
4438 * enables it _and_ the VM is configured to stop on errors */
4439 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs)
4441 return (bs->iostatus_enabled &&
4442 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC ||
4443 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP ||
4444 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP));
4447 void bdrv_iostatus_disable(BlockDriverState *bs)
4449 bs->iostatus_enabled = false;
4452 void bdrv_iostatus_reset(BlockDriverState *bs)
4454 if (bdrv_iostatus_is_enabled(bs)) {
4455 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
4456 if (bs->job) {
4457 block_job_iostatus_reset(bs->job);
4462 void bdrv_iostatus_set_err(BlockDriverState *bs, int error)
4464 assert(bdrv_iostatus_is_enabled(bs));
4465 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
4466 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
4467 BLOCK_DEVICE_IO_STATUS_FAILED;
4471 void
4472 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes,
4473 enum BlockAcctType type)
4475 assert(type < BDRV_MAX_IOTYPE);
4477 cookie->bytes = bytes;
4478 cookie->start_time_ns = get_clock();
4479 cookie->type = type;
4482 void
4483 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie)
4485 assert(cookie->type < BDRV_MAX_IOTYPE);
4487 bs->nr_bytes[cookie->type] += cookie->bytes;
4488 bs->nr_ops[cookie->type]++;
4489 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns;
4492 void bdrv_img_create(const char *filename, const char *fmt,
4493 const char *base_filename, const char *base_fmt,
4494 char *options, uint64_t img_size, int flags, Error **errp)
4496 QEMUOptionParameter *param = NULL, *create_options = NULL;
4497 QEMUOptionParameter *backing_fmt, *backing_file, *size;
4498 BlockDriverState *bs = NULL;
4499 BlockDriver *drv, *proto_drv;
4500 BlockDriver *backing_drv = NULL;
4501 int ret = 0;
4503 /* Find driver and parse its options */
4504 drv = bdrv_find_format(fmt);
4505 if (!drv) {
4506 error_setg(errp, "Unknown file format '%s'", fmt);
4507 return;
4510 proto_drv = bdrv_find_protocol(filename);
4511 if (!proto_drv) {
4512 error_setg(errp, "Unknown protocol '%s'", filename);
4513 return;
4516 create_options = append_option_parameters(create_options,
4517 drv->create_options);
4518 create_options = append_option_parameters(create_options,
4519 proto_drv->create_options);
4521 /* Create parameter list with default values */
4522 param = parse_option_parameters("", create_options, param);
4524 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);
4526 /* Parse -o options */
4527 if (options) {
4528 param = parse_option_parameters(options, create_options, param);
4529 if (param == NULL) {
4530 error_setg(errp, "Invalid options for file format '%s'.", fmt);
4531 goto out;
4535 if (base_filename) {
4536 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,
4537 base_filename)) {
4538 error_setg(errp, "Backing file not supported for file format '%s'",
4539 fmt);
4540 goto out;
4544 if (base_fmt) {
4545 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {
4546 error_setg(errp, "Backing file format not supported for file "
4547 "format '%s'", fmt);
4548 goto out;
4552 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
4553 if (backing_file && backing_file->value.s) {
4554 if (!strcmp(filename, backing_file->value.s)) {
4555 error_setg(errp, "Error: Trying to create an image with the "
4556 "same filename as the backing file");
4557 goto out;
4561 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
4562 if (backing_fmt && backing_fmt->value.s) {
4563 backing_drv = bdrv_find_format(backing_fmt->value.s);
4564 if (!backing_drv) {
4565 error_setg(errp, "Unknown backing file format '%s'",
4566 backing_fmt->value.s);
4567 goto out;
4571 // The size for the image must always be specified, with one exception:
4572 // If we are using a backing file, we can obtain the size from there
4573 size = get_option_parameter(param, BLOCK_OPT_SIZE);
4574 if (size && size->value.n == -1) {
4575 if (backing_file && backing_file->value.s) {
4576 uint64_t size;
4577 char buf[32];
4578 int back_flags;
4580 /* backing files always opened read-only */
4581 back_flags =
4582 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
4584 bs = bdrv_new("");
4586 ret = bdrv_open(bs, backing_file->value.s, back_flags, backing_drv);
4587 if (ret < 0) {
4588 error_setg_errno(errp, -ret, "Could not open '%s'",
4589 backing_file->value.s);
4590 goto out;
4592 bdrv_get_geometry(bs, &size);
4593 size *= 512;
4595 snprintf(buf, sizeof(buf), "%" PRId64, size);
4596 set_option_parameter(param, BLOCK_OPT_SIZE, buf);
4597 } else {
4598 error_setg(errp, "Image creation needs a size parameter");
4599 goto out;
4603 printf("Formatting '%s', fmt=%s ", filename, fmt);
4604 print_option_parameters(param);
4605 puts("");
4607 ret = bdrv_create(drv, filename, param);
4608 if (ret < 0) {
4609 if (ret == -ENOTSUP) {
4610 error_setg(errp,"Formatting or formatting option not supported for "
4611 "file format '%s'", fmt);
4612 } else if (ret == -EFBIG) {
4613 error_setg(errp, "The image size is too large for file format '%s'",
4614 fmt);
4615 } else {
4616 error_setg(errp, "%s: error while creating %s: %s", filename, fmt,
4617 strerror(-ret));
4621 out:
4622 free_option_parameters(create_options);
4623 free_option_parameters(param);
4625 if (bs) {
4626 bdrv_delete(bs);